⚡️ Speed up function _generate_range_overflow_safe by 32%

[codeflash-ai]

📄 32% (0.32x) speedup for _generate_range_overflow_safe in pandas/core/arrays/_ranges.py

⏱️ Runtime : 1.02 milliseconds → 773 microseconds (best of 41 runs)

📝 Explanation and details

The optimized code achieves a 32% speedup through several key micro-optimizations that eliminate redundant computations:

Primary Optimization - Caching Expensive np.uint64(i8max):

• The original code repeatedly calls np.uint64(i8max) on every function invocation, which is expensive (355ns per call based on profiler data)
• The optimization caches this value as a function attribute singleton, reducing it to a simple attribute lookup (~34ns)
• This single change provides the biggest performance gain since i64max is accessed multiple times per call

Secondary Optimizations:

• Eliminate redundant abs() calculations: Pre-compute abs_stride and reuse it instead of calling np.abs(stride) multiple times
• Avoid stride mutation: Replace in-place stride *= -1 with a local signed_stride variable, preventing unnecessary modifications to input parameters
• Cache intermediate calculations: Store endpoint - stride in a local variable when used in conditionals
• Remove unnecessary np.abs() on unsigned values: Since addend is already unsigned (np.uint64), the np.abs(addend) call is redundant

Performance Impact:
The function is called from generate_regular_range, which is used in pandas date/time range generation. Based on the function references, this is in a hot path for creating regular date ranges, making these micro-optimizations particularly valuable. The test results show consistent 30-40% improvements across various input combinations, with the biggest gains on basic cases that hit the fast path through _generate_range_overflow_safe_signed.

Behavioral Preservation:
All optimizations maintain identical functionality - the caching strategy is thread-safe for read operations, and all edge cases (overflow handling, recursion, error conditions) behave identically to the original implementation.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# imports
import pytest
from pandas._libs.lib import i8max
from pandas._libs.tslibs import OutOfBoundsDatetime
from pandas.core.arrays._ranges import _generate_range_overflow_safe

# unit tests

# --- BASIC TEST CASES ---


def test_basic_start_positive_stride():
    # Basic: start endpoint, positive stride, small periods
    codeflash_output = _generate_range_overflow_safe(
        0, 5, 2, "start"
    )  # 15.8μs -> 12.3μs (28.4% faster)
    codeflash_output = _generate_range_overflow_safe(
        10, 3, 1, "start"
    )  # 6.50μs -> 4.66μs (39.5% faster)
    codeflash_output = _generate_range_overflow_safe(
        -5, 4, 3, "start"
    )  # 5.13μs -> 3.76μs (36.3% faster)


def test_basic_end_positive_stride():
    # Basic: end endpoint, positive stride, small periods
    codeflash_output = _generate_range_overflow_safe(
        10, 5, 2, "end"
    )  # 15.8μs -> 12.0μs (32.2% faster)
    codeflash_output = _generate_range_overflow_safe(
        13, 3, 1, "end"
    )  # 6.35μs -> 4.62μs (37.6% faster)
    codeflash_output = _generate_range_overflow_safe(
        7, 4, 3, "end"
    )  # 5.15μs -> 3.92μs (31.3% faster)


def test_basic_negative_stride():
    # Basic: negative stride
    codeflash_output = _generate_range_overflow_safe(
        10, 5, -2, "start"
    )  # 15.4μs -> 11.4μs (34.9% faster)
    codeflash_output = _generate_range_overflow_safe(
        0, 3, -1, "start"
    )  # 6.41μs -> 4.72μs (35.7% faster)
    codeflash_output = _generate_range_overflow_safe(
        -5, 4, -3, "start"
    )  # 5.34μs -> 3.91μs (36.6% faster)


