⚡️ Speed up function ror_ by 17%

[codeflash-ai]

📄 17% (0.17x) speedup for ror_ in pandas/core/roperator.py

⏱️ Runtime : 1.06 milliseconds → 911 microseconds (best of 220 runs)

📝 Explanation and details

The optimization replaces the function call operator.or_(right, left) with the direct bitwise OR operator right | left. This eliminates the overhead of calling the operator.or_ function, which involves:

1. Function call overhead: Looking up and calling operator.or_ requires additional stack operations and Python function dispatch
2. Module attribute lookup: Accessing operator.or_ involves a module attribute lookup each time the function is called

The direct | operator bypasses these overheads and translates directly to the underlying bitwise OR operation. The test results show consistent speedups across all scenarios:

• Basic operations: 10-76% faster for simple integer and boolean operations
• Error cases: 17-25% faster even when raising TypeErrors, as the operator fails faster than the function call
• Custom objects: 8-20% faster for objects with __or__/__ror__ methods
• Large-scale operations: 18-26% faster when called repeatedly in loops

The optimization is particularly effective for this function since ror_ performs a simple reverse bitwise OR operation (right | left instead of left | right). The behavior is identical - both approaches delegate to the same underlying Python operator protocols (__or__ and __ror__ methods), but the direct operator syntax is more efficient.

This micro-optimization is valuable because bitwise operations are fundamental and may be called frequently in data manipulation contexts, especially given this is part of pandas core functionality.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations


# imports
import pytest  # used for our unit tests
from pandas.core.roperator import ror_

# unit tests

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


def test_basic_ints():
    # Test with two small positive integers
    codeflash_output = ror_(2, 4)  # 952ns -> 541ns (76.0% faster)
    # Test with two small negative integers
    codeflash_output = ror_(-2, -4)  # 541ns -> 455ns (18.9% faster)
    # Test with zero and a positive integer
    codeflash_output = ror_(0, 5)  # 231ns -> 190ns (21.6% faster)
    # Test with zero and a negative integer
    codeflash_output = ror_(0, -3)  # 282ns -> 239ns (18.0% faster)
    # Test with same integer
    codeflash_output = ror_(7, 7)  # 182ns -> 160ns (13.8% faster)


def test_basic_bools():
    # Test with booleans (True is 1, False is 0)
    codeflash_output = ror_(True, False)  # 655ns -> 431ns (52.0% faster)
    codeflash_output = ror_(False, True)  # 197ns -> 175ns (12.6% faster)
    codeflash_output = ror_(False, False)  # 168ns -> 144ns (16.7% faster)
    codeflash_output = ror_(True, True)  # 152ns -> 138ns (10.1% faster)


def test_basic_mixed_types():
    # Test with int and bool
    codeflash_output = ror_(1, True)  # 701ns -> 461ns (52.1% faster)
    codeflash_output = ror_(0, True)  # 263ns -> 220ns (19.5% faster)
    codeflash_output = ror_(0, False)  # 204ns -> 184ns (10.9% faster)
    # Test with int and long (Python 3: all int)
    codeflash_output = ror_(2, 3)  # 206ns -> 183ns (12.6% faster)


def test_basic_strings():
    # Test with strings (should raise TypeError)
    with pytest.raises(TypeError):
        ror_("a", "b")  # 1.69μs -> 1.40μs (20.3% faster)
    with pytest.raises(TypeError):
        ror_("1", 1)  # 907ns -> 758ns (19.7% faster)
    with pytest.raises(TypeError):
        ror_(1, "1")  # 632ns -> 610ns (3.61% faster)


def test_basic_lists():
    # Test with lists (should raise TypeError)
    with pytest.raises(TypeError):
        ror_([1, 2], [3, 4])  # 1.42μs -> 1.18μs (20.3% faster)
    with pytest.raises(TypeError):
        ror_([1], 2)  # 773ns -> 732ns (5.60% faster)
    with pytest.raises(TypeError):
        ror_(2, [1])  # 618ns -> 587ns (5.28% faster)


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


def test_edge_large_positive_numbers():
    # Test with large positive numbers
    a = 2**60
    b = 2**61
    codeflash_output = ror_(a, b)  # 620ns -> 439ns (41.2% faster)
    # Test with maximum 64-bit signed integer
    max_int = 2**63 - 1
    codeflash_output = ror_(max_int, 0)  # 368ns -> 349ns (5.44% faster)
    codeflash_output = ror_(0, max_int)  # 204ns -> 187ns (9.09% faster)


