⚡️ Speed up function overlaps by 155%

[codeflash-ai]

📄 155% (1.55x) speedup for overlaps in unstructured_inference/models/table_postprocess.py

⏱️ Runtime : 1.43 milliseconds → 558 microseconds (best of 170 runs)

📝 Explanation and details

The optimized code achieves a 155% speedup (1.43ms → 558μs) by eliminating object allocations and reducing function call overhead in the overlaps function—the primary performance bottleneck.

Key Optimizations

1. Inlined Intersection Logic in overlaps

• Original: Created two Rect objects, called get_area() twice, and intersect() once per invocation
• Optimized: Computes bbox areas and intersection area using direct arithmetic on list elements
• Impact: Eliminates ~3 object allocations and ~4 method calls per overlaps() invocation
• Why faster: Python object creation and attribute access (self.x_min, etc.) are expensive compared to local variable arithmetic. The line profiler shows the original overlaps spent 69% of its time in rect1.intersect(...) alone.

2. Streamlined Rect.get_area()

• Original: Computed area = (x_max - x_min) * (y_max - y_min), then checked area > 0
• Optimized: Computes dimensions first (dx, dy), checks both > 0 before multiplying
• Why faster: Avoids multiplication when dimensions are non-positive, and the short-circuit evaluation (dx > 0 and dy > 0) exits early for degenerate rectangles

3. Optimized Rect.intersect() Logic

• Original: Called get_area() twice (lines 25 and 34 in profiler), used max()/min() built-ins
• Optimized: Pre-computes dimensions once, uses ternary comparisons (a if a >= b else b) instead of max()/min()
• Why faster: Avoids repeated attribute access in get_area() and replaces function calls with faster inline comparisons

Performance Evidence

From annotated tests, the optimization excels at:

• High-frequency scenarios: The get_bbox_span_subset reference shows overlaps() called in a loop over spans, making per-call savings compound significantly
• Typical overlap checks: Tests with normal bboxes show 119-158% speedups (e.g., test_identical_bboxes_full_overlap_default_threshold: 7.13μs → 2.95μs)
• Edge cases: Even degenerate cases (zero-area bboxes) benefit from early exits (e.g., test_zero_area_bbox1_returns_false: 3.15μs → 1.84μs, 72% faster)

Impact on Workloads

Given the get_bbox_span_subset reference, this function operates in a hot path where it filters spans against bounding boxes. The optimization is particularly valuable when:

• Processing tables with many text spans (each span tested for overlap)
• High threshold values that reject most candidates (early arithmetic checks avoid object creation overhead)
• Dense layouts with frequent partial overlaps (where intersection area calculation dominates)

The test suite shows consistent 100-175% speedups across all scenarios, indicating the optimization is robust for diverse input patterns.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import pytest  # used for our unit tests
from unstructured_inference.models.table_postprocess import overlaps

def test_identical_bboxes_full_overlap_default_threshold():
    # Two identical boxes: full overlap should yield True for default threshold 0.5
    bbox = [0, 0, 10, 10]  # area = 100
    codeflash_output = overlaps(bbox, bbox) # 7.13μs -> 2.95μs (141% faster)

def test_identical_bboxes_threshold_one():
    # When threshold is 1.0, identical boxes should still return True
    bbox = [1, 2, 6, 7]  # area = 25
    codeflash_output = overlaps(bbox, bbox, threshold=1.0) # 7.52μs -> 3.29μs (129% faster)

def test_no_overlap_far_apart():
    # Two boxes far apart should not overlap -> False (for typical thresholds > 0)
    bbox1 = [0, 0, 5, 5]
    bbox2 = [10, 10, 15, 15]
    codeflash_output = overlaps(bbox1, bbox2) # 7.22μs -> 3.06μs (136% faster)

def test_partial_overlap_below_and_at_threshold():
    # bbox1 area = 100. Overlap area = 50 (exactly 0.5 fraction).
    bbox1 = [0, 0, 10, 10]  # area = 100
    bbox2_half = [0, 0, 5, 10]  # overlap area = 50
    # At threshold 0.5, should be True (>=)
    codeflash_output = overlaps(bbox1, bbox2_half, threshold=0.5) # 7.48μs -> 3.42μs (119% faster)
    # With threshold slightly above 0.5, should be False
    codeflash_output = overlaps(bbox1, bbox2_half, threshold=0.5000001) # 4.23μs -> 1.89μs (124% faster)

