⚡️ Speed up function _get_coordinates_of_block by 73%

[codeflash-ai]

📄 73% (0.73x) speedup for _get_coordinates_of_block in lib/matplotlib/backends/backend_pdf.py

⏱️ Runtime : 5.34 milliseconds → 3.08 milliseconds (best of 112 runs)

📝 Explanation and details

The optimized code achieves a 73% speedup through three key optimizations that reduce redundant calculations and improve data access patterns:

1. Eliminated Redundant Arithmetic Operations
The original code recalculated height * sin_angle, height * cos_angle, width * cos_angle, and width * sin_angle multiple times across variables. The optimization precomputes these values once (hx_s, hx_c, wx_c, wx_s) and reuses them, reducing arithmetic operations from 8 multiplications to 4.

2. Replaced Generator Expressions with Direct Unpacking
The original min/max operations used generator expressions like min(v[0] for v in vertices) which create temporary iterators and perform tuple indexing. The optimization directly unpacks vertices into individual variables (x0, y0, x1, y1, x2, y2, x3, y3) and passes them to min/max, eliminating iterator overhead and tuple access costs.

3. Replaced itertools.chain with Tuple Concatenation
The original used itertools.chain.from_iterable(vertices) to flatten the coordinate tuples, which creates an iterator object. The optimization manually constructs the flattened tuple (x0, y0, x1, y1, x2, y2, x3, y3) directly, avoiding iterator creation overhead.

Performance Impact on Usage Context
Based on the function reference, _get_coordinates_of_block is called from _get_link_annotation when creating PDF link annotations. The test results show consistent 35-85% speedups across various rectangle configurations, with the largest gains on batch operations (85% for many small rectangles). Since PDF generation often involves creating many annotations, this optimization significantly reduces rendering time in matplotlib's PDF backend, especially for documents with numerous interactive elements or complex layouts.

Optimization Effectiveness by Test Case

• Basic rectangles: ~40% speedup - benefits from reduced arithmetic
• Batch operations: up to 85% speedup - compounds savings across many calls
• Edge cases (zero dimensions): ~40% speedup - still benefits from unpacking optimizations
• Large coordinates: ~65% speedup - arithmetic savings more pronounced with expensive floating-point operations

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import math

# imports
from matplotlib.backends.backend_pdf import _get_coordinates_of_block

# unit tests

# --- BASIC TEST CASES ---


def test_axis_aligned_rectangle():
    # Rectangle at (0,0), width=10, height=5, no rotation
    quad, rect = _get_coordinates_of_block(
        0, 0, 10, 5, angle=0
    )  # 8.60μs -> 6.06μs (41.9% faster)
    # QuadPoints should be (0,0), (10,0), (10,5), (0,5)
    expected_quad = (0, 0, 10, 0, 10, 5, 0, 5)


def test_axis_aligned_rectangle_nonzero_origin():
    # Rectangle at (5,5), width=2, height=3, no rotation
    quad, rect = _get_coordinates_of_block(
        5, 5, 2, 3, angle=0
    )  # 8.50μs -> 6.13μs (38.6% faster)
    expected_quad = (5, 5, 7, 5, 7, 8, 5, 8)


def test_rotated_90_degrees():
    # Rectangle at (0,0), width=2, height=1, rotated 90deg
    quad, rect = _get_coordinates_of_block(
        0, 0, 2, 1, angle=90
    )  # 8.93μs -> 6.46μs (38.1% faster)
    # Should be rectangle from (0,0) rotated 90deg CCW
    # Points: (0,0), (0,-2), (1,-2), (1,0)
    expected_quad = (0, 0, 0, -2, 1, -2, 1, 0)


def test_rotated_180_degrees():
    # Rectangle at (0,0), width=2, height=1, rotated 180deg
    quad, rect = _get_coordinates_of_block(
        0, 0, 2, 1, angle=180
    )  # 8.92μs -> 6.49μs (37.5% faster)
    # Should be rectangle from (0,0) rotated 180deg CCW
    # Points: (0,0), (-2,0), (-2,-1), (0,-1)
    expected_quad = (0, 0, -2, 0, -2, -1, 0, -1)


