⚡️ Speed up method GlobalMercator.PixelsToTile by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for GlobalMercator.PixelsToTile in opendm/tiles/gdal2tiles.py

⏱️ Runtime : 1.79 milliseconds → 1.63 milliseconds (best of 146 runs)

📝 Explanation and details

The optimization replaces expensive division operations with faster multiplication by pre-computing the reciprocal of tileSize.

What was changed:

• Added self.invTileSize = 1.0 / tileSize in the constructor to pre-compute the reciprocal
• Changed px / float(self.tileSize) to px * self.invTileSize in the PixelsToTile method
• Same change for the py calculation

Why this is faster:

1. Eliminates repeated float conversion: The original code calls float(self.tileSize) on every method call, while the optimized version computes this once during initialization
2. Multiplication vs Division: CPU multiplication is typically faster than division operations. By pre-computing 1.0 / tileSize, we replace division with multiplication
3. Reduces per-call overhead: Each call to PixelsToTile now performs 2 multiplications instead of 2 divisions + 2 float conversions

Performance characteristics:
The optimization shows consistent 9-31% speedups across test cases, with particularly strong performance on:

• Basic coordinate conversions (15-26% faster)
• Large-scale sequential processing (8-9% faster for batch operations)
• Edge cases with various tile sizes (10-21% faster)

The optimization is most effective for workloads that call PixelsToTile frequently, such as tile generation for large images or real-time coordinate transformations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import math

# imports
import pytest  # used for our unit tests
from opendm.tiles.gdal2tiles import GlobalMercator

# unit tests

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

def test_pixels_to_tile_origin():
    # Test at origin (0,0)
    gm = GlobalMercator()
    codeflash_output = gm.PixelsToTile(0, 0) # 1.19μs -> 959ns (23.7% faster)

def test_pixels_to_tile_first_tile():
    # Test at pixel (1,1) which should be in tile (0,0)
    gm = GlobalMercator()
    codeflash_output = gm.PixelsToTile(1, 1) # 1.15μs -> 969ns (19.0% faster)

def test_pixels_to_tile_exact_tile_size():
    # Test at pixel exactly at tileSize boundary (256, 256)
    gm = GlobalMercator()
    codeflash_output = gm.PixelsToTile(256, 256) # 1.12μs -> 888ns (26.2% faster)

def test_pixels_to_tile_just_over_tile_size():
    # Test at pixel just over tileSize (257, 257)
    gm = GlobalMercator()
    codeflash_output = gm.PixelsToTile(257, 257) # 1.08μs -> 888ns (21.7% faster)

def test_pixels_to_tile_middle_of_second_tile():
    # Test at pixel in the middle of second tile
    gm = GlobalMercator()
    codeflash_output = gm.PixelsToTile(384, 384) # 1.12μs -> 977ns (14.8% faster)

def test_pixels_to_tile_various_tiles():
    # Test at various positions
    gm = GlobalMercator()
    codeflash_output = gm.PixelsToTile(511, 511) # 1.15μs -> 987ns (16.5% faster)
    codeflash_output = gm.PixelsToTile(512, 512) # 450ns -> 419ns (7.40% faster)
    codeflash_output = gm.PixelsToTile(513, 513) # 388ns -> 350ns (10.9% faster)

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

def test_pixels_to_tile_negative_pixels():
    # Negative pixel coordinates
    gm = GlobalMercator()
    codeflash_output = gm.PixelsToTile(-1, -1) # 1.20μs -> 1.04μs (15.1% faster)
    codeflash_output = gm.PixelsToTile(-256, -256) # 588ns -> 612ns (3.92% slower)
    codeflash_output = gm.PixelsToTile(-257, -257) # 426ns -> 416ns (2.40% faster)

def test_pixels_to_tile_zero_tile_size():
    # tileSize = 1 (smallest possible tile)
    gm = GlobalMercator(tileSize=1)
    codeflash_output = gm.PixelsToTile(0, 0) # 1.12μs -> 1.03μs (8.51% faster)
    codeflash_output = gm.PixelsToTile(1, 1) # 557ns -> 523ns (6.50% faster)
    codeflash_output = gm.PixelsToTile(2, 2) # 400ns -> 385ns (3.90% faster)

def test_pixels_to_tile_large_tile_size():
    # tileSize = 512
    gm = GlobalMercator(tileSize=512)
    codeflash_output = gm.PixelsToTile(0, 0) # 1.10μs -> 941ns (16.9% faster)
    codeflash_output = gm.PixelsToTile(511, 511) # 532ns -> 516ns (3.10% faster)
    codeflash_output = gm.PixelsToTile(512, 512) # 397ns -> 358ns (10.9% faster)
    codeflash_output = gm.PixelsToTile(513, 513) # 376ns -> 359ns (4.74% faster)

