⚡️ Speed up function numerical_integration_rectangle by 105%

[codeflash-ai]

📄 105% (1.05x) speedup for numerical_integration_rectangle in src/numerical/calculus.py

⏱️ Runtime : 3.04 milliseconds → 1.48 milliseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 105% speedup by replacing the Python for-loop with vectorized NumPy operations when possible, while maintaining a fallback for non-vectorizable functions.

Key Optimizations

1. Vectorized Array Generation
Instead of computing x = a + i * h in each loop iteration (34,839 times in the profile), the code generates all x-values at once using xs = a + np.arange(n) * h. This single vectorized operation is dramatically faster than repeated scalar arithmetic in Python.

2. Vectorized Function Application
The optimization attempts to call f(xs) on the entire array at once. If the function f supports vectorization (like lambda x: x**2), NumPy's C-optimized routines handle all evaluations simultaneously instead of 34,839 individual Python function calls.

3. Vectorized Summation
np.sum(vals) uses NumPy's optimized C implementation instead of accumulating values in a Python loop, eliminating the overhead of 34,839 addition operations in the interpreter.

Performance Impact

The line profiler shows the dramatic shift in execution time:

• Original: 54.1% of time spent in result += f(x) calls (27.4ms of 50.7ms)
• Optimized: When vectorization succeeds, only 3.7% spent in np.sum() (0.6ms of 17.3ms)

Test Results Analysis:

• Large n values (≥1000): Show 400-1000% speedups because vectorization overhead is amortized over many computations

  • test_quadratic_function (n=1000): 980% faster
  • test_large_interval (n=1000): 460% faster
  • test_large_scale_polynomial (n=1000): 421% faster

• Small n values (<100): Show slowdowns of 20-90% due to NumPy import overhead and array creation costs exceeding the benefit

  • test_single_subinterval (n=1): 87.2% slower
  • test_small_n (n=2): 84.0% slower

• Non-vectorizable functions: Fall back to the original loop, showing minimal overhead from the try-except (functions with conditionals like test_step_function)

Why This Works

The speedup comes from:

1. Reduced interpreter overhead: One vectorized operation vs. thousands of Python bytecode instructions
2. CPU cache efficiency: Contiguous array operations leverage modern CPU vectorization (SIMD)
3. Optimized C code: NumPy operations run in compiled C, not interpreted Python

This optimization is particularly valuable for numerical integration workloads where n is typically large (hundreds to thousands) to achieve acceptable accuracy, making the vectorization overhead negligible compared to the performance gain.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import math  # used for math functions in test cases

# function to test
from typing import Callable

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

# unit tests

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


def test_constant_function():
    # f(x) = 2 over [0, 5], area should be 2 * 5 = 10
    codeflash_output = numerical_integration_rectangle(lambda x: 2, 0, 5, 100)
    result = codeflash_output  # 8.17μs -> 10.6μs (23.1% slower)


def test_linear_function():
    # f(x) = x over [0, 1], exact integral is 0.5
    codeflash_output = numerical_integration_rectangle(lambda x: x, 0, 1, 100)
    result = codeflash_output  # 7.33μs -> 8.21μs (10.6% slower)


def test_quadratic_function():
    # f(x) = x^2 over [0, 1], exact integral is 1/3
    codeflash_output = numerical_integration_rectangle(lambda x: x**2, 0, 1, 1000)
    result = codeflash_output  # 113μs -> 10.5μs (980% faster)


def test_negative_bounds():
    # f(x) = x over [-1, 1], exact integral is 0
    codeflash_output = numerical_integration_rectangle(lambda x: x, -1, 1, 100)
    result = codeflash_output  # 6.96μs -> 8.12μs (14.4% slower)


def test_reverse_bounds():
    # f(x) = x^2 over [1, 0], should be same as [0, 1]
    codeflash_output = numerical_integration_rectangle(lambda x: x**2, 0, 1, 1000)
    res1 = codeflash_output  # 113μs -> 10.6μs (969% faster)
    codeflash_output = numerical_integration_rectangle(lambda x: x**2, 1, 0, 1000)
    res2 = codeflash_output  # 114μs -> 8.17μs (1298% faster)


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


def test_single_subinterval():
    # n=1, f(x) = x over [0, 1], rectangle at x=0, so area = f(0)*1 = 0
    codeflash_output = numerical_integration_rectangle(lambda x: x, 0, 1, 1)
    result = codeflash_output  # 1.00μs -> 7.83μs (87.2% slower)