def test_rotated_45_degrees():
    # Rectangle at (0,0), width=1, height=1, rotated 45deg
    quad, rect = _get_coordinates_of_block(
        0, 0, 1, 1, angle=45
    )  # 8.38μs -> 5.98μs (40.1% faster)
    # Compute expected points
    sqrt2_over_2 = math.sqrt(2) / 2
    # Manually compute the four corners
    # (0,0)
    # (cos(-45)*1, -sin(-45)*1) = (sqrt2/2, sqrt2/2)
    # (cos(-45)*1 + sin(-45)*1, -sin(-45)*1 + cos(-45)*1)
    # sin(-45) = -sqrt2/2, cos(-45) = sqrt2/2
    # (sqrt2/2 + -sqrt2/2, sqrt2/2 + sqrt2/2) = (0, sqrt2)
    # (sin(-45)*1, cos(-45)*1) = (-sqrt2/2, sqrt2/2)
    expected_quad = (
        0,
        0,
        sqrt2_over_2,
        sqrt2_over_2,
        0,
        math.sqrt(2),
        -sqrt2_over_2,
        sqrt2_over_2,
    )
    for a, b in zip(quad, expected_quad):
        pass
    min_x = min(expected_quad[::2]) - 0.00001
    min_y = min(expected_quad[1::2]) - 0.00001
    max_x = max(expected_quad[::2]) + 0.00001
    max_y = max(expected_quad[1::2]) + 0.00001
    for a, b in zip(rect, (min_x, min_y, max_x, max_y)):
        pass


def test_rotated_minus_30_degrees():
    # Rectangle at (1,2), width=3, height=4, rotated -30deg
    quad, rect = _get_coordinates_of_block(
        1, 2, 3, 4, angle=-30
    )  # 8.45μs -> 6.22μs (35.7% faster)


# --- EDGE TEST CASES ---


def test_zero_width():
    # Rectangle with zero width, should collapse to a line
    quad, rect = _get_coordinates_of_block(
        2, 3, 0, 5, angle=0
    )  # 8.53μs -> 6.21μs (37.4% faster)
    expected_quad = (2, 3, 2, 3, 2, 8, 2, 8)


def test_zero_height():
    # Rectangle with zero height, should collapse to a line
    quad, rect = _get_coordinates_of_block(
        2, 3, 5, 0, angle=0
    )  # 8.58μs -> 6.12μs (40.1% faster)
    expected_quad = (2, 3, 7, 3, 7, 3, 2, 3)


def test_zero_width_and_height():
    # Rectangle with zero width and height, should collapse to a point
    quad, rect = _get_coordinates_of_block(
        2, 3, 0, 0, angle=0
    )  # 8.24μs -> 5.93μs (38.9% faster)
    expected_quad = (2, 3, 2, 3, 2, 3, 2, 3)


def test_negative_width():
    # Negative width, should "flip" the rectangle horizontally
    quad, rect = _get_coordinates_of_block(
        0, 0, -2, 1, angle=0
    )  # 8.77μs -> 6.31μs (38.9% faster)
    expected_quad = (0, 0, -2, 0, -2, 1, 0, 1)


def test_negative_height():
    # Negative height, should "flip" the rectangle vertically
    quad, rect = _get_coordinates_of_block(
        0, 0, 2, -1, angle=0
    )  # 8.83μs -> 6.35μs (39.0% faster)
    expected_quad = (0, 0, 2, 0, 2, -1, 0, -1)


def test_large_angle():
    # Angle > 360, should wrap around
    quad1, rect1 = _get_coordinates_of_block(
        0, 0, 2, 1, angle=450
    )  # 8.90μs -> 6.58μs (35.3% faster)
    quad2, rect2 = _get_coordinates_of_block(
        0, 0, 2, 1, angle=90
    )  # 3.91μs -> 2.28μs (71.3% faster)


def test_negative_angle():
    # Negative angle, should rotate CW
    quad1, rect1 = _get_coordinates_of_block(
        0, 0, 2, 1, angle=-90
    )  # 8.47μs -> 6.05μs (40.0% faster)
    quad2, rect2 = _get_coordinates_of_block(
        0, 0, 2, 1, angle=270
    )  # 4.55μs -> 2.91μs (56.3% faster)


