⚡️ Speed up method PointOfInterest.bounding by 21%

[codeflash-ai]

📄 21% (0.21x) speedup for PointOfInterest.bounding in modules/textual_inversion/autocrop.py

⏱️ Runtime : 1.13 milliseconds → 934 microseconds (best of 243 runs)

📝 Explanation and details

The optimization eliminates unnecessary intermediate list creation and mutations by directly constructing the return list in a single expression.

Key changes:

• Removed the pre-allocated bounds = [0, 0, 0, 0] list and four separate assignment operations (bounds[0] = x - half_size, etc.)
• Replaced with direct list construction: return [x - half_size, y - half_size, x + half_size, y + half_size]

Why it's faster:

1. Fewer bytecode operations: The original code requires 5+ operations (list creation + 4 assignments + return), while the optimized version uses just 2 (computation + return)
2. Eliminates list mutation overhead: Python list item assignment (bounds[0] = ...) has additional overhead compared to direct construction
3. Reduces memory operations: No intermediate list object that gets mutated multiple times

Performance characteristics:
The optimization shows consistent 20-40% speedups across all test cases, with particularly strong gains on:

• Large coordinate values (40-42% faster)
• Edge cases like zero/negative sizes (28-35% faster)
• Bulk operations with many points (17-24% faster)

The speedup is uniform because it eliminates fixed overhead regardless of input values, making it especially effective for frequently called methods in performance-critical paths.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from modules.textual_inversion.autocrop import PointOfInterest

# unit tests

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

def test_bounding_basic_center():
    # Test bounding box at origin with size 10
    poi = PointOfInterest(0, 0)
    codeflash_output = poi.bounding(10); bounds = codeflash_output # 819ns -> 639ns (28.2% faster)

def test_bounding_basic_positive_coords():
    # Test bounding box at (10, 10) with size 10
    poi = PointOfInterest(10, 10)
    codeflash_output = poi.bounding(10); bounds = codeflash_output # 818ns -> 652ns (25.5% faster)

def test_bounding_basic_negative_coords():
    # Test bounding box at (-10, -10) with size 10
    poi = PointOfInterest(-10, -10)
    codeflash_output = poi.bounding(10); bounds = codeflash_output # 880ns -> 668ns (31.7% faster)

def test_bounding_basic_different_size():
    # Test bounding box at (5, 5) with size 3
    poi = PointOfInterest(5, 5)
    codeflash_output = poi.bounding(3); bounds = codeflash_output # 843ns -> 615ns (37.1% faster)

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

def test_bounding_edge_size_zero():
    # Test bounding box with size zero
    poi = PointOfInterest(7, 8)
    codeflash_output = poi.bounding(0); bounds = codeflash_output # 1.01μs -> 774ns (30.9% faster)

def test_bounding_edge_size_one():
    # Test bounding box with size one (odd)
    poi = PointOfInterest(2, 3)
    codeflash_output = poi.bounding(1); bounds = codeflash_output # 811ns -> 643ns (26.1% faster)

def test_bounding_edge_large_negative_coords():
    # Test bounding box at large negative coordinates
    poi = PointOfInterest(-999, -999)
    codeflash_output = poi.bounding(10); bounds = codeflash_output # 952ns -> 680ns (40.0% faster)

def test_bounding_edge_large_positive_coords():
    # Test bounding box at large positive coordinates
    poi = PointOfInterest(999, 999)
    codeflash_output = poi.bounding(10); bounds = codeflash_output # 888ns -> 703ns (26.3% faster)

def test_bounding_edge_even_and_odd_sizes():
    # Test bounding box at (0,0) with even and odd sizes
    poi = PointOfInterest(0, 0)
    codeflash_output = poi.bounding(6); bounds_even = codeflash_output # 819ns -> 643ns (27.4% faster)
    codeflash_output = poi.bounding(7); bounds_odd = codeflash_output # 377ns -> 350ns (7.71% faster)

def test_bounding_edge_non_integer_coords():
    # Test bounding box with float coordinates
    poi = PointOfInterest(2.5, 3.5)
    codeflash_output = poi.bounding(4); bounds = codeflash_output # 1.03μs -> 850ns (21.6% faster)

def test_bounding_edge_non_integer_size():
    # Test bounding box with float size (should floor division)
    poi = PointOfInterest(5, 5)
    codeflash_output = poi.bounding(7.9); bounds = codeflash_output # 1.50μs -> 1.38μs (9.31% faster)

def test_bounding_edge_zero_point():
    # Test bounding box at (0,0) with size 0
    poi = PointOfInterest(0, 0)
    codeflash_output = poi.bounding(0); bounds = codeflash_output # 964ns -> 747ns (29.0% faster)

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

