⚡️ Speed up function lagrange_interpolation by 32%

[codeflash-ai]

📄 32% (0.32x) speedup for lagrange_interpolation in src/numerical/calculus.py

⏱️ Runtime : 173 milliseconds → 131 milliseconds (best of 37 runs)

📝 Explanation and details

The optimized code achieves a 32% speedup by eliminating repeated tuple indexing operations in the innermost loop, which is executed over 2 million times according to the line profiler results.

Key optimization:
The code precomputes x_vals and y_vals lists at the start, extracting all x and y coordinates from the input tuples once. This transforms repeated points[i][0] and points[j][0] tuple accesses (which are relatively expensive in Python) into simple list lookups using x_vals[i] and x_vals[j].

Why this is faster:
In the original code, the line term *= (x - points[j][0]) / (points[i][0] - points[j][0]) performs 3 tuple index operations per iteration. With ~2.3 million iterations of the inner loop, this amounts to ~7 million tuple accesses. Tuple indexing in Python involves attribute lookup and bounds checking overhead. The optimized version replaces these with direct list accesses to precomputed values, which are faster.

Additionally, storing xi = x_vals[i] in the outer loop avoids repeatedly accessing the same value in the inner loop, providing another minor optimization.

Test case performance:

• Small inputs (< 10 points) show 3-35% slowdown due to the overhead of creating the x_vals and y_vals lists
• Medium inputs (20-50 points) show 11-27% speedup as the benefit of faster access outweighs the setup cost
• Large inputs (100-1000 points) show 20-33% speedup, with the best gains on the largest datasets where the inner loop dominates runtime

Behavioral preservation:
The optimization maintains identical behavior including raising ZeroDivisionError for duplicate x-values, since divisions still occur at each step rather than being batched. Numerical stability is also preserved by performing division incrementally rather than accumulating large products.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import math
import random

# function to test
# src/numerical/calculus.py
from typing import List, Tuple

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

# unit tests

# 1. Basic Test Cases


def test_single_point_exact():
    # Interpolating at a single point should return its y value
    points = [(2.0, 5.0)]
    x = 2.0
    codeflash_output = lagrange_interpolation(
        points, x
    )  # 1.00μs -> 1.33μs (25.0% slower)


def test_two_points_linear_exact():
    # Interpolating between two points (linear) at known x
    points = [(1.0, 3.0), (3.0, 7.0)]
    # The line is y = 2x + 1, so at x=2, y=5
    x = 2.0
    expected = 5.0
    codeflash_output = lagrange_interpolation(points, x)
    result = codeflash_output  # 1.71μs -> 1.79μs (4.69% slower)


def test_three_points_quadratic():
    # Interpolate a quadratic: y = x^2 at x=2, using points (0,0), (1,1), (3,9)
    points = [(0, 0), (1, 1), (3, 9)]
    x = 2.0
    expected = 4.0
    codeflash_output = lagrange_interpolation(points, x)
    result = codeflash_output  # 3.83μs -> 4.38μs (12.4% slower)


def test_interpolate_at_node():
    # Interpolating at a node should return the node's y value exactly
    points = [(0, 0), (2, 4), (4, 16)]
    for x, y in points:
        pass


def test_non_integer_values():
    # Test with non-integer values
    points = [(0.5, 1.5), (1.5, 2.5), (2.5, 4.5)]
    x = 1.0
    # Manually compute expected value
    # L0 = (1-1.5)*(1-2.5)/((0.5-1.5)*(0.5-2.5)) = (-0.5)*(-1.5)/((-1.0)*(-2.0)) = 0.75/2 = 0.375
    # L1 = (1-0.5)*(1-2.5)/((1.5-0.5)*(1.5-2.5)) = (0.5)*(-1.5)/(1.0*-1.0) = -0.75/-1 = 0.75
    # L2 = (1-0.5)*(1-1.5)/((2.5-0.5)*(2.5-1.5)) = (0.5)*(-0.5)/(2.0*1.0) = -0.25/2 = -0.125
    # y = 1.5*0.375 + 2.5*0.75 + 4.5*(-0.125) = 0.5625 + 1.875 - 0.5625 = 1.875
    expected = 1.875
    codeflash_output = lagrange_interpolation(points, x)
    result = codeflash_output  # 2.08μs -> 2.75μs (24.3% slower)