def test_float_inputs():
    # Inputs as floats
    quad, rect = _get_coordinates_of_block(
        1.5, 2.5, 3.5, 4.5, angle=0
    )  # 7.58μs -> 5.38μs (40.8% faster)
    expected_quad = (1.5, 2.5, 5.0, 2.5, 5.0, 7.0, 1.5, 7.0)


def test_extremely_small_rectangle():
    # Very small rectangle, test for floating point precision
    quad, rect = _get_coordinates_of_block(
        0, 0, 1e-10, 1e-10, angle=0
    )  # 8.39μs -> 6.07μs (38.1% faster)
    expected_quad = (0, 0, 1e-10, 0, 1e-10, 1e-10, 0, 1e-10)


def test_extremely_large_rectangle():
    # Very large rectangle, test for overflow or float issues
    quad, rect = _get_coordinates_of_block(
        1e10, 1e10, 1e10, 1e10, angle=0
    )  # 7.88μs -> 5.59μs (40.9% faster)
    expected_quad = (1e10, 1e10, 2e10, 1e10, 2e10, 2e10, 1e10, 2e10)


# --- LARGE SCALE TEST CASES ---


def test_many_rectangles_varying_angles():
    # Test rectangles with a range of angles
    for angle in range(0, 360, 30):
        quad, rect = _get_coordinates_of_block(
            10, 20, 30, 40, angle=angle
        )  # 43.1μs -> 27.3μs (57.6% faster)
        # All values should be finite numbers
        for v in quad + rect:
            pass


def test_large_number_of_rectangles():
    # Test scalability: 500 rectangles with increasing size and rotation
    for i in range(500):
        x = i
        y = i * 2
        width = 10 + i % 20
        height = 5 + i % 10
        angle = (i * 7) % 360
        quad, rect = _get_coordinates_of_block(
            x, y, width, height, angle=angle
        )  # 1.31ms -> 740μs (76.8% faster)
        for v in quad + rect:
            pass


def test_large_rectangles_with_random_angles():
    # Test rectangles with large coordinates and random angles
    for i in range(0, 1000, 100):
        x = 1e6 + i
        y = -1e6 + i
        width = 1e3 + i
        height = 2e3 + i
        angle = (i * 13) % 360
        quad, rect = _get_coordinates_of_block(
            x, y, width, height, angle=angle
        )  # 34.0μs -> 21.7μs (57.0% faster)
        for v in quad + rect:
            pass


def test_rectangles_with_many_angles_and_sizes():
    # Test a grid of rectangles with various origins, sizes, and angles
    for x in range(0, 100, 25):
        for y in range(0, 100, 25):
            for width in (1, 10, 50):
                for height in (1, 10, 50):
                    for angle in (0, 45, 90, 135, 180, 225, 270, 315):
                        quad, rect = _get_coordinates_of_block(
                            x, y, width, height, angle=angle
                        )
                        for v in quad + rect:
                            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

# imports
from matplotlib.backends.backend_pdf import _get_coordinates_of_block

# unit tests


# Helper for floating point comparison
def tuples_close(a, b, tol=1e-7):
    return all(abs(x - y) < tol for x, y in zip(a, b))


def rects_close(a, b, tol=1e-7):
    return all(abs(x - y) < tol for x, y in zip(a, b))


# 1. BASIC TEST CASES


def test_origin_no_rotation():
    # Rectangle at origin, no rotation
    quad, rect = _get_coordinates_of_block(
        0, 0, 10, 5, 0
    )  # 8.42μs -> 6.16μs (36.6% faster)
    # Vertices should be (0,0), (10,0), (10,5), (0,5)
    expected_quad = (0, 0, 10, 0, 10, 5, 0, 5)
    expected_rect = (0, 0, 10, 5)


def test_non_origin_no_rotation():
    # Rectangle at (2,3), width 4, height 6, no rotation
    quad, rect = _get_coordinates_of_block(
        2, 3, 4, 6, 0
    )  # 8.47μs -> 5.98μs (41.6% faster)
    expected_quad = (2, 3, 6, 3, 6, 9, 2, 9)
    expected_rect = (2, 3, 6, 9)