def test_zero_width_interval():
    # a == b, area should be zero regardless of function
    codeflash_output = numerical_integration_rectangle(lambda x: x**3, 2, 2, 10)
    result = codeflash_output  # 2.33μs -> 9.17μs (74.5% slower)


def test_large_a_smaller_b():
    # a > b, should swap and compute as normal
    codeflash_output = numerical_integration_rectangle(lambda x: x + 1, 5, 2, 100)
    result = codeflash_output  # 9.12μs -> 9.12μs (0.000% faster)
    codeflash_output = numerical_integration_rectangle(lambda x: x + 1, 2, 5, 100)
    expected = codeflash_output  # 8.12μs -> 6.58μs (23.4% faster)


def test_function_with_discontinuity():
    # f(x) = 1 if x < 0.5 else 2, over [0, 1]
    def f(x):
        return 1 if x < 0.5 else 2

    codeflash_output = numerical_integration_rectangle(f, 0, 1, 100)
    result = codeflash_output  # 8.83μs -> 14.6μs (39.4% slower)


def test_function_with_negative_values():
    # f(x) = -x over [0, 1], exact integral is -0.5
    codeflash_output = numerical_integration_rectangle(lambda x: -x, 0, 1, 100)
    result = codeflash_output  # 8.00μs -> 8.58μs (6.80% slower)


def test_small_n():
    # f(x) = x^2 over [0, 1], n=2, left rectangles: f(0) and f(0.5)
    # area = (f(0) + f(0.5)) * 0.5 = (0 + 0.25) * 0.5 = 0.125
    codeflash_output = numerical_integration_rectangle(lambda x: x**2, 0, 1, 2)
    result = codeflash_output  # 1.33μs -> 8.33μs (84.0% slower)


def test_negative_n_raises():
    # n must be positive; function should fail or behave incorrectly if n <= 0
    with pytest.raises(ZeroDivisionError):
        numerical_integration_rectangle(
            lambda x: x, 0, 1, 0
        )  # 709ns -> 708ns (0.141% faster)


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


def test_large_n_accuracy():
    # f(x) = sin(x) over [0, pi], exact integral is 2
    codeflash_output = numerical_integration_rectangle(math.sin, 0, math.pi, 1000)
    result = codeflash_output  # 69.8μs -> 79.9μs (12.6% slower)


def test_large_interval():
    # f(x) = 1 over [0, 1000], area should be 1000
    codeflash_output = numerical_integration_rectangle(lambda x: 1, 0, 1000, 1000)
    result = codeflash_output  # 69.3μs -> 12.4μs (460% faster)


def test_large_scale_polynomial():
    # f(x) = x^3 over [0, 10], exact integral is x^4/4 from 0 to 10 = 2500
    codeflash_output = numerical_integration_rectangle(lambda x: x**3, 0, 10, 1000)
    result = codeflash_output  # 113μs -> 21.8μs (421% faster)


def test_performance_large_n():
    # f(x) = x, large n, test should finish quickly and not crash
    codeflash_output = numerical_integration_rectangle(lambda x: x, 0, 100, 1000)
    result = codeflash_output  # 61.4μs -> 9.88μs (522% faster)


# ------------------------
# Additional Edge Cases
# ------------------------


def test_function_returns_float():
    # Ensure function works with float return values
    codeflash_output = numerical_integration_rectangle(lambda x: float(x), 0, 1, 100)
    result = codeflash_output  # 8.33μs -> 13.0μs (35.7% slower)


def test_function_returns_int():
    # Ensure function works with int return values
    codeflash_output = numerical_integration_rectangle(
        lambda x: int(x >= 0.5), 0, 1, 100
    )
    result = codeflash_output  # 10.3μs -> 15.8μs (34.8% slower)


def test_function_with_side_effects():
    # Ensure function is called exactly n times
    calls = []

    def f(x):
        calls.append(x)
        return x

    codeflash_output = numerical_integration_rectangle(f, 0, 1, 100)
    result = codeflash_output  # 10.0μs -> 8.17μs (23.0% 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
from typing import Callable

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

# unit tests