# 2. Edge Test Cases


def test_duplicate_x_points():
    # Should raise ZeroDivisionError if x values are duplicated
    points = [(1.0, 2.0), (1.0, 3.0)]
    with pytest.raises(ZeroDivisionError):
        lagrange_interpolation(points, 1.0)  # 2.00μs -> 2.54μs (21.3% slower)


def test_interpolate_outside_range():
    # Interpolating outside the x range (extrapolation)
    points = [(1.0, 2.0), (2.0, 4.0), (3.0, 8.0)]
    x = 5.0
    # The polynomial is degree 2, so the value is not obvious
    # Compute using the formula
    codeflash_output = lagrange_interpolation(points, x)
    y = codeflash_output  # 2.29μs -> 2.71μs (15.4% slower)


def test_negative_x_values():
    # Test with negative x values
    points = [(-2, 4), (0, 0), (2, 4)]
    x = -1
    # The polynomial is y = x^2, so at x=-1, y=1
    expected = 1.0
    codeflash_output = lagrange_interpolation(points, x)
    result = codeflash_output  # 3.21μs -> 3.54μs (9.40% slower)


def test_high_precision():
    # Test with high-precision floating point values
    points = [(0.1, 0.01), (0.2, 0.04), (0.3, 0.09)]
    x = 0.15
    # The polynomial is y = x^2, so at x=0.15, y=0.0225
    expected = 0.0225
    codeflash_output = lagrange_interpolation(points, x)
    result = codeflash_output  # 2.29μs -> 2.46μs (6.79% slower)


def test_all_y_zero():
    # All y values are zero, result should always be zero
    points = [(-1, 0), (0, 0), (1, 0)]
    for x in [-2, 0, 2]:
        codeflash_output = lagrange_interpolation(
            points, x
        )  # 5.04μs -> 5.83μs (13.6% slower)


def test_single_point_not_exact():
    # Interpolating at a point not in the list with only one point should still return that y value
    points = [(3.0, 7.0)]
    x = 10.0
    codeflash_output = lagrange_interpolation(
        points, x
    )  # 959ns -> 1.25μs (23.3% slower)


def test_large_x_value():
    # Test with a large x value
    points = [(1.0, 2.0), (2.0, 4.0), (3.0, 8.0)]
    x = 1e5
    # Should not overflow, just return a float
    codeflash_output = lagrange_interpolation(points, x)
    y = codeflash_output  # 2.12μs -> 2.67μs (20.3% slower)


def test_large_negative_x_value():
    # Test with a very negative x value
    points = [(1.0, 2.0), (2.0, 4.0), (3.0, 8.0)]
    x = -1e5
    codeflash_output = lagrange_interpolation(points, x)
    y = codeflash_output  # 1.92μs -> 2.38μs (19.3% slower)


# 3. Large Scale Test Cases


def test_large_linear():
    # Interpolate a linear function with many points
    n = 1000
    points = [(float(i), 2.0 * float(i) + 1.0) for i in range(n)]
    x = 500.5
    expected = 2.0 * x + 1.0


def test_large_quadratic():
    # Interpolate a quadratic function with many points
    n = 100
    points = [(float(i), float(i) ** 2 + 2 * float(i) + 1.0) for i in range(n)]
    x = 50.5
    expected = x**2 + 2 * x + 1.0