def test_edge_large_negative_numbers():
    # Test with large negative numbers
    a = -(2**60)
    b = -(2**61)
    codeflash_output = ror_(a, b)  # 918ns -> 704ns (30.4% faster)
    # Test with minimum 64-bit signed integer
    min_int = -(2**63)
    codeflash_output = ror_(min_int, 0)  # 381ns -> 381ns (0.000% faster)
    codeflash_output = ror_(0, min_int)  # 236ns -> 209ns (12.9% faster)


def test_edge_mixed_signs():
    # Test with one positive, one negative
    codeflash_output = ror_(-1, 1)  # 694ns -> 510ns (36.1% faster)
    codeflash_output = ror_(1, -1)  # 349ns -> 306ns (14.1% faster)
    codeflash_output = ror_(-123, 456)  # 218ns -> 216ns (0.926% faster)
    codeflash_output = ror_(456, -123)  # 193ns -> 166ns (16.3% faster)


def test_edge_float_input():
    # Bitwise or is not supported for float
    with pytest.raises(TypeError):
        ror_(1.5, 2)  # 1.85μs -> 1.49μs (24.9% faster)
    with pytest.raises(TypeError):
        ror_(2, 1.5)  # 894ns -> 739ns (21.0% faster)
    with pytest.raises(TypeError):
        ror_(1.0, 2.0)  # 547ns -> 549ns (0.364% slower)


def test_edge_none_input():
    # None is not a valid operand
    with pytest.raises(TypeError):
        ror_(None, 1)  # 1.45μs -> 1.19μs (22.6% faster)
    with pytest.raises(TypeError):
        ror_(1, None)  # 713ns -> 666ns (7.06% faster)
    with pytest.raises(TypeError):
        ror_(None, None)  # 529ns -> 524ns (0.954% faster)


def test_edge_bool_and_int():
    # True | 2 == 3, False | 2 == 2
    codeflash_output = ror_(True, 2)  # 833ns -> 583ns (42.9% faster)
    codeflash_output = ror_(False, 2)  # 365ns -> 319ns (14.4% faster)
    codeflash_output = ror_(2, True)  # 252ns -> 222ns (13.5% faster)
    codeflash_output = ror_(2, False)  # 250ns -> 221ns (13.1% faster)


def test_edge_object_input():
    # Custom objects without __or__ should fail
    class Dummy:
        pass

    with pytest.raises(TypeError):
        ror_(Dummy(), Dummy())  # 1.27μs -> 1.16μs (10.3% faster)
    with pytest.raises(TypeError):
        ror_(Dummy(), 1)  # 861ns -> 768ns (12.1% faster)
    with pytest.raises(TypeError):
        ror_(1, Dummy())  # 597ns -> 595ns (0.336% faster)


def test_edge_custom_or_method():
    # Custom objects with __or__ should work
    class MyInt:
        def __init__(self, value):
            self.value = value

        def __or__(self, other):
            # Only works if other is MyInt or int
            if isinstance(other, MyInt):
                return MyInt(self.value | other.value)
            elif isinstance(other, int):
                return MyInt(self.value | other)
            return NotImplemented

        def __ror__(self, other):
            if isinstance(other, int):
                return MyInt(self.value | other)
            return NotImplemented

        def __eq__(self, other):
            return isinstance(other, MyInt) and self.value == other.value

        def __repr__(self):
            return f"MyInt({self.value})"

    a = MyInt(2)
    b = MyInt(4)
    codeflash_output = ror_(a, b)  # 1.62μs -> 1.46μs (10.5% faster)
    codeflash_output = ror_(2, a)  # 946ns -> 823ns (14.9% faster)
    codeflash_output = ror_(a, 2)  # 626ns -> 622ns (0.643% faster)


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


def test_large_scale_many_pairs():
    # Test with a list of 1000 pairs of ints
    for i in range(1000):
        left = i
        right = 1000 - i
        codeflash_output = ror_(left, right)  # 154μs -> 127μs (21.7% faster)


def test_large_scale_all_zeros():
    # All zeros should always return zero
    for i in range(1000):
        codeflash_output = ror_(0, 0)  # 159μs -> 129μs (22.7% faster)