class TestBasicIntegration:
    """Test basic integration scenarios with simple functions"""

    def test_constant_function_positive(self):
        # Test: integral of f(x) = 5 from 0 to 10 should be 50
        # Using left rectangle rule, should be exact for constants
        def f(x):
            return 5.0

        codeflash_output = numerical_integration_rectangle(f, 0, 10, 100)
        result = codeflash_output  # 6.83μs -> 8.88μs (23.0% slower)

    def test_linear_function_through_origin(self):
        # Test: integral of f(x) = x from 0 to 10 should be 50
        # Left rectangle rule will underestimate, but should be close with many rectangles
        def f(x):
            return x

        codeflash_output = numerical_integration_rectangle(f, 0, 10, 1000)
        result = codeflash_output  # 61.5μs -> 10.1μs (510% faster)

    def test_linear_function_with_intercept(self):
        # Test: integral of f(x) = 2x + 1 from 0 to 5
        # Exact value: [x² + x] from 0 to 5 = 25 + 5 = 30
        def f(x):
            return 2 * x + 1

        codeflash_output = numerical_integration_rectangle(f, 0, 5, 500)
        result = codeflash_output  # 45.2μs -> 11.0μs (311% faster)

    def test_quadratic_function(self):
        # Test: integral of f(x) = x² from 0 to 3
        # Exact value: [x³/3] from 0 to 3 = 9
        def f(x):
            return x * x

        codeflash_output = numerical_integration_rectangle(f, 0, 3, 1000)
        result = codeflash_output  # 66.5μs -> 10.8μs (516% faster)

    def test_simple_polynomial(self):
        # Test: integral of f(x) = x³ from 0 to 2
        # Exact value: [x⁴/4] from 0 to 2 = 16/4 = 4
        def f(x):
            return x**3

        codeflash_output = numerical_integration_rectangle(f, 0, 2, 1000)
        result = codeflash_output  # 114μs -> 21.8μs (426% faster)


class TestIntervalEdgeCases:
    """Test edge cases related to integration interval properties"""

    def test_reversed_interval(self):
        # Test: when a > b, function should swap them
        # integral of f(x) = 2 from 5 to 0 should equal integral from 0 to 5
        def f(x):
            return 2.0

        codeflash_output = numerical_integration_rectangle(f, 5, 0, 100)
        result = codeflash_output  # 6.88μs -> 8.92μs (22.9% slower)
        codeflash_output = numerical_integration_rectangle(f, 0, 5, 100)
        expected = codeflash_output  # 5.96μs -> 6.46μs (7.76% slower)

    def test_zero_width_interval(self):
        # Test: when a == b, integral should be 0
        def f(x):
            return x * x

        codeflash_output = numerical_integration_rectangle(f, 5, 5, 10)
        result = codeflash_output  # 1.79μs -> 8.42μs (78.7% slower)

    def test_negative_interval(self):
        # Test: integral over negative interval
        # integral of f(x) = x from -5 to -1
        # Exact value: [x²/2] from -5 to -1 = 0.5 - 12.5 = -12
        def f(x):
            return x

        codeflash_output = numerical_integration_rectangle(f, -5, -1, 1000)
        result = codeflash_output  # 61.5μs -> 9.79μs (528% faster)

    def test_interval_crossing_zero(self):
        # Test: integral crossing zero
        # integral of f(x) = x from -2 to 2 should be 0
        def f(x):
            return x

        codeflash_output = numerical_integration_rectangle(f, -2, 2, 1000)
        result = codeflash_output  # 61.2μs -> 9.75μs (527% faster)

    def test_small_interval(self):
        # Test: very small interval
        # integral of f(x) = 10 from 0 to 0.01 should be 0.1
        def f(x):
            return 10.0

        codeflash_output = numerical_integration_rectangle(f, 0, 0.01, 100)
        result = codeflash_output  # 7.04μs -> 9.00μs (21.8% slower)


class TestRectangleCountEdgeCases:
    """Test edge cases related to the number of rectangles"""

    def test_single_rectangle(self):
        # Test: n = 1, single rectangle
        # For f(x) = 3 from 0 to 5, should give 3 * 5 = 15
        def f(x):
            return 3.0

        codeflash_output = numerical_integration_rectangle(f, 0, 5, 1)
        result = codeflash_output  # 1.00μs -> 8.50μs (88.2% slower)

    def test_two_rectangles(self):
        # Test: n = 2, two rectangles
        # For f(x) = 2 from 0 to 4, should give 2 * 4 = 8
        def f(x):
            return 2.0

        codeflash_output = numerical_integration_rectangle(f, 0, 4, 2)
        result = codeflash_output  # 1.08μs -> 8.42μs (87.1% slower)

    def test_three_rectangles(self):
        # Test: n = 3, three rectangles
        # For f(x) = 1 from 0 to 6, should give 1 * 6 = 6
        def f(x):
            return 1.0

        codeflash_output = numerical_integration_rectangle(f, 0, 6, 3)
        result = codeflash_output  # 1.21μs -> 8.58μs (85.9% slower)

    def test_many_rectangles_improves_accuracy(self):
        # Test: more rectangles should give better approximation
        # For f(x) = x² from 0 to 1, exact integral is 1/3
        def f(x):
            return x * x

        codeflash_output = numerical_integration_rectangle(f, 0, 1, 10)
        result_10 = codeflash_output  # 1.75μs -> 8.46μs (79.3% slower)
        codeflash_output = numerical_integration_rectangle(f, 0, 1, 100)
        result_100 = codeflash_output  # 6.79μs -> 6.04μs (12.4% faster)
        codeflash_output = numerical_integration_rectangle(f, 0, 1, 1000)
        result_1000 = codeflash_output  # 65.2μs -> 7.92μs (724% faster)

        # Error should decrease as n increases
        error_10 = abs(result_10 - 1 / 3)
        error_100 = abs(result_100 - 1 / 3)
        error_1000 = abs(result_1000 - 1 / 3)