def test_basic_end_negative_stride():
    # Basic: end endpoint, negative stride
    codeflash_output = _generate_range_overflow_safe(
        0, 5, -2, "end"
    )  # 15.3μs -> 11.7μs (30.4% faster)
    codeflash_output = _generate_range_overflow_safe(
        -3, 3, -1, "end"
    )  # 6.56μs -> 4.76μs (37.9% faster)
    codeflash_output = _generate_range_overflow_safe(
        -17, 4, -3, "end"
    )  # 5.22μs -> 3.82μs (36.5% faster)


def test_basic_stride_zero():
    # Basic: stride zero should always return endpoint
    codeflash_output = _generate_range_overflow_safe(
        10, 5, 0, "start"
    )  # 15.3μs -> 11.7μs (31.1% faster)
    codeflash_output = _generate_range_overflow_safe(
        -5, 3, 0, "end"
    )  # 6.48μs -> 4.93μs (31.5% faster)


def test_basic_periods_one():
    # Basic: periods=1 should always return endpoint
    codeflash_output = _generate_range_overflow_safe(
        100, 1, 10, "start"
    )  # 15.7μs -> 11.7μs (33.9% faster)
    codeflash_output = _generate_range_overflow_safe(
        -100, 1, -10, "end"
    )  # 6.95μs -> 4.91μs (41.4% faster)


def test_basic_periods_zero():
    # Basic: periods=0 should always return endpoint
    codeflash_output = _generate_range_overflow_safe(
        100, 0, 10, "start"
    )  # 15.2μs -> 11.5μs (31.7% faster)
    codeflash_output = _generate_range_overflow_safe(
        -100, 0, -10, "end"
    )  # 6.80μs -> 4.75μs (43.2% faster)


# --- EDGE TEST CASES ---


def test_edge_max_int64():
    # Edge: endpoint at max int64, stride positive, periods small
    max_i64 = i8max
    codeflash_output = _generate_range_overflow_safe(
        max_i64, 1, 1, "start"
    )  # 18.2μs -> 16.7μs (8.90% faster)
    codeflash_output = _generate_range_overflow_safe(
        max_i64, 1, 0, "start"
    )  # 7.07μs -> 5.55μs (27.4% faster)
    # Edge: endpoint at max int64, stride negative
    codeflash_output = _generate_range_overflow_safe(
        max_i64, 2, -1, "start"
    )  # 5.24μs -> 3.93μs (33.3% faster)


def test_edge_overflow_raises():
    # Edge: periods * stride overflows int64, should raise OutOfBoundsDatetime
    max_i64 = i8max
    # Large periods, positive stride, start at max_i64
    with pytest.raises(OutOfBoundsDatetime):
        _generate_range_overflow_safe(max_i64, max_i64, 2, "start")
    # Large periods, negative stride, start at min_i64
    min_i64 = -i8max - 1
    with pytest.raises(OutOfBoundsDatetime):
        _generate_range_overflow_safe(min_i64, max_i64, -2, "start")
    # Large periods, positive stride, end at max_i64
    with pytest.raises(OutOfBoundsDatetime):
        _generate_range_overflow_safe(max_i64, max_i64, 2, "end")


def test_edge_invalid_side():
    # Edge: invalid side argument should raise AssertionError
    with pytest.raises(AssertionError):
        _generate_range_overflow_safe(
            0, 1, 1, "middle"
        )  # 980ns -> 993ns (1.31% slower)
    with pytest.raises(AssertionError):
        _generate_range_overflow_safe(0, 1, 1, "")  # 486ns -> 490ns (0.816% slower)


def test_edge_zero_stride_large_periods():
    # Edge: zero stride, large periods, should not overflow
    codeflash_output = _generate_range_overflow_safe(
        0, 1000, 0, "start"
    )  # 26.7μs -> 19.7μs (35.2% faster)
    codeflash_output = _generate_range_overflow_safe(
        123456789, 999, 0, "end"
    )  # 7.29μs -> 5.21μs (40.1% faster)