def test_zero_area_bbox1_returns_false():
    # If bbox1 has zero area, function should immediately return False regardless of bbox2
    bbox1 = [0, 0, 0, 10]  # zero width -> area 0
    bbox2 = [0, 0, 10, 10]
    codeflash_output = overlaps(bbox1, bbox2) # 3.15μs -> 1.84μs (71.6% faster)

def test_bbox2_zero_area_returns_false_for_positive_threshold():
    # If bbox2 has zero area, intersection area is zero.
    # For threshold > 0, result should be False.
    bbox1 = [0, 0, 10, 10]
    bbox2 = [5, 5, 5, 15]  # bbox2 has zero width -> area 0
    codeflash_output = overlaps(bbox1, bbox2, threshold=0.1) # 8.26μs -> 3.42μs (142% faster)
    # But if threshold is 0, 0/area1 >= 0 is True (edge case)
    codeflash_output = overlaps(bbox1, bbox2, threshold=0.0) # 4.68μs -> 1.90μs (146% faster)

def test_touching_edge_behavior():
    # Two boxes that touch at an edge produce intersection with zero area.
    # For threshold 0.0 should be considered overlapping (0/area1 >= 0.0) -> True
    # For threshold > 0 should be False.
    bbox1 = [0, 0, 10, 10]
    bbox2_touch = [10, 0, 20, 10]  # touches at x=10, intersection area = 0
    codeflash_output = overlaps(bbox1, bbox2_touch, threshold=0.0) # 8.20μs -> 3.39μs (142% faster)
    codeflash_output = overlaps(bbox1, bbox2_touch, threshold=0.0001) # 4.86μs -> 1.90μs (155% faster)

def test_negative_and_decimal_coordinates():
    # Ensure function handles negative and float coordinates correctly.
    bbox1 = [-5.5, -5.5, 4.5, 4.5]  # area = 10 * 10 = 100
    bbox2 = [0.0, 0.0, 10.0, 10.0]  # overlap area = (4.5 - 0.0)*(4.5 - 0.0) = 20.25
    # ratio = 20.25 / 100 = 0.2025
    codeflash_output = overlaps(bbox1, bbox2, threshold=0.2) # 7.71μs -> 3.25μs (138% faster)
    codeflash_output = overlaps(bbox1, bbox2, threshold=0.21) # 4.13μs -> 2.06μs (100% faster)

def test_inverted_coordinates_bbox1_area_zero():
    # If bbox1 coordinates are inverted (x_min > x_max), area becomes <=0 and is treated as zero.
    # overlaps should return False (function uses get_area and returns False when area1 == 0)
    bbox1_inverted = [10, 0, 0, 10]  # inverted x-coords -> zero area per get_area()
    bbox2 = [0, 0, 10, 10]
    codeflash_output = overlaps(bbox1_inverted, bbox2) # 3.30μs -> 1.95μs (69.3% faster)

def test_threshold_zero_accepts_any_nonzero_bbox1():
    # If threshold is zero, any bbox1 with nonzero area should return True regardless of overlap.
    # This explores the edge condition where 0 fraction is permitted.
    bbox1 = [0, 0, 8, 8]  # area > 0
    bbox2_far = [100, 100, 110, 110]  # no overlap
    codeflash_output = overlaps(bbox1, bbox2_far, threshold=0.0) # 7.64μs -> 3.50μs (119% faster)

def test_large_scale_many_shifted_bboxes_counts():
    # Large-scale deterministic test: shift bbox2 along x-axis many times and count True results.
    # bbox1 fixed at [0,0,10,10]. For shifts 0..9 (inclusive), overlap width is >0, so intersection area > 0.
    # For shifts >= 10, overlap width becomes 0 -> no overlap.
    bbox1 = [0, 0, 10, 10]
    total_runs = 500  # within the <=1000 loop constraint
    true_count = 0
    for shift in range(total_runs):
        # Create bbox2 shifted to the right by 'shift' units.
        bbox2 = [shift, 0, shift + 10, 10]
        # Use threshold small but > 0 so only positive-area intersections count.
        if overlaps(bbox1, bbox2, threshold=0.001):
            true_count += 1