def test_large_random_points():
    # Interpolate with many random points for a known polynomial
    random.seed(42)
    n = 50

    # y = 3x^3 - 2x^2 + x - 5
    def f(x):
        return 3 * x**3 - 2 * x**2 + x - 5

    xs = sorted(random.uniform(-100, 100) for _ in range(n))
    points = [(x, f(x)) for x in xs]
    # Test at a node
    for i in [0, n // 2, n - 1]:
        x = points[i][0]
        expected = f(x)
        codeflash_output = lagrange_interpolation(points, x)
        result = codeflash_output  # 540μs -> 425μs (27.0% faster)


def test_large_scale_performance():
    # Test that the function completes in a reasonable time for 200 points
    import time

    n = 200
    points = [(float(i), float(i) ** 2) for i in range(n)]
    x = 123.456
    start = time.time()
    codeflash_output = lagrange_interpolation(points, x)
    result = codeflash_output  # 2.80ms -> 2.14ms (30.4% faster)
    duration = time.time() - start


def test_large_scale_all_same_y():
    # All y values are the same, result should always be that y value
    n = 100
    points = [(float(i), 42.0) for i in range(n)]
    for x in [0, 50, 99, 123.456]:
        pass


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

import math

# function to test
# src/numerical/calculus.py
from typing import List, Tuple

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

# unit tests

# 1. Basic Test Cases


def test_single_point():
    # Only one point: the interpolation should always return its y-value
    points = [(2.0, 5.0)]
    codeflash_output = lagrange_interpolation(
        points, 2.0
    )  # 917ns -> 1.33μs (31.3% slower)
    codeflash_output = lagrange_interpolation(
        points, 100.0
    )  # 375ns -> 584ns (35.8% slower)
    codeflash_output = lagrange_interpolation(
        points, -100.0
    )  # 333ns -> 500ns (33.4% slower)


def test_two_points_linear():
    # Two points: should interpolate a straight line
    points = [(1.0, 2.0), (3.0, 6.0)]  # y = 2x
    # At x=1, should return 2
    codeflash_output = lagrange_interpolation(
        points, 1.0
    )  # 1.42μs -> 1.92μs (26.1% slower)
    # At x=3, should return 6
    codeflash_output = lagrange_interpolation(
        points, 3.0
    )  # 667ns -> 917ns (27.3% slower)
    # At x=2, should return 4
    codeflash_output = lagrange_interpolation(
        points, 2.0
    )  # 583ns -> 709ns (17.8% slower)


def test_three_points_quadratic():
    # Three points on y = x^2
    points = [(-1.0, 1.0), (0.0, 0.0), (2.0, 4.0)]
    # At x=-1, should return 1
    codeflash_output = lagrange_interpolation(
        points, -1.0
    )  # 1.96μs -> 2.46μs (20.3% slower)
    # At x=0, should return 0
    codeflash_output = lagrange_interpolation(
        points, 0.0
    )  # 1.21μs -> 1.42μs (14.7% slower)
    # At x=2, should return 4
    codeflash_output = lagrange_interpolation(
        points, 2.0
    )  # 1.12μs -> 1.29μs (12.9% slower)
    # At x=1, should return 1
    codeflash_output = lagrange_interpolation(
        points, 1.0
    )  # 1.08μs -> 1.12μs (3.73% slower)


def test_interpolate_between_points():
    # Interpolate between points not at given x
    points = [(0.0, 0.0), (1.0, 1.0), (2.0, 4.0)]  # y = x^2
    # At x=1.5, should return 2.25
    codeflash_output = lagrange_interpolation(points, 1.5)
    result = codeflash_output  # 1.96μs -> 2.21μs (11.3% slower)


def test_non_integer_points():
    # Interpolate with non-integer x and y
    points = [(0.5, 1.5), (2.5, 6.5), (4.5, 20.5)]
    # At x=2.5, should return 6.5
    codeflash_output = lagrange_interpolation(
        points, 2.5
    )  # 1.83μs -> 2.29μs (20.0% slower)
    # At x=0.5, should return 1.5
    codeflash_output = lagrange_interpolation(
        points, 0.5
    )  # 1.17μs -> 1.21μs (3.47% slower)
    # At x=4.5, should return 20.5
    codeflash_output = lagrange_interpolation(
        points, 4.5
    )  # 1.08μs -> 1.12μs (3.73% slower)


# 2. Edge Test Cases


def test_duplicate_x_raises():
    # Duplicate x values should cause division by zero
    points = [(1.0, 2.0), (1.0, 3.0)]
    with pytest.raises(ZeroDivisionError):
        lagrange_interpolation(points, 1.0)  # 1.46μs -> 1.92μs (23.9% slower)


def test_x_outside_range():
    # Interpolation is not extrapolation, but function should return a value
    points = [(0.0, 0.0), (1.0, 1.0), (2.0, 4.0)]
    # At x far outside, should still return a value (extrapolation)
    codeflash_output = lagrange_interpolation(points, 10.0)
    result = codeflash_output  # 2.04μs -> 2.62μs (22.2% slower)


def test_negative_and_zero_x():
    # Negative and zero x values
    points = [(-2.0, 4.0), (0.0, 0.0), (2.0, 4.0)]
    # At x=0, should return 0
    codeflash_output = lagrange_interpolation(
        points, 0.0
    )  # 2.04μs -> 2.33μs (12.5% slower)
    # At x=-2, should return 4
    codeflash_output = lagrange_interpolation(
        points, -2.0
    )  # 1.17μs -> 1.29μs (9.75% slower)


def test_all_y_equal():
    # All y-values the same: should always return that value
    points = [(1.0, 7.0), (2.0, 7.0), (3.0, 7.0)]
    for x in [-10.0, 0.0, 2.0, 100.0]:
        codeflash_output = lagrange_interpolation(
            points, x
        )  # 5.21μs -> 5.71μs (8.76% slower)


def test_large_and_small_floats():
    # Test with very large and very small float values
    points = [(1e-10, 1e10), (1e10, 1e-10)]


def test_x_exactly_at_point():
    # Test x exactly at one of the points
    points = [(0.0, 10.0), (1.0, 20.0), (2.0, 30.0)]
    codeflash_output = lagrange_interpolation(
        points, 1.0
    )  # 2.08μs -> 2.29μs (9.08% slower)


def test_points_with_negative_y():
    # Negative y-values
    points = [(-1.0, -2.0), (0.0, 0.0), (1.0, 2.0)]
    # At x=0, should return 0
    codeflash_output = lagrange_interpolation(
        points, 0.0
    )  # 1.96μs -> 2.17μs (9.64% slower)
    # At x=-1, should return -2
    codeflash_output = lagrange_interpolation(
        points, -1.0
    )  # 1.08μs -> 1.29μs (16.1% slower)


def test_points_with_non_uniform_spacing():
    # Non-uniform x spacing
    points = [(0.0, 1.0), (2.0, 9.0), (5.0, 36.0)]  # y = (x+1)^2
    # At x=1, should return 4
    codeflash_output = lagrange_interpolation(points, 1.0)
    result = codeflash_output  # 1.96μs -> 2.29μs (14.6% slower)


# 3. Large Scale Test Cases


def test_large_number_of_points_linear():
    # 100 points on y = 2x + 1
    points = [(float(x), 2.0 * x + 1.0) for x in range(100)]
    # Interpolate at x=50.5
    expected = 2.0 * 50.5 + 1.0
    codeflash_output = lagrange_interpolation(points, 50.5)
    result = codeflash_output  # 711μs -> 557μs (27.7% faster)


def test_large_number_of_points_quadratic():
    # 20 points on y = x^2
    points = [(float(x), float(x * x)) for x in range(20)]
    # Interpolate at x=10.5
    expected = 10.5 * 10.5
    codeflash_output = lagrange_interpolation(points, 10.5)
    result = codeflash_output  # 30.7μs -> 25.5μs (20.2% faster)


def test_large_number_of_points_constant():
    # 500 points, all y=42
    points = [(float(x), 42.0) for x in range(500)]
    for x in [0.0, 250.0, 499.0, -100.0, 1000.0]:
        codeflash_output = lagrange_interpolation(
            points, x
        )  # 92.5ms -> 70.3ms (31.6% faster)


def test_large_number_of_points_performance():
    # 1000 points, y = x^2 (performance test, but also correctness)
    points = [(float(x), float(x * x)) for x in range(1000)]
    x = 500.5
    expected = x * x
    codeflash_output = lagrange_interpolation(points, x)
    result = codeflash_output  # 76.5ms -> 57.7ms (32.7% faster)


def test_large_number_of_points_random_y():
    # 100 points, random y values
    import random

    random.seed(42)
    points = [(float(x), random.uniform(-1000, 1000)) for x in range(100)]
    # At x exactly at a known point, should return the y-value
    for idx in [0, 50, 99]:
        x, y = points[idx]


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


def test_lagrange_interpolation():
    lagrange_interpolation([(-1.0, 0.0), (2.0, 0.0)], 0.0)

🔎 Click to see Concolic Coverage Tests

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_7p4fb03p/tmpwx7fxeyl/test_concolic_coverage.py::test_lagrange_interpolation	2.12μs	2.25μs	-5.56%⚠️

To edit these changes git checkout codeflash/optimize-lagrange_interpolation-mjhvaguy and push.