⚡️ Speed up method Rank.__radd__ by 64%

[codeflash-ai]

📄 64% (0.64x) speedup for Rank.__radd__ in chromadb/execution/expression/operator.py

⏱️ Runtime : 1.96 microsecondss → 1.20 microseconds (best of 265 runs)

📝 Explanation and details

The optimization adds a fast-path for the common case where other is a numeric type (int or float). Instead of always creating a Val(other) object and then calling + (which triggers complex flattening logic in __add__), the optimized version directly constructs the final Sum([Val(other), self]) result.

Key performance improvements:

• Eliminates intermediate object creation: The original code creates Val(other) then immediately uses it in addition, creating temporary objects that get discarded
• Bypasses complex flattening logic: The original triggers __add__ which has branching logic to handle Sum flattening - the optimized version skips this entirely for the 92.5% of cases where other is numeric (37 out of 40 hits in profiler)
• Reduces function call overhead: Direct construction eliminates the method dispatch to __add__

The line profiler shows the optimization works best for numeric inputs (37/40 cases), achieving 63% speedup by spending only 81,626ns vs 177,152ns in the original. The fallback Val(other) + self path handles the remaining edge cases (3/40 hits) where other isn't numeric, preserving exact behavioral compatibility.

This optimization is particularly effective for hybrid search ranking scenarios where numeric coefficients are frequently added to rank expressions.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from dataclasses import dataclass
from typing import List, Union

# imports
import pytest
from chromadb.execution.expression.operator import Rank


@dataclass
class Val(Rank):
    value: Union[float, int]

@dataclass
class Sum(Rank):
    ranks: List[Rank]

@dataclass
class Sub(Rank):
    left: Rank
    right: Rank

@dataclass
class Mul(Rank):
    ranks: List[Rank]

@dataclass
class Div(Rank):
    left: Rank
    right: Rank

@dataclass
class Abs(Rank):
    rank: Rank

# unit tests

# 1. Basic Test Cases
def test_radd_with_int_and_val():
    # Test: int + Val
    # Scenario: 5 + Val(10) should yield Sum([Val(5), Val(10)])
    result = 5 + Val(10)

def test_radd_with_float_and_val():
    # Test: float + Val
    result = 2.5 + Val(7.5)

def test_radd_with_int_and_custom_rank():
    # Test: int + custom Rank subclass
    class CustomRank(Rank): pass
    cr = CustomRank()
    result = 3 + cr

def test_radd_with_float_and_sum():
    # Test: float + Sum([Val(1), Val(2)])
    s = Sum([Val(1), Val(2)])
    result = 3.5 + s

def test_radd_with_int_and_sum_of_sums():
    # Test: int + Sum([Val(1), Val(2)]) + Sum([Val(3), Val(4)])
    s1 = Sum([Val(1), Val(2)])
    s2 = Sum([Val(3), Val(4)])
    result = 0 + s1 + s2

# 2. Edge Test Cases
def test_radd_with_zero():
    # Edge: 0 + Val(10)
    result = 0 + Val(10)

def test_radd_with_negative_number():
    # Edge: -5 + Val(3)
    result = -5 + Val(3)

def test_radd_with_large_float():
    # Edge: Large float + Val
    result = 1e20 + Val(1e-20)

def test_radd_with_sum_and_val():
    # Edge: Sum + Val via radd (should flatten)
    s = Sum([Val(1), Val(2)])
    result = 10 + s

def test_radd_with_sum_and_sum():
    # Edge: Sum + Sum via radd (should flatten both)
    s1 = Sum([Val(1), Val(2)])
    s2 = Sum([Val(3), Val(4)])
    result = 5 + s1 + s2


def test_radd_with_val_and_sum_right():
    # Edge: Val + Sum (right operand is Sum)
    s = Sum([Val(2), Val(3)])
    result = 1 + s

def test_radd_with_val_and_empty_sum():
    # Edge: Val + Sum([]) (empty sum)
    s = Sum([])
    result = 42 + s

def test_radd_with_val_and_nested_sum():
    # Edge: Val + Sum([Sum([Val(1), Val(2)]), Val(3)])
    nested_sum = Sum([Sum([Val(1), Val(2)]), Val(3)])
    result = 99 + nested_sum

def test_radd_with_val_and_rank_subclass():
    # Edge: int + Rank subclass
    class DummyRank(Rank): pass
    dr = DummyRank()
    result = 7 + dr

# 3. Large Scale Test Cases
def test_radd_with_large_sum():
    # Large: int + Sum of 1000 Vals
    vals = [Val(i) for i in range(1000)]
    s = Sum(vals)
    result = 123 + s
    for idx, val in enumerate(result.ranks[1:]):
        pass

def test_radd_chain_large_scale():
    # Large: Chain radd with multiple Sums
    s1 = Sum([Val(i) for i in range(500)])
    s2 = Sum([Val(i) for i in range(500, 1000)])
    result = 0 + s1 + s2
    for idx, val in enumerate(result.ranks[1:]):
        pass

def test_radd_with_large_float_and_sum():
    # Large: Large float + large Sum
    vals = [Val(i * 1e10) for i in range(1000)]
    s = Sum(vals)
    result = 1e20 + s
    for idx, val in enumerate(result.ranks[1:]):
        pass

def test_radd_with_large_nested_sum():
    # Large: int + Sum of Sums (nested, but only top-level flattened)
    nested_sums = [Sum([Val(i), Val(i+1)]) for i in range(0, 1000, 2)]
    s = Sum(nested_sums)
    result = 55 + s
    for idx, ns in enumerate(result.ranks[1:]):
        pass