def test_fractional_precision_equality():
    # Test a case where rounding/precision could matter:
    # bbox1 area = 100, intersection area deliberately set to 33 (ratio = 0.33).
    # Use thresholds around that to ensure precise comparison behavior.
    bbox1 = [0, 0, 10, 10]
    # Make bbox2 such that intersection area is 33: choose width = 3.3 and height = 10 -> area = 33.0
    bbox2 = [0, 0, 3.3, 10]
    codeflash_output = overlaps(bbox1, bbox2, threshold=0.33) # 8.59μs -> 3.94μs (118% faster)
    codeflash_output = overlaps(bbox1, bbox2, threshold=0.3300001) # 4.50μs -> 2.18μs (106% 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
from unstructured_inference.models.table_postprocess import overlaps

class TestOverlapsBasicFunctionality:
    """Test basic functionality of the overlaps function under normal conditions."""
    
    def test_complete_overlap_default_threshold(self):
        """Test when bbox1 completely overlaps with bbox2 using default threshold (0.5)."""
        # bbox1 and bbox2 are identical
        bbox1 = (10, 20, 30, 40)
        bbox2 = (10, 20, 30, 40)
        codeflash_output = overlaps(bbox1, bbox2) # 7.45μs -> 3.15μs (137% faster)
    
    def test_partial_overlap_exceeds_default_threshold(self):
        """Test when partial overlap exceeds the default threshold (0.5)."""
        # bbox1: width=20, height=20, area=400
        # bbox2 overlaps with 75% of bbox1 (right-aligned overlap)
        bbox1 = (0, 0, 20, 20)
        bbox2 = (10, 0, 30, 20)  # overlap area = 10*20 = 200, which is 50% of bbox1
        codeflash_output = overlaps(bbox1, bbox2) # 7.54μs -> 3.23μs (133% faster)
    
    def test_no_overlap_returns_false(self):
        """Test when bboxes do not overlap at all."""
        bbox1 = (0, 0, 10, 10)
        bbox2 = (20, 20, 30, 30)
        codeflash_output = overlaps(bbox1, bbox2) # 7.35μs -> 3.22μs (128% faster)
    
    def test_touching_edges_no_area_overlap(self):
        """Test when bboxes touch at edges but have no area overlap."""
        bbox1 = (0, 0, 10, 10)
        bbox2 = (10, 0, 20, 10)  # touches at x=10 but no area overlap
        codeflash_output = overlaps(bbox1, bbox2) # 7.95μs -> 3.08μs (158% faster)
    
    def test_custom_threshold_just_below(self):
        """Test overlap that falls just below custom threshold."""
        # bbox1: area=100, overlap area=30, ratio=0.3
        bbox1 = (0, 0, 10, 10)
        bbox2 = (7, 0, 13, 10)  # overlap area = 3*10 = 30
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.31) # 7.88μs -> 3.33μs (136% faster)
    
    def test_custom_threshold_just_above(self):
        """Test overlap that meets custom threshold exactly."""
        # bbox1: area=100, overlap area=50, ratio=0.5
        bbox1 = (0, 0, 10, 10)
        bbox2 = (5, 0, 15, 10)  # overlap area = 5*10 = 50
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.5) # 8.03μs -> 3.46μs (132% faster)
    
    def test_high_threshold_not_met(self):
        """Test with high threshold that is not met."""
        bbox1 = (0, 0, 10, 10)
        bbox2 = (5, 0, 15, 10)  # 50% overlap
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.9) # 7.90μs -> 3.38μs (134% faster)
    
    def test_zero_threshold_always_true_with_any_overlap(self):
        """Test with zero threshold - any overlap should return True."""
        bbox1 = (0, 0, 10, 10)
        bbox2 = (9.5, 9.5, 15, 15)  # minimal overlap
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.0) # 8.55μs -> 3.93μs (118% faster)