def test_edge_stride_sign_switch():
    # Edge: stride sign switch at endpoint
    codeflash_output = _generate_range_overflow_safe(
        0, 2, -1, "start"
    )  # 26.4μs -> 19.9μs (32.5% faster)
    codeflash_output = _generate_range_overflow_safe(
        0, 2, 1, "end"
    )  # 6.99μs -> 4.97μs (40.5% faster)


def test_large_scale_positive_stride():
    # Large scale: periods and stride are large, but not overflowing
    start = 0
    periods = 1000
    stride = 1000000
    expected = start + periods * stride
    codeflash_output = _generate_range_overflow_safe(
        start, periods, stride, "start"
    )  # 26.1μs -> 19.9μs (31.2% faster)


def test_large_scale_negative_stride():
    # Large scale: periods and stride are large, negative stride
    start = 0
    periods = 1000
    stride = -1000000
    expected = start + periods * stride
    codeflash_output = _generate_range_overflow_safe(
        start, periods, stride, "start"
    )  # 18.0μs -> 13.6μs (32.0% faster)


def test_large_scale_end_side():
    # Large scale: periods and stride are large, using side="end"
    end = 1000000000
    periods = 1000
    stride = 1000000
    expected = end - periods * stride
    codeflash_output = _generate_range_overflow_safe(
        end, periods, stride, "end"
    )  # 17.4μs -> 13.0μs (33.7% faster)


def test_large_scale_overflow_raises():
    # Large scale: periods and stride large enough to overflow, should raise
    max_i64 = i8max
    periods = max_i64 // 2
    stride = max_i64
    with pytest.raises(OutOfBoundsDatetime):
        _generate_range_overflow_safe(
            max_i64, periods, stride, "start"
        )  # 22.1μs -> 15.7μs (40.5% faster)


def test_large_scale_split_recursion():
    # Large scale: force recursion by using large periods and stride
    # This test is to ensure the recursive splitting works and does not overflow
    start = 0
    periods = 999
    stride = 999
    expected = start + periods * stride
    codeflash_output = _generate_range_overflow_safe(
        start, periods, stride, "start"
    )  # 20.4μs -> 15.6μs (30.5% faster)


def test_large_scale_stride_zero():
    # Large scale: stride zero with large periods, should not overflow
    codeflash_output = _generate_range_overflow_safe(
        123456789, 1000, 0, "start"
    )  # 17.0μs -> 13.3μs (28.5% faster)
    codeflash_output = _generate_range_overflow_safe(
        -123456789, 1000, 0, "end"
    )  # 6.93μs -> 4.94μs (40.3% faster)


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

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from pandas.core.arrays._ranges import _generate_range_overflow_safe

# Minimal stubs for pandas._libs.lib.i8max and pandas._libs.tslibs.OutOfBoundsDatetime, iNaT
i8max = 9223372036854775807  # max int64 value


class OutOfBoundsDatetime(Exception):
    pass


iNaT = -9223372036854775808  # typically used as "missing" in pandas

# unit tests

# ----------- BASIC TEST CASES -----------


def test_basic_positive_stride_start():
    # Basic: start endpoint, positive stride, small periods
    codeflash_output = _generate_range_overflow_safe(
        0, 5, 10, "start"
    )  # 22.4μs -> 16.5μs (35.3% faster)


def test_basic_positive_stride_end():
    # Basic: end endpoint, positive stride, small periods
    codeflash_output = _generate_range_overflow_safe(
        100, 4, 25, "end"
    )  # 18.1μs -> 13.7μs (32.1% faster)


def test_basic_negative_stride_start():
    # Basic: start endpoint, negative stride, small periods
    codeflash_output = _generate_range_overflow_safe(
        50, 5, -10, "start"
    )  # 17.1μs -> 12.8μs (33.5% faster)


def test_basic_negative_stride_end():
    # Basic: end endpoint, negative stride, small periods
    codeflash_output = _generate_range_overflow_safe(
        -100, 4, -25, "end"
    )  # 16.5μs -> 12.3μs (33.6% faster)