def test_origin_90deg_rotation():
    # Rectangle at origin, rotated 90 degrees
    quad, rect = _get_coordinates_of_block(
        0, 0, 2, 1, 90
    )  # 8.67μs -> 6.08μs (42.5% faster)
    # Vertices should be (0,0), (0,2), (-1,2), (-1,0)
    expected_quad = (0, 0, 0, 2, -1, 2, -1, 0)
    expected_rect = (-1, 0, 0, 2)


def test_origin_180deg_rotation():
    # Rectangle at origin, rotated 180 degrees
    quad, rect = _get_coordinates_of_block(
        0, 0, 2, 1, 180
    )  # 8.68μs -> 6.22μs (39.5% faster)
    # Vertices should be (0,0), (-2,0), (-2,-1), (0,-1)
    expected_quad = (0, 0, -2, 0, -2, -1, 0, -1)
    expected_rect = (-2, -1, 0, 0)


def test_origin_270deg_rotation():
    # Rectangle at origin, rotated 270 degrees
    quad, rect = _get_coordinates_of_block(
        0, 0, 2, 1, 270
    )  # 8.53μs -> 5.94μs (43.7% faster)
    # Vertices should be (0,0), (0,-2),  (1,-2), (1,0)
    expected_quad = (0, 0, 0, -2, 1, -2, 1, 0)
    expected_rect = (0, -2, 1, 0)


def test_nonzero_rotation():
    # Rectangle at (1,1), width 2, height 1, rotated 45 degrees
    quad, rect = _get_coordinates_of_block(
        1, 1, 2, 1, 45
    )  # 8.47μs -> 5.74μs (47.6% faster)
    # Manually compute expected vertices
    angle = math.radians(-45)
    sin_a = math.sin(angle)
    cos_a = math.cos(angle)
    a = (1 + 1 * sin_a, 1 + 1 * cos_a)
    e = (1 + 2 * cos_a, 1 - 2 * sin_a)
    c = (1 + 2 * cos_a + 1 * sin_a, 1 - 2 * sin_a + 1 * cos_a)
    expected_quad = (1, 1, e[0], e[1], c[0], c[1], a[0], a[1])
    # The rect should be the min/max of these points, with pad
    xs = [1, e[0], c[0], a[0]]
    ys = [1, e[1], c[1], a[1]]
    pad = 0.00001
    expected_rect = (min(xs) - pad, min(ys) - pad, max(xs) + pad, max(ys) + pad)


# 2. EDGE TEST CASES


def test_zero_width():
    # Rectangle with zero width
    quad, rect = _get_coordinates_of_block(
        5, 5, 0, 10, 0
    )  # 8.15μs -> 5.78μs (40.9% faster)
    expected_quad = (5, 5, 5, 5, 5, 15, 5, 15)
    expected_rect = (5, 5, 5, 15)


def test_zero_height():
    # Rectangle with zero height
    quad, rect = _get_coordinates_of_block(
        5, 5, 10, 0, 0
    )  # 8.39μs -> 5.97μs (40.5% faster)
    expected_quad = (5, 5, 15, 5, 15, 5, 5, 5)
    expected_rect = (5, 5, 15, 5)


def test_zero_width_and_height():
    # Rectangle with zero width and height
    quad, rect = _get_coordinates_of_block(
        7, 8, 0, 0, 0
    )  # 8.11μs -> 5.79μs (40.1% faster)
    expected_quad = (7, 8, 7, 8, 7, 8, 7, 8)
    expected_rect = (7, 8, 7, 8)


def test_negative_width():
    # Negative width
    quad, rect = _get_coordinates_of_block(
        0, 0, -3, 2, 0
    )  # 8.51μs -> 6.11μs (39.4% faster)
    expected_quad = (0, 0, -3, 0, -3, 2, 0, 2)
    expected_rect = (-3, 0, 0, 2)


def test_negative_height():
    # Negative height
    quad, rect = _get_coordinates_of_block(
        0, 0, 3, -2, 0
    )  # 8.58μs -> 6.00μs (42.9% faster)
    expected_quad = (0, 0, 3, 0, 3, -2, 0, -2)
    expected_rect = (0, -2, 3, 0)