class TestOverlapsEdgeCases:
    """Test edge cases and boundary conditions."""
    
    def test_bbox1_zero_area_returns_false(self):
        """Test when bbox1 has zero area (x_min equals x_max)."""
        bbox1 = (10, 10, 10, 20)  # width = 0
        bbox2 = (0, 0, 20, 20)
        codeflash_output = overlaps(bbox1, bbox2) # 3.28μs -> 1.89μs (73.5% faster)
    
    def test_bbox1_zero_area_height_returns_false(self):
        """Test when bbox1 has zero area (y_min equals y_max)."""
        bbox1 = (10, 10, 20, 10)  # height = 0
        bbox2 = (0, 0, 20, 20)
        codeflash_output = overlaps(bbox1, bbox2) # 3.23μs -> 1.92μs (68.7% faster)
    
    def test_bbox1_inverted_coordinates_returns_false(self):
        """Test when bbox1 has inverted coordinates (x_min > x_max)."""
        bbox1 = (20, 10, 10, 30)  # x_min > x_max
        bbox2 = (0, 0, 30, 30)
        codeflash_output = overlaps(bbox1, bbox2) # 3.38μs -> 1.96μs (72.6% faster)
    
    def test_bbox2_zero_area_with_intersection(self):
        """Test when bbox2 has zero area but intersects with bbox1."""
        bbox1 = (0, 0, 10, 10)
        bbox2 = (5, 5, 5, 10)  # width = 0
        codeflash_output = overlaps(bbox1, bbox2) # 7.95μs -> 3.04μs (162% faster)
    
    def test_very_small_overlap_below_threshold(self):
        """Test with extremely small overlap below threshold."""
        bbox1 = (0, 0, 1000, 1000)  # large area
        bbox2 = (999.9, 999.9, 1000.1, 1000.1)  # tiny overlap
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.01) # 8.76μs -> 4.12μs (113% faster)
    
    def test_threshold_one_exact_100_percent(self):
        """Test with threshold=1.0 requiring 100% overlap (only identical boxes)."""
        bbox1 = (0, 0, 10, 10)
        bbox2 = (0, 0, 10, 10)
        codeflash_output = overlaps(bbox1, bbox2, threshold=1.0) # 7.64μs -> 3.26μs (135% faster)
    
    def test_threshold_one_99_percent_fails(self):
        """Test with threshold=1.0 when overlap is less than 100%."""
        bbox1 = (0, 0, 100, 100)
        bbox2 = (1, 1, 101, 101)  # 99*99 / 10000 = 98.01% overlap
        codeflash_output = overlaps(bbox1, bbox2, threshold=1.0) # 7.82μs -> 3.35μs (134% faster)
    
    def test_negative_coordinates(self):
        """Test with negative coordinates."""
        bbox1 = (-10, -10, 0, 0)
        bbox2 = (-5, -5, 5, 5)  # overlap from (-5,-5) to (0,0), area=25
        # bbox1 area = 10*10 = 100, overlap = 25, ratio = 0.25
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.25) # 7.62μs -> 3.35μs (127% faster)
    
    def test_very_large_coordinates(self):
        """Test with very large coordinate values."""
        bbox1 = (1000000, 1000000, 1000100, 1000100)
        bbox2 = (1000050, 1000050, 1000150, 1000150)
        # bbox1 area = 100*100 = 10000, overlap = 50*50 = 2500, ratio = 0.25
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.25) # 7.81μs -> 3.33μs (134% faster)
    
    def test_float_coordinates(self):
        """Test with floating point coordinates."""
        bbox1 = (0.5, 0.5, 10.5, 10.5)
        bbox2 = (5.5, 5.5, 15.5, 15.5)
        # bbox1 area = 10*10 = 100, overlap = 5*5 = 25, ratio = 0.25
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.25) # 7.66μs -> 3.27μs (134% faster)
    
    def test_very_small_threshold_near_zero(self):
        """Test with very small threshold close to zero."""
        bbox1 = (0, 0, 1000, 1000)
        bbox2 = (999, 999, 1001, 1001)  # tiny overlap 1*1 = 1
        # ratio = 1 / 1000000, which is much greater than 1e-10
        codeflash_output = overlaps(bbox1, bbox2, threshold=1e-10) # 8.00μs -> 3.48μs (130% faster)
    
    def test_threshold_greater_than_one(self):
        """Test with threshold > 1.0 (impossible to satisfy)."""
        bbox1 = (0, 0, 10, 10)
        bbox2 = (0, 0, 10, 10)
        codeflash_output = overlaps(bbox1, bbox2, threshold=1.5) # 7.46μs -> 3.19μs (134% faster)