def test_bounding_large_scale_many_points():
    # Test bounding for many points in a grid
    size = 10
    half_size = size // 2
    for x in range(-50, 51, 10):  # 11 points
        for y in range(-50, 51, 10):  # 11 points
            poi = PointOfInterest(x, y)
            codeflash_output = poi.bounding(size); bounds = codeflash_output
            expected = [x - half_size, y - half_size, x + half_size, y + half_size]

def test_bounding_large_scale_max_size():
    # Test bounding with maximum allowed size (999)
    poi = PointOfInterest(500, 500)
    codeflash_output = poi.bounding(999); bounds = codeflash_output # 894ns -> 686ns (30.3% faster)
    half_size = 999 // 2  # 499
    expected = [500 - half_size, 500 - half_size, 500 + half_size, 500 + half_size]

def test_bounding_large_scale_randomized():
    # Test bounding for 1000 random points and sizes
    import random
    random.seed(42)
    for _ in range(1000):
        x = random.randint(-500, 500)
        y = random.randint(-500, 500)
        size = random.randint(0, 999)
        poi = PointOfInterest(x, y)
        codeflash_output = poi.bounding(size); bounds = codeflash_output # 282μs -> 239μs (17.5% faster)
        half_size = size // 2
        expected = [x - half_size, y - half_size, x + half_size, y + half_size]

def test_bounding_large_scale_performance():
    # Ensure that the function runs efficiently for 1000 points
    import time
    points = [PointOfInterest(i, i) for i in range(1000)]
    sizes = [i % 100 for i in range(1000)]
    start = time.time()
    for poi, size in zip(points, sizes):
        codeflash_output = poi.bounding(size); bounds = codeflash_output # 250μs -> 205μs (22.0% faster)
        half_size = size // 2
        expected = [poi.x - half_size, poi.y - half_size, poi.x + half_size, poi.y + half_size]
    duration = time.time() - start

# ----------- Mutation Testing: Defensive Checks -----------

def test_bounding_mutation_wrong_order():
    # Ensure bounds are always [min_x, min_y, max_x, max_y]
    poi = PointOfInterest(10, 20)
    codeflash_output = poi.bounding(6); bounds = codeflash_output # 890ns -> 668ns (33.2% faster)

def test_bounding_mutation_size_not_used():
    # Changing size should change bounds
    poi = PointOfInterest(10, 10)
    codeflash_output = poi.bounding(10); bounds1 = codeflash_output # 741ns -> 606ns (22.3% faster)
    codeflash_output = poi.bounding(20); bounds2 = codeflash_output # 320ns -> 303ns (5.61% faster)

def test_bounding_mutation_x_y_not_used():
    # Changing x/y should change bounds
    poi1 = PointOfInterest(10, 10)
    poi2 = PointOfInterest(20, 20)
    codeflash_output = poi1.bounding(10); bounds1 = codeflash_output # 710ns -> 600ns (18.3% faster)
    codeflash_output = poi2.bounding(10); bounds2 = codeflash_output # 309ns -> 291ns (6.19% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest  # used for our unit tests
from modules.textual_inversion.autocrop import PointOfInterest

# unit tests

# ------------------------
# 1. Basic Test Cases
# ------------------------

def test_bounding_center_origin_even_size():
    # Center at (0,0), even size
    poi = PointOfInterest(0, 0)
    codeflash_output = poi.bounding(10); result = codeflash_output # 929ns -> 738ns (25.9% faster)

def test_bounding_center_origin_odd_size():
    # Center at (0,0), odd size
    poi = PointOfInterest(0, 0)
    codeflash_output = poi.bounding(9); result = codeflash_output # 817ns -> 677ns (20.7% faster)

def test_bounding_positive_coordinates():
    # Center at (10, 10), size 6
    poi = PointOfInterest(10, 10)
    codeflash_output = poi.bounding(6); result = codeflash_output # 856ns -> 669ns (28.0% faster)

def test_bounding_negative_coordinates():
    # Center at (-10, -20), size 8
    poi = PointOfInterest(-10, -20)
    codeflash_output = poi.bounding(8); result = codeflash_output # 946ns -> 716ns (32.1% faster)

def test_bounding_nonzero_weight_and_size_unused():
    # Weight and size do not affect bounding
    poi = PointOfInterest(5, 7, weight=3.2, size=99)
    codeflash_output = poi.bounding(4); result = codeflash_output # 866ns -> 640ns (35.3% faster)

# ------------------------
# 2. Edge Test Cases
# ------------------------