def test_basic_stride_zero():
    # Basic: stride zero, periods > 0, should return endpoint unchanged
    codeflash_output = _generate_range_overflow_safe(
        12345, 10, 0, "start"
    )  # 16.8μs -> 12.4μs (35.6% faster)
    codeflash_output = _generate_range_overflow_safe(
        12345, 10, 0, "end"
    )  # 6.70μs -> 4.83μs (38.8% faster)


def test_basic_one_period():
    # Basic: periods = 1, should return endpoint unchanged
    codeflash_output = _generate_range_overflow_safe(
        1000, 1, 50, "start"
    )  # 16.1μs -> 12.3μs (31.2% faster)
    codeflash_output = _generate_range_overflow_safe(
        1000, 1, 50, "end"
    )  # 6.88μs -> 5.00μs (37.6% faster)


# ----------- EDGE TEST CASES -----------


def test_edge_max_int64_no_overflow():
    # Edge: endpoint at max int64, stride positive, periods = 1, should not overflow
    codeflash_output = _generate_range_overflow_safe(
        i8max, 1, 1, "start"
    )  # 19.4μs -> 16.8μs (15.6% faster)


def test_edge_zero_periods():
    # Edge: periods = 0, should return endpoint unchanged
    codeflash_output = _generate_range_overflow_safe(
        500, 0, 10, "start"
    )  # 26.9μs -> 19.8μs (35.7% faster)
    codeflash_output = _generate_range_overflow_safe(
        500, 0, 10, "end"
    )  # 7.11μs -> 4.99μs (42.3% faster)


def test_edge_invalid_side():
    # Edge: invalid side argument, should raise AssertionError
    with pytest.raises(AssertionError):
        _generate_range_overflow_safe(
            100, 5, 10, "invalid"
        )  # 1.04μs -> 1.06μs (2.07% slower)


def test_edge_stride_sign_mismatch():
    # Edge: stride and endpoint have opposite signs, periods large
    # Should not overflow if endpoint + addend does not overflow
    codeflash_output = _generate_range_overflow_safe(
        -100, 5, 10, "start"
    )  # 26.6μs -> 19.8μs (34.1% faster)
    codeflash_output = _generate_range_overflow_safe(
        100, 5, -10, "start"
    )  # 6.88μs -> 5.35μs (28.8% faster)


def test_large_periods_positive_stride():
    # Large: periods = 1000, stride = 1, endpoint = 0
    codeflash_output = _generate_range_overflow_safe(
        0, 1000, 1, "start"
    )  # 26.2μs -> 19.8μs (32.6% faster)


def test_large_periods_negative_stride():
    # Large: periods = 1000, stride = -1, endpoint = 0
    codeflash_output = _generate_range_overflow_safe(
        0, 1000, -1, "start"
    )  # 18.2μs -> 13.9μs (31.2% faster)


def test_large_periods_stride_end():
    # Large: periods = 1000, stride = 1, endpoint = 1000, side="end"
    codeflash_output = _generate_range_overflow_safe(
        1000, 1000, 1, "end"
    )  # 17.3μs -> 12.9μs (33.9% faster)


def test_large_stride_no_overflow():
    # Large: stride is large but not overflowing, periods small
    stride = i8max // 1000
    codeflash_output = _generate_range_overflow_safe(
        0, 1000, stride, "start"
    )  # 17.1μs -> 13.3μs (28.8% faster)


def test_large_endpoint_and_stride():
    # Large: endpoint and stride both large, but no overflow
    endpoint = i8max - 1000
    stride = 1
    periods = 999
    codeflash_output = _generate_range_overflow_safe(
        endpoint, periods, stride, "start"
    )  # 26.7μs -> 19.7μs (35.1% faster)