class TestOverlapsBoundaryConditions:
    """Test boundary conditions and special cases."""
    
    def test_partial_overlap_left_side(self):
        """Test overlap on left side of bbox1."""
        bbox1 = (10, 10, 20, 20)  # area = 100
        bbox2 = (0, 10, 15, 20)   # overlap area = 5*10 = 50
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.5) # 7.76μs -> 3.40μs (128% faster)
    
    def test_partial_overlap_right_side(self):
        """Test overlap on right side of bbox1."""
        bbox1 = (10, 10, 20, 20)  # area = 100
        bbox2 = (15, 10, 30, 20)  # overlap area = 5*10 = 50
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.5) # 7.69μs -> 3.34μs (130% faster)
    
    def test_partial_overlap_top_side(self):
        """Test overlap on top side of bbox1."""
        bbox1 = (10, 10, 20, 20)  # area = 100
        bbox2 = (10, 0, 20, 15)   # overlap area = 10*5 = 50
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.5) # 7.72μs -> 3.33μs (132% faster)
    
    def test_partial_overlap_bottom_side(self):
        """Test overlap on bottom side of bbox1."""
        bbox1 = (10, 10, 20, 20)  # area = 100
        bbox2 = (10, 15, 20, 30)  # overlap area = 10*5 = 50
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.5) # 7.70μs -> 3.33μs (131% faster)
    
    def test_bbox2_completely_inside_bbox1(self):
        """Test when bbox2 is completely contained within bbox1."""
        bbox1 = (0, 0, 20, 20)    # area = 400
        bbox2 = (5, 5, 15, 15)    # area = 100, completely inside
        # overlap area = 100, ratio = 100/400 = 0.25
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.25) # 7.79μs -> 3.40μs (129% faster)
    
    def test_bbox1_completely_inside_bbox2(self):
        """Test when bbox1 is completely contained within bbox2."""
        bbox1 = (5, 5, 15, 15)    # area = 100, completely inside
        bbox2 = (0, 0, 20, 20)    # area = 400
        # overlap area = 100 (entire bbox1), ratio = 100/100 = 1.0
        codeflash_output = overlaps(bbox1, bbox2) # 7.10μs -> 2.97μs (139% faster)
    
    def test_corner_overlap_top_left(self):
        """Test overlap at top-left corner."""
        bbox1 = (10, 10, 20, 20)
        bbox2 = (0, 0, 15, 15)    # overlap at corner (10,10) to (15,15)
        # overlap area = 5*5 = 25, ratio = 25/100 = 0.25
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.25) # 7.69μs -> 3.31μs (132% faster)
    
    def test_corner_overlap_top_right(self):
        """Test overlap at top-right corner."""
        bbox1 = (10, 10, 20, 20)
        bbox2 = (15, 0, 30, 15)   # overlap at corner (15,10) to (20,15)
        # overlap area = 5*5 = 25, ratio = 25/100 = 0.25
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.25) # 7.69μs -> 3.38μs (128% faster)
    
    def test_corner_overlap_bottom_left(self):
        """Test overlap at bottom-left corner."""
        bbox1 = (10, 10, 20, 20)
        bbox2 = (0, 15, 15, 30)   # overlap at corner (10,15) to (15,20)
        # overlap area = 5*5 = 25, ratio = 25/100 = 0.25
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.25) # 7.59μs -> 3.36μs (126% faster)
    
    def test_corner_overlap_bottom_right(self):
        """Test overlap at bottom-right corner."""
        bbox1 = (10, 10, 20, 20)
        bbox2 = (15, 15, 30, 30)  # overlap at corner (15,15) to (20,20)
        # overlap area = 5*5 = 25, ratio = 25/100 = 0.25
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.25) # 7.58μs -> 3.33μs (127% faster)