def test_pixels_to_tile_float_pixels():
    # Non-integer pixel coordinates
    gm = GlobalMercator()
    # px=255.9, py=255.9 should be in tile (0,0)
    codeflash_output = gm.PixelsToTile(255.9, 255.9) # 1.02μs -> 986ns (3.65% faster)
    # px=256.1, py=256.1 should be in tile (1,1)
    codeflash_output = gm.PixelsToTile(256.1, 256.1) # 505ns -> 471ns (7.22% faster)

def test_pixels_to_tile_float_tile_size():
    # tileSize as float
    gm = GlobalMercator(tileSize=128.5)
    codeflash_output = gm.PixelsToTile(128.5, 128.5) # 997ns -> 852ns (17.0% faster)
    codeflash_output = gm.PixelsToTile(129, 129) # 630ns -> 531ns (18.6% faster)
    codeflash_output = gm.PixelsToTile(257, 257) # 385ns -> 362ns (6.35% faster)

def test_pixels_to_tile_large_negative_pixels():
    # Large negative pixel coordinates
    gm = GlobalMercator()
    codeflash_output = gm.PixelsToTile(-10000, -10000) # 1.31μs -> 1.13μs (15.7% faster)

def test_pixels_to_tile_large_positive_pixels():
    # Large positive pixel coordinates
    gm = GlobalMercator()
    codeflash_output = gm.PixelsToTile(10000, 10000) # 1.14μs -> 958ns (19.0% faster)

def test_pixels_to_tile_tile_boundary():
    # Test exactly on tile boundary
    gm = GlobalMercator()
    codeflash_output = gm.PixelsToTile(256, 0) # 1.13μs -> 1.03μs (9.43% faster)
    codeflash_output = gm.PixelsToTile(0, 256) # 551ns -> 516ns (6.78% faster)

def test_pixels_to_tile_tile_boundary_plus_one():
    # Test just over tile boundary
    gm = GlobalMercator()
    codeflash_output = gm.PixelsToTile(257, 0) # 1.10μs -> 966ns (13.6% faster)
    codeflash_output = gm.PixelsToTile(0, 257) # 524ns -> 477ns (9.85% faster)

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

def test_pixels_to_tile_many_tiles():
    # Test a range of pixel coordinates up to 1000*tileSize
    gm = GlobalMercator()
    for i in range(0, 1000, 100):
        px = i * gm.tileSize
        py = i * gm.tileSize
        # At pixel exactly at tile boundary, should be (i-1, i-1) for i>0
        expected = (i-1, i-1) if i > 0 else (-1, -1)
        codeflash_output = gm.PixelsToTile(px, py) # 4.87μs -> 4.46μs (9.11% faster)

def test_pixels_to_tile_large_tile_size_many_tiles():
    # Test with large tileSize and large px/py
    gm = GlobalMercator(tileSize=512)
    for i in range(0, 1000, 100):
        px = i * gm.tileSize
        py = i * gm.tileSize
        expected = (i-1, i-1) if i > 0 else (-1, -1)
        codeflash_output = gm.PixelsToTile(px, py) # 4.86μs -> 4.45μs (9.34% faster)

def test_pixels_to_tile_high_precision():
    # Test with high-precision float pixel coordinates
    gm = GlobalMercator()
    for i in range(0, 1000, 100):
        px = i * gm.tileSize + 0.000001
        py = i * gm.tileSize + 0.000001
        expected = (i, i) if i > 0 else (0, 0)
        codeflash_output = gm.PixelsToTile(px, py) # 4.68μs -> 4.26μs (9.90% faster)