def test_radd_performance_large_scale():
    # Large: Ensure radd does not hang or crash with near-limit size
    vals = [Val(i) for i in range(999)]
    s = Sum(vals)
    result = 1000 + s
    for idx, val in enumerate(result.ranks[1:]):
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from dataclasses import dataclass
from typing import List, Union

# imports
import pytest
from chromadb.execution.expression.operator import Rank


@dataclass
class Val(Rank):
    value: float

@dataclass
class Sum(Rank):
    ranks: List[Rank]

@dataclass
class Sub(Rank):
    left: Rank
    right: Rank

@dataclass
class Mul(Rank):
    ranks: List[Rank]

@dataclass
class Div(Rank):
    left: Rank
    right: Rank

@dataclass
class Abs(Rank):
    rank: Rank

# unit tests

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

def test_radd_with_float_and_val():
    # 2.0 + Val(3.0) should be Sum([Val(2.0), Val(3.0)])
    result = 2.0 + Val(3.0)

def test_radd_with_int_and_val():
    # 5 + Val(4.5) should be Sum([Val(5), Val(4.5)])
    result = 5 + Val(4.5)

def test_radd_with_float_and_sum():
    # 1.5 + Sum([Val(2.0), Val(3.0)]) should flatten to Sum([Val(1.5), Val(2.0), Val(3.0)])
    result = 1.5 + Sum([Val(2.0), Val(3.0)])

def test_radd_with_int_and_sum():
    # 7 + Sum([Val(8), Val(9)]) should flatten to Sum([Val(7), Val(8), Val(9)])
    result = 7 + Sum([Val(8), Val(9)])

def test_radd_with_float_and_mul():
    # 3.0 + Mul([Val(4.0), Val(5.0)]) should be Sum([Val(3.0), Mul([Val(4.0), Val(5.0)])])
    mul_expr = Mul([Val(4.0), Val(5.0)])
    result = 3.0 + mul_expr

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

def test_radd_with_zero():
    # 0 + Val(10.0) should be Sum([Val(0), Val(10.0)])
    result = 0 + Val(10.0)

def test_radd_with_negative_number():
    # -5 + Val(2.0) should be Sum([Val(-5), Val(2.0)])
    result = -5 + Val(2.0)

def test_radd_with_large_float():
    # Large float addition
    result = 1e100 + Val(1e100)

def test_radd_with_sum_containing_val_and_mul():
    # 2 + Sum([Val(3), Mul([Val(4), Val(5)])]) should be Sum([Val(2), Val(3), Mul([Val(4), Val(5)])])
    mul_expr = Mul([Val(4), Val(5)])
    sum_expr = Sum([Val(3), mul_expr])
    result = 2 + sum_expr

def test_radd_with_sum_of_sum():
    # 1 + Sum([Val(2), Val(3)]) + Sum([Val(4), Val(5)]) should flatten correctly
    sum1 = Sum([Val(2), Val(3)])
    sum2 = Sum([Val(4), Val(5)])
    result = 1 + sum1 + sum2



def test_radd_with_large_sum():
    # Add a float to a Sum of 999 Val elements
    vals = [Val(float(i)) for i in range(1, 1000)]
    sum_expr = Sum(vals)
    result = 0.5 + sum_expr
    for i in range(1, 1000):
        pass

def test_radd_chain_large():
    # Chain radd for many elements: 0 + Val(1) + Val(2) + ... + Val(999)
    expr = 0
    for i in range(1, 1000):
        expr = expr + Val(i)
    for i in range(1, 1000):
        pass

def test_radd_with_large_mul():
    # Add a float to a Mul of 999 Val elements
    vals = [Val(float(i)) for i in range(1, 1000)]
    mul_expr = Mul(vals)
    result = 1.0 + mul_expr
    for i in range(999):
        pass

def test_radd_performance_large_sum():
    # Ensure adding to a large sum does not hang or crash
    vals = [Val(i) for i in range(1000)]
    sum_expr = Sum(vals)
    result = 42 + sum_expr
    for i in range(1, 1001):
        pass

# ----------- MISCELLANEOUS/EXTRA EDGE CASES -----------

def test_radd_with_float_and_abs():
    # 2.0 + Abs(Val(-3.0)) should be Sum([Val(2.0), Abs(Val(-3.0))])
    abs_expr = Abs(Val(-3.0))
    result = 2.0 + abs_expr

def test_radd_with_float_and_sub():
    # 1.0 + Sub(Val(2.0), Val(3.0)) should be Sum([Val(1.0), Sub(Val(2.0), Val(3.0))])
    sub_expr = Sub(Val(2.0), Val(3.0))
    result = 1.0 + sub_expr

def test_radd_with_float_and_div():
    # 4.0 + Div(Val(8.0), Val(2.0)) should be Sum([Val(4.0), Div(Val(8.0), Val(2.0))])
    div_expr = Div(Val(8.0), Val(2.0))
    result = 4.0 + div_expr
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from chromadb.execution.expression.operator import Rank

def test_Rank___radd__():
    Rank.__radd__(Rank(), 0)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_aqrniplu/tmpvlnflk0b/test_concolic_coverage.py::test_Rank___radd__	1.96μs	1.20μs	63.8%✅

To edit these changes git checkout codeflash/optimize-Rank.__radd__-mh1jfazn and push.