def test_bounding_zero_size():
    # Size 0: bounding box is the point itself
    poi = PointOfInterest(3, 4)
    codeflash_output = poi.bounding(0); result = codeflash_output # 968ns -> 755ns (28.2% faster)

def test_bounding_size_one():
    # Size 1: half_size = 0, so all bounds are the point itself
    poi = PointOfInterest(-2, 2)
    codeflash_output = poi.bounding(1); result = codeflash_output # 881ns -> 684ns (28.8% faster)

def test_bounding_large_negative_coordinates():
    # Very large negative coordinates
    poi = PointOfInterest(-999, -999)
    codeflash_output = poi.bounding(8); result = codeflash_output # 951ns -> 709ns (34.1% faster)

def test_bounding_large_positive_coordinates():
    # Very large positive coordinates
    poi = PointOfInterest(999, 999)
    codeflash_output = poi.bounding(8); result = codeflash_output # 896ns -> 708ns (26.6% faster)

def test_bounding_size_is_max_int():
    # Use a very large size
    import sys
    max_int = 999  # within constraint (<1000)
    poi = PointOfInterest(0, 0)
    codeflash_output = poi.bounding(max_int); result = codeflash_output # 957ns -> 711ns (34.6% faster)
    half_size = max_int // 2

def test_bounding_size_is_negative():
    # Negative size: should still work, half_size negative
    poi = PointOfInterest(5, 5)
    codeflash_output = poi.bounding(-4); result = codeflash_output # 885ns -> 661ns (33.9% faster)

def test_bounding_non_integer_coordinates():
    # Non-integer coordinates: should work, since subtraction/addition is valid
    poi = PointOfInterest(2.5, -3.5)
    codeflash_output = poi.bounding(6); result = codeflash_output # 1.06μs -> 813ns (30.4% faster)

def test_bounding_size_is_float():
    # Size as float: should floor-divide, so 5.9//2 == 2.0
    poi = PointOfInterest(1, 1)
    codeflash_output = poi.bounding(5.9); result = codeflash_output # 1.44μs -> 1.31μs (9.93% faster)

def test_bounding_size_is_string_raises():
    # Non-numeric size should raise TypeError
    poi = PointOfInterest(0, 0)
    with pytest.raises(TypeError):
        poi.bounding("10") # 1.47μs -> 1.39μs (5.45% faster)

def test_bounding_coordinate_is_string_raises():
    # Non-numeric coordinate should raise TypeError when doing arithmetic
    poi = PointOfInterest("x", 0)
    with pytest.raises(TypeError):
        poi.bounding(10) # 1.59μs -> 1.44μs (10.2% faster)

# ------------------------
# 3. Large Scale Test Cases
# ------------------------

def test_bounding_many_points_unique():
    # Test bounding for many unique points
    for i in range(1000):
        poi = PointOfInterest(i, 2*i)
        size = (i % 20) + 1  # size cycles from 1 to 20
        half_size = size // 2
        expected = [i - half_size, 2*i - half_size, i + half_size, 2*i + half_size]
        codeflash_output = poi.bounding(size) # 250μs -> 201μs (24.3% faster)

def test_bounding_performance_large_size():
    # Test with a large size and large coordinates
    poi = PointOfInterest(500, 500)
    size = 999  # max within constraints
    half_size = size // 2
    expected = [500 - half_size, 500 - half_size, 500 + half_size, 500 + half_size]
    codeflash_output = poi.bounding(size) # 945ns -> 665ns (42.1% faster)

def test_bounding_performance_negative_large_size():
    # Test with a large negative size
    poi = PointOfInterest(-500, -500)
    size = -999
    half_size = size // 2
    expected = [-500 - half_size, -500 - half_size, -500 + half_size, -500 + half_size]
    codeflash_output = poi.bounding(size) # 821ns -> 621ns (32.2% faster)

def test_bounding_many_random_points():
    # Test many points with random coordinates and sizes
    import random
    random.seed(42)
    for _ in range(1000):
        x = random.randint(-1000, 1000)
        y = random.randint(-1000, 1000)
        size = random.randint(0, 999)
        poi = PointOfInterest(x, y)
        half_size = size // 2
        expected = [x - half_size, y - half_size, x + half_size, y + half_size]
        codeflash_output = poi.bounding(size) # 278μs -> 233μs (19.5% faster)

def test_bounding_extreme_float_coordinates():
    # Test with very large float coordinates
    poi = PointOfInterest(1e6, -1e6)
    size = 999
    half_size = size // 2
    expected = [1e6 - half_size, -1e6 - half_size, 1e6 + half_size, -1e6 + half_size]
    codeflash_output = poi.bounding(size) # 905ns -> 692ns (30.8% 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-PointOfInterest.bounding-mhbmifrd and push.