def test_large_scale_high_bits():
    # Test with high bit numbers
    for i in range(900, 1000):
        left = 1 << i
        right = 1 << (i + 1)
        codeflash_output = ror_(left, right)  # 17.7μs -> 14.9μs (18.8% faster)


def test_large_scale_randomized():
    # Test with random values
    import random

    random.seed(42)
    for _ in range(500):
        a = random.randint(-(2**63), 2**63 - 1)
        b = random.randint(-(2**63), 2**63 - 1)
        codeflash_output = ror_(a, b)  # 96.2μs -> 81.0μs (18.7% faster)


def test_large_scale_custom_objects():
    # Test with many custom objects
    class MyInt:
        def __init__(self, value):
            self.value = value

        def __or__(self, other):
            if isinstance(other, MyInt):
                return MyInt(self.value | other.value)
            elif isinstance(other, int):
                return MyInt(self.value | other)
            return NotImplemented

        def __ror__(self, other):
            if isinstance(other, int):
                return MyInt(self.value | other)
            return NotImplemented

        def __eq__(self, other):
            return isinstance(other, MyInt) and self.value == other.value

    for i in range(100):
        left = MyInt(i)
        right = MyInt(100 - i)
        codeflash_output = ror_(left, right)  # 37.8μs -> 35.0μs (8.02% faster)
        codeflash_output = ror_(i, right)
        codeflash_output = ror_(left, i)  # 38.2μs -> 35.3μs (8.23% 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.roperator import ror_

# unit tests

# 1. Basic Test Cases


def test_basic_ints():
    # Test with two positive integers
    codeflash_output = ror_(3, 5)  # 658ns -> 407ns (61.7% faster)
    # Test with two negative integers
    codeflash_output = ror_(-3, -5)  # 453ns -> 466ns (2.79% slower)
    # Test with one positive, one negative
    codeflash_output = ror_(3, -5)  # 257ns -> 217ns (18.4% faster)
    codeflash_output = ror_(-3, 5)  # 236ns -> 201ns (17.4% faster)
    # Test with zero
    codeflash_output = ror_(0, 5)  # 220ns -> 183ns (20.2% faster)
    codeflash_output = ror_(3, 0)  # 209ns -> 191ns (9.42% faster)
    codeflash_output = ror_(0, 0)  # 190ns -> 169ns (12.4% faster)


def test_basic_bools():
    # Test with booleans (True is 1, False is 0)
    codeflash_output = ror_(True, False)  # 623ns -> 412ns (51.2% faster)
    codeflash_output = ror_(False, True)  # 229ns -> 185ns (23.8% faster)
    codeflash_output = ror_(True, True)  # 159ns -> 134ns (18.7% faster)
    codeflash_output = ror_(False, False)  # 167ns -> 140ns (19.3% faster)


def test_basic_mixed_types():
    # Test with int and bool
    codeflash_output = ror_(1, True)  # 668ns -> 473ns (41.2% faster)
    codeflash_output = ror_(0, True)  # 297ns -> 266ns (11.7% faster)
    codeflash_output = ror_(1, False)  # 207ns -> 204ns (1.47% faster)
    # Test with bool and int
    codeflash_output = ror_(True, 2)  # 264ns -> 212ns (24.5% faster)
    codeflash_output = ror_(False, 2)  # 202ns -> 170ns (18.8% faster)


def test_basic_strings():
    # Test with strings (should raise TypeError)
    with pytest.raises(TypeError):
        ror_("a", "b")  # 1.72μs -> 1.47μs (17.0% faster)
    with pytest.raises(TypeError):
        ror_("a", 1)  # 899ns -> 760ns (18.3% faster)
    with pytest.raises(TypeError):
        ror_(1, "b")  # 651ns -> 613ns (6.20% faster)


# 2. Edge Test Cases


def test_edge_large_ints():
    # Test with very large integers
    big = 2**100
    small = 2**10
    codeflash_output = ror_(big, small)  # 677ns -> 484ns (39.9% faster)
    codeflash_output = ror_(big, big)  # 291ns -> 249ns (16.9% faster)
    codeflash_output = ror_(0, big)  # 197ns -> 174ns (13.2% faster)