class TestFunctionBehaviorEdgeCases:
    """Test edge cases related to function behavior"""

    def test_zero_function(self):
        # Test: function that always returns zero
        def f(x):
            return 0.0

        codeflash_output = numerical_integration_rectangle(f, 0, 10, 100)
        result = codeflash_output  # 6.79μs -> 8.62μs (21.3% slower)

    def test_negative_function(self):
        # Test: function with negative values
        # integral of f(x) = -2 from 0 to 5 should be -10
        def f(x):
            return -2.0

        codeflash_output = numerical_integration_rectangle(f, 0, 5, 100)
        result = codeflash_output  # 6.88μs -> 8.62μs (20.3% slower)

    def test_mixed_sign_function(self):
        # Test: function that changes sign
        # f(x) = x - 2 from 0 to 4
        # Integral: [x²/2 - 2x] from 0 to 4 = 8 - 8 = 0
        def f(x):
            return x - 2

        codeflash_output = numerical_integration_rectangle(f, 0, 4, 1000)
        result = codeflash_output  # 81.1μs -> 11.3μs (618% faster)

    def test_step_function(self):
        # Test: step function (discontinuous)
        # f(x) = 1 if x < 5 else 2, from 0 to 10
        # Should give approximately 1*5 + 2*5 = 15
        def f(x):
            return 1.0 if x < 5 else 2.0

        codeflash_output = numerical_integration_rectangle(f, 0, 10, 1000)
        result = codeflash_output  # 79.9μs -> 86.6μs (7.70% slower)

    def test_sine_function(self):
        # Test: integral of sin(x) from 0 to π should be 2
        def f(x):
            return math.sin(x)

        codeflash_output = numerical_integration_rectangle(f, 0, math.pi, 1000)
        result = codeflash_output  # 92.5μs -> 97.6μs (5.17% slower)

    def test_cosine_function(self):
        # Test: integral of cos(x) from 0 to π/2 should be 1
        def f(x):
            return math.cos(x)

        codeflash_output = numerical_integration_rectangle(f, 0, math.pi / 2, 1000)
        result = codeflash_output  # 90.8μs -> 95.8μs (5.30% slower)

    def test_exponential_function(self):
        # Test: integral of e^x from 0 to 1 should be e - 1 ≈ 1.718
        def f(x):
            return math.exp(x)

        codeflash_output = numerical_integration_rectangle(f, 0, 1, 1000)
        result = codeflash_output  # 83.3μs -> 90.5μs (7.92% slower)
        expected = math.e - 1


class TestLargeScaleCases:
    """Test performance and scalability with large data samples"""

    def test_large_number_of_rectangles(self):
        # Test: using 1000 rectangles for better precision
        # integral of f(x) = x² from 0 to 10 should be 1000/3 ≈ 333.33
        def f(x):
            return x * x

        codeflash_output = numerical_integration_rectangle(f, 0, 10, 1000)
        result = codeflash_output  # 66.4μs -> 10.5μs (535% faster)

    def test_wide_interval_many_rectangles(self):
        # Test: wide interval with many rectangles
        # integral of f(x) = 1 from 0 to 1000 should be 1000
        def f(x):
            return 1.0

        codeflash_output = numerical_integration_rectangle(f, 0, 1000, 1000)
        result = codeflash_output  # 60.0μs -> 10.4μs (478% faster)

    def test_oscillating_function_large_scale(self):
        # Test: rapidly oscillating function over large interval
        # integral of sin(x) from 0 to 10π should be close to 0
        def f(x):
            return math.sin(x)

        codeflash_output = numerical_integration_rectangle(f, 0, 10 * math.pi, 1000)
        result = codeflash_output  # 94.6μs -> 99.3μs (4.78% slower)

    def test_large_function_values(self):
        # Test: function with large values
        # integral of f(x) = 1000 from 0 to 100 should be 100000
        def f(x):
            return 1000.0

        codeflash_output = numerical_integration_rectangle(f, 0, 100, 500)
        result = codeflash_output  # 30.1μs -> 9.58μs (214% faster)

    def test_performance_consistency(self):
        # Test: function should produce consistent results
        # Run same integration multiple times
        def f(x):
            return x * x + 2 * x + 1

        codeflash_output = numerical_integration_rectangle(f, 0, 10, 1000)
        result1 = codeflash_output  # 105μs -> 13.6μs (675% faster)
        codeflash_output = numerical_integration_rectangle(f, 0, 10, 1000)
        result2 = codeflash_output  # 103μs -> 10.9μs (848% faster)
        codeflash_output = numerical_integration_rectangle(f, 0, 10, 1000)
        result3 = codeflash_output  # 103μs -> 10.2μs (915% faster)