def test_large_negative_endpoint_and_stride():
    # Large: negative endpoint, negative stride, large periods
    endpoint = -i8max + 1000
    stride = -1
    periods = 999
    codeflash_output = _generate_range_overflow_safe(
        endpoint, periods, stride, "start"
    )  # 27.2μs -> 20.3μs (34.4% faster)


def test_large_periods_stride_zero():
    # Large: periods = 1000, stride = 0, endpoint arbitrary
    codeflash_output = _generate_range_overflow_safe(
        123456789, 1000, 0, "start"
    )  # 26.8μs -> 20.0μs (34.0% faster)
    codeflash_output = _generate_range_overflow_safe(
        123456789, 1000, 0, "end"
    )  # 6.69μs -> 4.87μs (37.3% faster)


def test_large_periods_one_stride():
    # Large: periods = 999, stride = 1, endpoint = 0
    codeflash_output = _generate_range_overflow_safe(
        0, 999, 1, "start"
    )  # 17.3μs -> 12.8μs (35.0% faster)


def test_large_periods_max_stride():
    # Large: periods = 1, stride = i8max, endpoint = 0
    codeflash_output = _generate_range_overflow_safe(
        0, 1, i8max, "start"
    )  # 16.5μs -> 13.1μs (26.2% faster)


def test_large_periods_negative_max_stride():
    # Large: periods = 1, stride = -i8max, endpoint = 0
    codeflash_output = _generate_range_overflow_safe(
        0, 1, -i8max, "start"
    )  # 17.0μs -> 13.2μs (28.8% faster)


def test_large_periods_side_end():
    # Large: periods = 1000, stride = 1, endpoint = 1000, side="end"
    codeflash_output = _generate_range_overflow_safe(
        1000, 1000, 1, "end"
    )  # 16.9μs -> 13.0μs (29.7% faster)


def test_large_periods_side_end_negative_stride():
    # Large: periods = 1000, stride = -1, endpoint = -1000, side="end"
    codeflash_output = _generate_range_overflow_safe(
        -1000, 1000, -1, "end"
    )  # 16.5μs -> 13.0μs (26.7% faster)


# ----------- DETERMINISTIC & MISC TESTS -----------


def test_deterministic_repeat():
    # Deterministic: repeated calls should return same result
    for _ in range(10):
        codeflash_output = _generate_range_overflow_safe(
            0, 5, 10, "start"
        )  # 60.2μs -> 44.2μs (36.2% faster)


def test_misc_large_stride_small_periods():
    # Misc: large stride, small periods, should not overflow
    stride = i8max // 2
    periods = 2
    codeflash_output = _generate_range_overflow_safe(
        0, periods, stride, "start"
    )  # 26.8μs -> 20.1μs (33.9% faster)


def test_misc_negative_stride_small_periods():
    # Misc: large negative stride, small periods, should not overflow
    stride = -(i8max // 2)
    periods = 2
    codeflash_output = _generate_range_overflow_safe(
        0, periods, stride, "start"
    )  # 18.0μs -> 14.5μs (23.9% faster)


def test_misc_endpoint_zero():
    # Misc: endpoint zero, periods and stride arbitrary
    codeflash_output = _generate_range_overflow_safe(
        0, 1, 1, "start"
    )  # 17.3μs -> 12.6μs (37.4% faster)
    codeflash_output = _generate_range_overflow_safe(
        0, 1, 1, "end"
    )  # 6.93μs -> 5.01μs (38.4% faster)


def test_misc_endpoint_negative():
    # Misc: endpoint negative, positive stride
    codeflash_output = _generate_range_overflow_safe(
        -100, 5, 10, "start"
    )  # 16.1μs -> 11.9μs (35.5% faster)


def test_misc_endpoint_positive_negative_stride():
    # Misc: endpoint positive, negative stride
    codeflash_output = _generate_range_overflow_safe(
        100, 5, -10, "start"
    )  # 15.9μs -> 12.9μs (23.3% 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-_generate_range_overflow_safe-mir3xuub and push.