⚡️ Speed up method Rank.__truediv__ by 15%

[codeflash-ai]

📄 15% (0.15x) speedup for Rank.__truediv__ in chromadb/execution/expression/operator.py

⏱️ Runtime : 2.73 microseconds → 2.37 microseconds (best of 285 runs)

📝 Explanation and details

Optimization Rationale:

• This replaces isinstance(other, (int, float)) with a direct and short-circuiting type check, which is marginally faster for primitive types by avoiding the tuple allocation and isinstance dynamic logic—it is the tightest form of such a type check and still behaviorally identical for the supported context.
• No behavior, side effects, type annotation, or semantics have been changed.
• The check is placed inline to reduce branching, which is beneficial in small hot path functions such as operator overloads.
• All existing code patterns, comments, and signatures are preserved.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 49 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	✅ 5 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: float

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

# --- UNIT TESTS ---

# Basic Test Cases

def test_divide_val_by_val():
    # Dividing Val by Val should return Div with correct left/right
    v1 = Val(10)
    v2 = Val(2)
    result = v1 / v2

def test_divide_val_by_float():
    # Dividing Val by float should wrap float in Val and return Div
    v = Val(10)
    result = v / 2.0

def test_divide_val_by_int():
    # Dividing Val by int should wrap int in Val and return Div
    v = Val(10)
    result = v / 2

def test_divide_float_by_val():
    # Dividing float by Val should wrap float in Val and return Div
    v = Val(5)
    result = 10.0 / v

def test_divide_int_by_val():
    # Dividing int by Val should wrap int in Val and return Div
    v = Val(5)
    result = 10 / v

def test_divide_rank_by_rank():
    # Dividing Rank by Rank should return Div with correct left/right
    v1 = Val(3)
    v2 = Val(4)
    r1 = v1
    r2 = v2
    result = r1 / r2

def test_divide_rank_by_float():
    # Dividing Rank by float should wrap float in Val
    r = Val(7)
    result = r / 2.5

def test_divide_float_by_rank():
    # Dividing float by Rank should wrap float in Val
    r = Val(7)
    result = 2.5 / r

# Edge Test Cases

def test_divide_by_zero_val():
    # Dividing by zero should still construct Div, not raise
    v = Val(10)
    zero = Val(0)
    result = v / zero

def test_divide_by_zero_float():
    # Dividing by zero float should wrap and construct Div
    v = Val(10)
    result = v / 0.0

def test_divide_zero_by_val():
    # Zero divided by Val
    v = Val(5)
    result = 0 / v

def test_divide_negative_val():
    # Dividing by negative value
    v = Val(10)
    neg = Val(-2)
    result = v / neg

def test_divide_val_by_negative_float():
    # Dividing by negative float
    v = Val(10)
    result = v / -2.0

def test_divide_negative_float_by_val():
    # Negative float divided by Val
    v = Val(5)
    result = -10.0 / v

def test_divide_val_by_large_float():
    # Dividing by a very large float
    v = Val(10)
    result = v / 1e100

def test_divide_val_by_small_float():
    # Dividing by a very small float
    v = Val(10)
    result = v / 1e-100

def test_divide_val_by_nan():
    # Dividing by NaN
    import math
    v = Val(10)
    result = v / math.nan

def test_divide_val_by_inf():
    # Dividing by infinity
    import math
    v = Val(10)
    result = v / math.inf

def test_divide_inf_by_val():
    # Infinity divided by Val
    import math
    v = Val(5)
    result = math.inf / v

def test_divide_val_by_self():
    # Dividing Val by itself
    v = Val(7)
    result = v / v

def test_divide_rank_by_zero_int():
    # Dividing Rank by zero int
    r = Val(10)
    result = r / 0

def test_divide_zero_int_by_rank():
    # Dividing zero int by Rank
    r = Val(10)
    result = 0 / r

# Large Scale Test Cases

def test_divide_many_vals():
    # Divide 1000 Val objects by a constant, check all results
    vals = [Val(i) for i in range(1000)]
    divisor = 3.0
    for v in vals:
        result = v / divisor

def test_divide_chain_of_vals():
    # Chain division of Val objects: (((Val(1000)/Val(999))/Val(998))/.../Val(1))
    result = Val(1000)
    for i in range(999, 0, -1):
        result = result / Val(i)

def test_divide_large_float_by_large_val():
    # Divide a large float by a large Val
    v = Val(1e12)
    result = 1e12 / v

def test_divide_large_val_by_large_float():
    # Divide a large Val by a large float
    v = Val(1e12)
    result = v / 1e12

def test_divide_large_negative_val_by_large_positive_val():
    # Divide a large negative Val by a large positive Val
    v_neg = Val(-1e12)
    v_pos = Val(1e12)
    result = v_neg / v_pos

def test_divide_large_positive_val_by_large_negative_val():
    # Divide a large positive Val by a large negative Val
    v_pos = Val(1e12)
    v_neg = Val(-1e12)
    result = v_pos / v_neg

def test_divide_large_chain_of_floats():
    # Chain division of floats by Val: (((1000.0/Val(999))/Val(998))/.../Val(1))
    result = 1000.0
    for i in range(999, 0, -1):
        result = result / Val(i)