def test_edge_negative_and_zero():
    # Test with negative and zero
    codeflash_output = ror_(-1, 0)  # 773ns -> 560ns (38.0% faster)
    codeflash_output = ror_(0, -1)  # 360ns -> 268ns (34.3% faster)
    codeflash_output = ror_(-1, -1)  # 274ns -> 245ns (11.8% faster)


def test_edge_non_int_types():
    # Test with floats (should raise TypeError)
    with pytest.raises(TypeError):
        ror_(1.5, 2)  # 1.71μs -> 1.52μs (11.9% faster)
    with pytest.raises(TypeError):
        ror_(2, 1.5)  # 906ns -> 780ns (16.2% faster)
    with pytest.raises(TypeError):
        ror_(1.0, 2.0)  # 607ns -> 557ns (8.98% faster)
    # Test with None
    with pytest.raises(TypeError):
        ror_(None, 1)  # 709ns -> 633ns (12.0% faster)
    with pytest.raises(TypeError):
        ror_(1, None)  # 560ns -> 494ns (13.4% faster)
    with pytest.raises(TypeError):
        ror_(None, None)  # 529ns -> 470ns (12.6% faster)
    # Test with lists
    with pytest.raises(TypeError):
        ror_([1], [2])  # 601ns -> 527ns (14.0% faster)
    with pytest.raises(TypeError):
        ror_([1], 2)  # 531ns -> 512ns (3.71% faster)
    with pytest.raises(TypeError):
        ror_(1, [2])  # 543ns -> 487ns (11.5% faster)


def test_edge_custom_object():
    # Test with an object that implements __or__ and __ror__
    class X:
        def __init__(self, value):
            self.value = value

        def __or__(self, other):
            return f"__or__:{self.value}|{other}"

        def __ror__(self, other):
            return f"__ror__:{other}|{self.value}"

    x = X(10)
    # ror_(x, 5) should call 5 | x, which will call X.__ror__
    codeflash_output = ror_(x, 5)  # 1.47μs -> 1.22μs (20.4% faster)
    # ror_(5, x) should call x | 5, which will call X.__or__
    codeflash_output = ror_(5, x)  # 786ns -> 665ns (18.2% faster)
    # ror_(x, x) should call x | x
    codeflash_output = ror_(x, x)  # 1.92μs -> 1.93μs (0.621% slower)


def test_edge_bool_and_custom_object():
    class Y:
        def __ror__(self, other):
            return f"Y.__ror__({other})"

        def __or__(self, other):
            return f"Y.__or__({other})"

    y = Y()
    codeflash_output = ror_(True, y)  # 1.61μs -> 1.38μs (16.5% faster)
    codeflash_output = ror_(y, True)  # 672ns -> 572ns (17.5% faster)


# 3. Large Scale Test Cases


def test_large_list_of_ints():
    # Test with a large list of ints, applying ror_ in a reduce-like fashion
    data = list(range(1000))  # 0, 1, 2, ..., 999
    result = 0
    for x in data:
        codeflash_output = ror_(x, result)
        result = codeflash_output  # 160μs -> 128μs (25.7% faster)
    # Should be equivalent to: reduce(lambda acc, x: acc | x, data, 0)
    expected = 0
    for x in data:
        expected = expected | x


def test_large_custom_objects():
    # Test with a large number of custom objects
    class Z:
        def __init__(self, v):
            self.v = v

        def __or__(self, other):
            return Z(self.v + (other.v if isinstance(other, Z) else other))

        def __ror__(self, other):
            return Z((other.v if isinstance(other, Z) else other) + self.v)

        def __eq__(self, other):
            return isinstance(other, Z) and self.v == other.v

    objs = [Z(i) for i in range(100)]
    result = objs[0]
    for obj in objs[1:]:
        codeflash_output = ror_(obj, result)
        result = codeflash_output  # 36.4μs -> 33.0μs (10.2% faster)


def test_large_scale_type_errors():
    # Test a large number of invalid type pairs to ensure all raise TypeError
    for i in range(100):
        with pytest.raises(TypeError):
            ror_([i], {i})
        with pytest.raises(TypeError):
            ror_({i}, [i])
        with pytest.raises(TypeError):
            ror_((i,), {i})
        with pytest.raises(TypeError):
            ror_({i}, (i,))
        with pytest.raises(TypeError):
            ror_([i], None)
        with pytest.raises(TypeError):
            ror_(None, [i])


# 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-ror_-mior3jgu and push.