class TestNumericalPrecision:
    """Test numerical precision and accuracy"""

    def test_very_small_values(self):
        # Test: integration with very small function values
        def f(x):
            return 0.0001

        codeflash_output = numerical_integration_rectangle(f, 0, 10, 100)
        result = codeflash_output  # 6.88μs -> 8.71μs (21.1% slower)

    def test_known_integral_value(self):
        # Test: integral with known exact value
        # integral of 1/x from 1 to e should be 1
        def f(x):
            return 1.0 / x

        codeflash_output = numerical_integration_rectangle(f, 1, math.e, 1000)
        result = codeflash_output  # 74.3μs -> 11.2μs (563% faster)

    def test_symmetric_function(self):
        # Test: symmetric function around midpoint
        # integral of (x-5)² from 0 to 10
        # Should equal integral of x² from -5 to 5
        def f(x):
            return (x - 5) ** 2

        codeflash_output = numerical_integration_rectangle(f, 0, 10, 1000)
        result = codeflash_output  # 134μs -> 11.9μs (1025% faster)

    def test_absolute_value_function(self):
        # Test: absolute value function
        # integral of |x| from -5 to 5 should be 25
        def f(x):
            return abs(x)

        codeflash_output = numerical_integration_rectangle(f, -5, 5, 1000)
        result = codeflash_output  # 73.0μs -> 10.4μs (604% faster)

    def test_piecewise_linear_function(self):
        # Test: piecewise linear function
        # f(x) = x for x < 3, f(x) = 6 - x for x >= 3, from 0 to 6
        # Triangle with area 9
        def f(x):
            return x if x < 3 else 6 - x

        codeflash_output = numerical_integration_rectangle(f, 0, 6, 1000)
        result = codeflash_output  # 87.5μs -> 94.1μs (7.00% slower)


class TestSpecialCases:
    """Test special mathematical cases"""

    def test_square_root_function(self):
        # Test: integral of √x from 0 to 4
        # Exact: [2x^(3/2)/3] from 0 to 4 = 16/3 ≈ 5.33
        def f(x):
            return math.sqrt(x) if x >= 0 else 0

        codeflash_output = numerical_integration_rectangle(f, 0, 4, 1000)
        result = codeflash_output  # 97.4μs -> 103μs (5.80% slower)

    def test_inverse_square_function(self):
        # Test: integral of 1/x² from 1 to 2
        # Exact: [-1/x] from 1 to 2 = -1/2 + 1 = 0.5
        def f(x):
            return 1.0 / (x * x) if x != 0 else 0

        codeflash_output = numerical_integration_rectangle(f, 1, 2, 1000)
        result = codeflash_output  # 98.5μs -> 105μs (6.82% slower)

    def test_logarithmic_function(self):
        # Test: integral of ln(x) from 1 to e
        # Exact: [x*ln(x) - x] from 1 to e = e - e - (0 - 1) = 1
        def f(x):
            return math.log(x) if x > 0 else 0

        codeflash_output = numerical_integration_rectangle(f, 1, math.e, 1000)
        result = codeflash_output  # 108μs -> 114μs (5.81% slower)

    def test_rational_function(self):
        # Test: integral of 1/(1+x²) from 0 to 1
        # Exact: [arctan(x)] from 0 to 1 = π/4 ≈ 0.785
        def f(x):
            return 1.0 / (1 + x * x)

        codeflash_output = numerical_integration_rectangle(f, 0, 1, 1000)
        result = codeflash_output  # 94.7μs -> 12.8μs (640% faster)


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

To edit these changes git checkout codeflash/optimize-numerical_integration_rectangle-mk3ejvdd and push.