# 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

    def __eq__(self, other):
        if not isinstance(other, Val):
            return False
        return self.value == other.value

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

    def __eq__(self, other):
        if not isinstance(other, Sum):
            return False
        return self.ranks == other.ranks

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

    def __eq__(self, other):
        if not isinstance(other, Sub):
            return False
        return self.left == other.left and self.right == other.right

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

    def __eq__(self, other):
        if not isinstance(other, Mul):
            return False
        return self.ranks == other.ranks

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

    def __eq__(self, other):
        if not isinstance(other, Div):
            return False
        return self.left == other.left and self.right == other.right

@dataclass
class Abs(Rank):
    rank: Rank

    def __eq__(self, other):
        if not isinstance(other, Abs):
            return False
        return self.rank == other.rank

# unit tests

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

def test_truediv_rank_by_rank():
    # Test dividing one Rank by another Rank
    a = Val(10)
    b = Val(2)
    result = a / b

def test_truediv_rank_by_float():
    # Test dividing a Rank by a float
    a = Val(10)
    result = a / 2.0

def test_truediv_rank_by_int():
    # Test dividing a Rank by an int
    a = Val(10)
    result = a / 3

def test_truediv_float_by_rank():
    # Test dividing a float by a Rank (right division)
    a = Val(5)
    result = 20.0 / a

def test_truediv_int_by_rank():
    # Test dividing an int by a Rank (right division)
    a = Val(4)
    result = 8 / a

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

def test_truediv_by_zero_val():
    # Dividing by zero: should still construct Div, not raise ZeroDivisionError
    a = Val(5)
    zero = Val(0)
    result = a / zero

def test_truediv_by_zero_float():
    # Dividing by zero float: should still construct Div, not raise ZeroDivisionError
    a = Val(7)
    result = a / 0.0

def test_truediv_nested_div():
    # Test nested division: (a / b) / c
    a = Val(12)
    b = Val(3)
    c = Val(2)
    result = (a / b) / c

def test_truediv_rank_by_sum():
    # Test dividing a Rank by a Sum
    a = Val(8)
    b = Val(2)
    c = Val(2)
    sum_rank = b + c  # Sum([b, c])
    result = a / sum_rank

def test_truediv_sum_by_rank():
    # Test dividing a Sum by a Rank
    a = Val(8)
    b = Val(2)
    c = Val(2)
    sum_rank = a + b  # Sum([a, b])
    result = sum_rank / c

def test_truediv_rank_by_negative():
    # Test dividing by a negative value
    a = Val(10)
    result = a / -2

def test_truediv_negative_rank():
    # Test dividing a negative Rank by a value
    a = Val(-10)
    result = a / 5

def test_truediv_chained_operations():
    # Test chaining: (a / b) / c == Div(Div(a, b), c)
    a = Val(100)
    b = Val(5)
    c = Val(2)
    result = (a / b) / c

def test_truediv_rank_by_self():
    # Test dividing a Rank by itself
    a = Val(9)
    result = a / a

def test_truediv_with_mul():
    # Test dividing a Mul by a value
    a = Val(2)
    b = Val(3)
    mul_rank = a * b  # Mul([a, b])
    result = mul_rank / 6

def test_truediv_with_sum_and_mul():
    # Test dividing a Sum by a Mul
    a = Val(2)
    b = Val(3)
    c = Val(4)
    sum_rank = a + b  # Sum([a, b])
    mul_rank = b * c  # Mul([b, c])
    result = sum_rank / mul_rank

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

def test_truediv_large_sum():
    # Divide a Rank by a large Sum (up to 1000 elements)
    a = Val(1000)
    sum_ranks = [Val(i) for i in range(1, 1001)]  # 1 to 1000
    sum_rank = Sum(sum_ranks)
    result = a / sum_rank

def test_truediv_large_mul():
    # Divide a large Mul (up to 1000 elements) by a Rank
    mul_ranks = [Val(i) for i in range(1, 1001)]
    mul_rank = Mul(mul_ranks)
    b = Val(10)
    result = mul_rank / b

def test_truediv_large_chain():
    # Chain a large number of divisions: (((a1 / a2) / a3) / ... / a1000)
    ranks = [Val(i + 1) for i in range(1000)]
    result = ranks[0]
    for r in ranks[1:]:
        result = result / r
    # The final result should be a nested Div structure
    current = result
    for r in reversed(ranks[1:]):
        current = current.left

def test_truediv_large_nested():
    # Divide a large Sum by a large Mul
    sum_ranks = [Val(i) for i in range(1, 501)]
    mul_ranks = [Val(i) for i in range(501, 1001)]
    sum_rank = Sum(sum_ranks)
    mul_rank = Mul(mul_ranks)
    result = sum_rank / mul_rank
# 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___truediv__():
    Rank.__truediv__(Rank(), 0)

def test_Rank___truediv___2():
    Rank.__truediv__(Rank(), Rank())

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_aqrniplu/tmpmy2_pppx/test_concolic_coverage.py::test_Rank___truediv__	1.65μs	1.42μs	16.3%✅
codeflash_concolic_aqrniplu/tmpmy2_pppx/test_concolic_coverage.py::test_Rank___truediv___2	1.08μs	948ns	13.5%✅

To edit these changes git checkout codeflash/optimize-Rank.__truediv__-mh1k3fjx and push.