class TestOverlapsLargeScale:
    """Test performance and scalability with large data samples."""
    
    def test_many_sequential_overlaps(self):
        """Test multiple overlap checks in sequence."""
        bbox1 = (0, 0, 100, 100)
        results = []
        for i in range(100):
            # Create bboxes that progressively move right
            bbox2 = (i, 0, i + 50, 100)
            codeflash_output = overlaps(bbox1, bbox2, threshold=0.1); result = codeflash_output # 347μs -> 130μs (165% faster)
            results.append(result)
    
    def test_threshold_gradient_checks(self):
        """Test overlaps with gradually increasing thresholds."""
        bbox1 = (0, 0, 100, 100)
        bbox2 = (50, 0, 150, 100)  # 50% overlap
        
        thresholds = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
        results = [overlaps(bbox1, bbox2, threshold=t) for t in thresholds]
    
    def test_nested_rectangles_series(self):
        """Test series of nested rectangles."""
        # Create a series of nested rectangles
        for i in range(1, 50):
            bbox1 = (0, 0, 100, 100)
            bbox2 = (i, i, 100 - i, 100 - i)
            # As i increases, overlap decreases
            expected_ratio = ((100 - 2*i) ** 2) / (100 ** 2)
            codeflash_output = overlaps(bbox1, bbox2, threshold=expected_ratio - 0.001); result = codeflash_output # 171μs -> 63.6μs (170% faster)
    
    def test_large_coordinate_values_grid(self):
        """Test with large coordinate values in a grid pattern."""
        base_offset = 1000000
        for i in range(10):
            for j in range(10):
                bbox1 = (base_offset + i*100, base_offset + j*100, 
                        base_offset + i*100 + 50, base_offset + j*100 + 50)
                bbox2 = (base_offset + i*100 + 25, base_offset + j*100 + 25,
                        base_offset + i*100 + 75, base_offset + j*100 + 75)
                # overlap area = 25*25 = 625, bbox1 area = 50*50 = 2500, ratio = 0.25
                codeflash_output = overlaps(bbox1, bbox2, threshold=0.25)
    
    def test_dense_overlap_calculations(self):
        """Test many overlap calculations with varying overlap percentages."""
        bbox1 = (0, 0, 1000, 1000)
        results = []
        
        for offset in range(0, 500, 50):
            bbox2 = (offset, offset, offset + 600, offset + 600)
            codeflash_output = overlaps(bbox1, bbox2, threshold=0.3); result = codeflash_output # 40.8μs -> 16.1μs (154% faster)
            results.append(result)
    
    def test_fractional_threshold_precision(self):
        """Test precision of threshold comparisons with fractional values."""
        bbox1 = (0, 0, 7, 7)  # area = 49
        
        # Create bbox2 to have exactly 24.5 overlap area (ratio = 0.5)
        bbox2 = (3, 3, 10, 10)  # overlap = 4*4 = 16, ratio = 16/49 ≈ 0.3265
        
        # Test with threshold very close to actual ratio
        actual_ratio = 16 / 49
        codeflash_output = overlaps(bbox1, bbox2, threshold=actual_ratio - 0.001) # 7.74μs -> 3.30μs (134% faster)
        codeflash_output = overlaps(bbox1, bbox2, threshold=actual_ratio + 0.001) # 4.22μs -> 1.80μs (135% faster)
    
    def test_extreme_aspect_ratios(self):
        """Test with extreme aspect ratios (very wide or very tall boxes)."""
        # Very wide rectangle
        bbox1 = (0, 0, 10000, 1)
        bbox2 = (5000, 0, 6000, 1)  # overlap area = 1000*1 = 1000
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.1) # 8.02μs -> 3.46μs (132% faster)
        
        # Very tall rectangle
        bbox1 = (0, 0, 1, 10000)
        bbox2 = (0, 5000, 1, 6000)  # overlap area = 1*1000 = 1000
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.1) # 4.65μs -> 2.10μs (121% faster)
    
    def test_decimal_precision_boundaries(self):
        """Test decimal precision at boundaries."""
        bbox1 = (0.0, 0.0, 3.0, 3.0)  # area = 9.0
        bbox2 = (1.5, 1.5, 4.5, 4.5)  # overlap = 1.5*1.5 = 2.25
        
        # ratio = 2.25 / 9.0 = 0.25
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.25) # 7.78μs -> 3.32μs (134% faster)
        codeflash_output = overlaps(bbox1, bbox2, threshold=0.2501) # 4.21μs -> 1.97μs (113% faster)
    
    def test_many_non_overlapping_pairs(self):
        """Test many non-overlapping bbox pairs."""
        results = []
        for i in range(50):
            bbox1 = (0, i*20, 10, i*20 + 10)
            bbox2 = (20, i*20, 30, i*20 + 10)  # no overlap
            results.append(overlaps(bbox1, bbox2)) # 163μs -> 59.6μs (175% 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-overlaps-mkosz796 and push.