def test_pixels_to_tile_dense_range():
    # Test a dense range of px/py values within first few tiles
    gm = GlobalMercator()
    for px in range(0, gm.tileSize * 5, gm.tileSize // 10):
        for py in range(0, gm.tileSize * 5, gm.tileSize // 10):
            tx = int(math.ceil(px / float(gm.tileSize)) - 1)
            ty = int(math.ceil(py / float(gm.tileSize)) - 1)
            codeflash_output = gm.PixelsToTile(px, py)

def test_pixels_to_tile_extreme_values():
    # Test with very large pixel values (close to int32 limits)
    gm = GlobalMercator()
    max_px = 2**31 - 1
    max_py = 2**31 - 1
    tx = int(math.ceil(max_px / float(gm.tileSize)) - 1)
    ty = int(math.ceil(max_py / float(gm.tileSize)) - 1)
    codeflash_output = gm.PixelsToTile(max_px, max_py) # 967ns -> 1.04μs (7.02% slower)

def test_pixels_to_tile_extreme_negative_values():
    # Test with very large negative pixel values
    gm = GlobalMercator()
    min_px = -2**31
    min_py = -2**31
    tx = int(math.ceil(min_px / float(gm.tileSize)) - 1)
    ty = int(math.ceil(min_py / float(gm.tileSize)) - 1)
    codeflash_output = gm.PixelsToTile(min_px, min_py) # 833ns -> 892ns (6.61% slower)
# 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
import pytest  # used for our unit tests
from opendm.tiles.gdal2tiles import GlobalMercator

# unit tests

# 1. Basic Test Cases

def test_basic_origin_tile():
    # px=0, py=0 should be in tile (0, 0)
    merc = GlobalMercator()
    codeflash_output = merc.PixelsToTile(0, 0) # 1.16μs -> 1.00μs (15.5% faster)

def test_basic_first_tile_boundary():
    # px=255, py=255 is still in tile (0, 0)
    merc = GlobalMercator()
    codeflash_output = merc.PixelsToTile(255, 255) # 1.16μs -> 985ns (18.0% faster)

def test_basic_next_tile_start():
    # px=256, py=256 is in tile (1, 1)
    merc = GlobalMercator()
    codeflash_output = merc.PixelsToTile(256, 256) # 1.08μs -> 903ns (19.4% faster)

def test_basic_middle_of_tile():
    # px=128, py=128 is in tile (0, 0)
    merc = GlobalMercator()
    codeflash_output = merc.PixelsToTile(128, 128) # 1.05μs -> 915ns (15.2% faster)

def test_basic_tile_size_change():
    # Changing tile size to 512
    merc = GlobalMercator(tileSize=512)
    codeflash_output = merc.PixelsToTile(511, 511) # 1.02μs -> 896ns (14.4% faster)
    codeflash_output = merc.PixelsToTile(512, 512) # 504ns -> 427ns (18.0% faster)

def test_basic_non_integer_pixel():
    # Non-integer pixel coordinates
    merc = GlobalMercator()
    codeflash_output = merc.PixelsToTile(255.9, 255.9) # 1.00μs -> 915ns (9.84% faster)
    codeflash_output = merc.PixelsToTile(256.1, 256.1) # 495ns -> 453ns (9.27% faster)

# 2. Edge Test Cases

def test_edge_negative_pixel():
    # Negative pixel coordinates should be in tile (-1, -1)
    merc = GlobalMercator()
    codeflash_output = merc.PixelsToTile(-1, -1) # 1.19μs -> 1.03μs (15.8% faster)
    codeflash_output = merc.PixelsToTile(-256, -256) # 630ns -> 631ns (0.158% slower)
    codeflash_output = merc.PixelsToTile(-0.1, -0.1) # 447ns -> 437ns (2.29% faster)


def test_edge_large_negative_pixel():
    # Very large negative pixel coordinates
    merc = GlobalMercator()
    codeflash_output = merc.PixelsToTile(-10000, -10000) # 1.82μs -> 1.39μs (31.1% faster)

def test_edge_tile_boundary_exact():
    # On the exact boundary between tiles
    merc = GlobalMercator()
    codeflash_output = merc.PixelsToTile(256, 0) # 1.30μs -> 1.12μs (16.6% faster)
    codeflash_output = merc.PixelsToTile(0, 256) # 516ns -> 510ns (1.18% faster)
    codeflash_output = merc.PixelsToTile(512, 256) # 441ns -> 399ns (10.5% faster)

def test_edge_float_tile_size():
    # tileSize as a float
    merc = GlobalMercator(tileSize=128.5)
    codeflash_output = merc.PixelsToTile(128.5, 128.5) # 1.04μs -> 944ns (10.7% faster)
    codeflash_output = merc.PixelsToTile(129, 129) # 587ns -> 530ns (10.8% faster)

def test_edge_very_small_tile_size():
    # Very small tile size
    merc = GlobalMercator(tileSize=1)
    codeflash_output = merc.PixelsToTile(0, 0) # 1.19μs -> 973ns (21.9% faster)
    codeflash_output = merc.PixelsToTile(1, 1) # 516ns -> 471ns (9.55% faster)
    codeflash_output = merc.PixelsToTile(999, 999) # 510ns -> 500ns (2.00% faster)

def test_edge_one_pixel_below_boundary():
    # One pixel below boundary
    merc = GlobalMercator()
    codeflash_output = merc.PixelsToTile(255, 256) # 1.07μs -> 881ns (21.2% faster)
    codeflash_output = merc.PixelsToTile(256, 255) # 403ns -> 410ns (1.71% slower)

def test_edge_max_integer_pixel():
    # Maximum integer pixel values (within reasonable range)
    merc = GlobalMercator()
    max_px = 2**31 - 1
    max_py = 2**31 - 1
    tx = int(math.ceil(max_px / float(merc.tileSize)) - 1)
    ty = int(math.ceil(max_py / float(merc.tileSize)) - 1)
    codeflash_output = merc.PixelsToTile(max_px, max_py) # 840ns -> 987ns (14.9% slower)

def test_edge_min_integer_pixel():
    # Minimum integer pixel values (negative)
    merc = GlobalMercator()
    min_px = -2**31
    min_py = -2**31
    tx = int(math.ceil(min_px / float(merc.tileSize)) - 1)
    ty = int(math.ceil(min_py / float(merc.tileSize)) - 1)
    codeflash_output = merc.PixelsToTile(min_px, min_py) # 810ns -> 878ns (7.74% slower)

def test_edge_nan_pixel():
    # Pixel coordinates as NaN should raise ValueError
    merc = GlobalMercator()
    with pytest.raises(ValueError):
        merc.PixelsToTile(float('nan'), 0) # 1.26μs -> 1.24μs (1.93% faster)
    with pytest.raises(ValueError):
        merc.PixelsToTile(0, float('nan')) # 1.21μs -> 1.17μs (3.25% faster)
    with pytest.raises(ValueError):
        merc.PixelsToTile(float('nan'), float('nan')) # 470ns -> 458ns (2.62% faster)

def test_edge_inf_pixel():
    # Pixel coordinates as infinity should raise OverflowError
    merc = GlobalMercator()
    with pytest.raises(OverflowError):
        merc.PixelsToTile(float('inf'), 0) # 1.10μs -> 1.11μs (0.901% slower)
    with pytest.raises(OverflowError):
        merc.PixelsToTile(0, float('inf')) # 1.13μs -> 1.04μs (8.37% faster)
    with pytest.raises(OverflowError):
        merc.PixelsToTile(float('-inf'), 0) # 494ns -> 495ns (0.202% slower)
    with pytest.raises(OverflowError):
        merc.PixelsToTile(0, float('-inf')) # 546ns -> 583ns (6.35% slower)

# 3. Large Scale Test Cases

def test_large_scale_linear_tiles():
    # Test a sequence of tiles for a large image (up to 1000x1000 pixels)
    merc = GlobalMercator()
    for px in range(0, 1000, 256):
        for py in range(0, 1000, 256):
            tx, ty = merc.PixelsToTile(px, py)

def test_large_scale_random_tiles():
    # Test random pixel positions within a large image
    merc = GlobalMercator()
    for px, py in [(0, 0), (999, 999), (500, 500), (256, 512), (800, 200), (255, 255), (257, 257)]:
        tx, ty = merc.PixelsToTile(px, py) # 3.52μs -> 3.23μs (9.03% faster)

def test_large_scale_tile_size():
    # Large tile size
    merc = GlobalMercator(tileSize=1000)
    codeflash_output = merc.PixelsToTile(0, 0) # 1.07μs -> 881ns (21.7% faster)
    codeflash_output = merc.PixelsToTile(999, 999) # 532ns -> 500ns (6.40% faster)
    codeflash_output = merc.PixelsToTile(1000, 1000) # 385ns -> 363ns (6.06% faster)
    codeflash_output = merc.PixelsToTile(1999, 1999) # 393ns -> 361ns (8.86% faster)
    codeflash_output = merc.PixelsToTile(2000, 2000) # 370ns -> 332ns (11.4% faster)

def test_large_scale_high_pixel_values():
    # Very high pixel values, but within reasonable integer range
    merc = GlobalMercator()
    px = 999 * merc.tileSize
    py = 999 * merc.tileSize
    codeflash_output = merc.PixelsToTile(px, py) # 1.17μs -> 1.04μs (12.6% faster)
    codeflash_output = merc.PixelsToTile(px + 1, py + 1) # 506ns -> 452ns (11.9% faster)

def test_large_scale_sequential_tiles():
    # Ensure sequential tiles are correct for a long row
    merc = GlobalMercator()
    for i in range(1000):
        px = i * merc.tileSize
        py = 0
        tx, ty = merc.PixelsToTile(px, py) # 368μs -> 338μs (8.78% faster)

def test_large_scale_sequential_tiles_column():
    # Ensure sequential tiles are correct for a long column
    merc = GlobalMercator()
    for i in range(1000):
        px = 0
        py = i * merc.tileSize
        tx, ty = merc.PixelsToTile(px, py) # 367μs -> 337μs (8.69% faster)

# Additional: test for correct type in output
def test_output_type():
    merc = GlobalMercator()
    tx, ty = merc.PixelsToTile(123, 456) # 1.39μs -> 1.17μs (18.7% 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-GlobalMercator.PixelsToTile-mh4iz95n and push.