def test_negative_width_and_height():
    # Negative width and height
    quad, rect = _get_coordinates_of_block(
        0, 0, -3, -2, 0
    )  # 8.34μs -> 5.91μs (41.0% faster)
    expected_quad = (0, 0, -3, 0, -3, -2, 0, -2)
    expected_rect = (-3, -2, 0, 0)


def test_large_angle():
    # Angle > 360
    quad1, rect1 = _get_coordinates_of_block(
        0, 0, 2, 1, 450
    )  # 8.65μs -> 6.26μs (38.2% faster)
    quad2, rect2 = _get_coordinates_of_block(
        0, 0, 2, 1, 90
    )  # 3.78μs -> 2.27μs (66.4% faster)


def test_negative_angle():
    # Negative angle
    quad_pos, rect_pos = _get_coordinates_of_block(
        0, 0, 2, 1, 30
    )  # 7.68μs -> 5.64μs (36.1% faster)
    quad_neg, rect_neg = _get_coordinates_of_block(
        0, 0, 2, 1, 390
    )  # 4.03μs -> 2.49μs (61.6% faster)


def test_small_values():
    # Very small width/height
    quad, rect = _get_coordinates_of_block(
        1e-8, 1e-8, 1e-8, 1e-8, 0
    )  # 7.49μs -> 5.24μs (43.1% faster)
    expected_quad = (1e-8, 1e-8, 2e-8, 1e-8, 2e-8, 2e-8, 1e-8, 2e-8)
    expected_rect = (1e-8, 1e-8, 2e-8, 2e-8)


def test_large_values():
    # Very large width/height
    quad, rect = _get_coordinates_of_block(
        1e8, 1e8, 1e8, 1e8, 0
    )  # 7.83μs -> 5.28μs (48.2% faster)
    expected_quad = (1e8, 1e8, 2e8, 1e8, 2e8, 2e8, 1e8, 2e8)
    expected_rect = (1e8, 1e8, 2e8, 2e8)


def test_non_integer_values():
    # Non-integer and negative origin
    quad, rect = _get_coordinates_of_block(
        -0.5, 0.5, 1.5, 2.5, 0
    )  # 7.84μs -> 5.16μs (52.0% faster)
    expected_quad = (-0.5, 0.5, 1.0, 0.5, 1.0, 3.0, -0.5, 3.0)
    expected_rect = (-0.5, 0.5, 1.0, 3.0)


# 3. LARGE SCALE TEST CASES


def test_large_number_of_blocks():
    # Test many rectangles with different parameters
    for i in range(0, 100, 10):
        for j in range(0, 100, 10):
            width = i + 1
            height = j + 1
            angle = (i + j) % 360
            quad, rect = _get_coordinates_of_block(i, j, width, height, angle)
            # The rect should always enclose all quad points
            xs = quad[0::2]
            ys = quad[1::2]
            min_x, min_y, max_x, max_y = rect
            for x, y in zip(xs, ys):
                pass


def test_performance_large_rectangles():
    # Large rectangles with rotation, check for performance and correctness
    for angle in range(0, 360, 30):
        quad, rect = _get_coordinates_of_block(
            1e5, 1e5, 5e5, 3e5, angle
        )  # 37.9μs -> 23.0μs (65.2% faster)
        xs = quad[0::2]
        ys = quad[1::2]
        min_x, min_y, max_x, max_y = rect
        for x, y in zip(xs, ys):
            pass


def test_many_small_rectangles():
    # Many small rectangles to check for floating point precision and scalability
    for i in range(100):
        x = i * 1e-4
        y = i * 1e-4
        width = 1e-4
        height = 2e-4
        angle = (i * 7) % 360
        quad, rect = _get_coordinates_of_block(
            x, y, width, height, angle
        )  # 250μs -> 135μs (85.1% faster)
        xs = quad[0::2]
        ys = quad[1::2]
        min_x, min_y, max_x, max_y = rect
        for xq, yq in zip(xs, ys):
            pass


# 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-_get_coordinates_of_block-miyjgmqs and push.