⚡️ Speed up function default_gamma by 39%

[codeflash-ai]

📄 39% (0.39x) speedup for default_gamma in optuna/samplers/_tpe/sampler.py

⏱️ Runtime : 1.09 milliseconds → 780 microseconds (best of 271 runs)

📝 Explanation and details

The optimization achieves a 39% speedup by avoiding expensive math.ceil() calls when the result will exceed the cap of 25.

Key optimization: The code splits the original single-line computation into an early return pattern:

1. First computes gamma = 0.1 * x
2. If gamma >= 25, returns 25 directly without calling math.ceil()
3. Otherwise calls math.ceil(gamma) as before

Why this is faster: math.ceil() is a relatively expensive function call. When x >= 250, the original code unnecessarily computes math.ceil(0.1 * x) even though min() will always choose 25. The optimization eliminates this wasteful computation for large inputs.

Performance gains by input range:

• Large inputs (x ≥ 250): 50-85% faster - avoids math.ceil() entirely
• Medium inputs (x < 250): 25-35% faster - still calls math.ceil() but saves the min() call
• Small/negative inputs: 10-30% faster - modest gains from eliminating min()

The line profiler shows that in the test workload, 46% of calls (2266/4904) took the early return path, explaining the significant overall speedup. This optimization is particularly effective for workloads with many large input values, which is common in hyperparameter optimization scenarios where this function is used.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import math  # used by the function under test

# imports
import pytest  # used for our unit tests
from optuna.samplers._tpe.sampler import default_gamma

# unit tests

# --- Basic Test Cases ---

def test_gamma_basic_small_integers():
    # Test with small positive integers
    codeflash_output = default_gamma(1) # 706ns -> 683ns (3.37% faster)
    codeflash_output = default_gamma(5) # 404ns -> 294ns (37.4% faster)
    codeflash_output = default_gamma(10) # 222ns -> 173ns (28.3% faster)
    codeflash_output = default_gamma(15) # 222ns -> 170ns (30.6% faster)
    codeflash_output = default_gamma(20) # 223ns -> 177ns (26.0% faster)
    codeflash_output = default_gamma(25) # 218ns -> 172ns (26.7% faster)

def test_gamma_basic_typical_integers():
    # Test with typical values below the cap
    codeflash_output = default_gamma(50) # 662ns -> 601ns (10.1% faster)
    codeflash_output = default_gamma(99) # 374ns -> 279ns (34.1% faster)

def test_gamma_basic_at_cap():
    # Test values where the result hits the cap of 25
    codeflash_output = default_gamma(250) # 671ns -> 445ns (50.8% faster)
    codeflash_output = default_gamma(249) # 362ns -> 427ns (15.2% slower)
    codeflash_output = default_gamma(260) # 275ns -> 160ns (71.9% faster)

# --- Edge Test Cases ---

def test_gamma_zero_and_negative():
    # Test with zero input
    codeflash_output = default_gamma(0) # 650ns -> 600ns (8.33% faster)
    # Test with negative input
    codeflash_output = default_gamma(-1) # 395ns -> 331ns (19.3% faster)
    codeflash_output = default_gamma(-10) # 294ns -> 240ns (22.5% faster)
    codeflash_output = default_gamma(-100) # 275ns -> 212ns (29.7% faster)

def test_gamma_edge_near_cap():
    # Test values just below and above the cap threshold
    codeflash_output = default_gamma(249) # 689ns -> 582ns (18.4% faster)
    codeflash_output = default_gamma(250) # 338ns -> 288ns (17.4% faster)
    codeflash_output = default_gamma(251) # 306ns -> 150ns (104% faster)

def test_gamma_large_integer():
    # Test with a large integer well above the cap
    codeflash_output = default_gamma(1000) # 701ns -> 387ns (81.1% faster)
    codeflash_output = default_gamma(10000) # 469ns -> 197ns (138% faster)


def test_gamma_minimum_output():
    # Test that output is never negative
    for x in range(-100, 0):
        codeflash_output = default_gamma(x) # 24.1μs -> 18.8μs (28.3% faster)

# --- Large Scale Test Cases ---

def test_gamma_large_scale_range():
    # Test a range of values from 0 to 999 (inclusive)
    for x in range(0, 1000):
        expected = min(math.ceil(0.1 * x), 25)
        codeflash_output = default_gamma(x) # 215μs -> 150μs (43.0% faster)

def test_gamma_large_scale_negative_range():
    # Test a range of negative values from -1000 to -1 (inclusive)
    for x in range(-1000, 0):
        expected = 0  # All negative inputs should return 0
        codeflash_output = default_gamma(x) # 220μs -> 168μs (30.5% faster)

def test_gamma_large_scale_at_cap():
    # All x >= 250 should return 25
    for x in range(250, 1000):
        codeflash_output = default_gamma(x) # 164μs -> 101μs (61.6% faster)


#------------------------------------------------
import math

# imports
import pytest  # used for our unit tests
from optuna.samplers._tpe.sampler import default_gamma

# unit tests

# --- Basic Test Cases ---

def test_gamma_basic_small_integers():
    # Test for small positive integers
    # 0.1*1 = 0.1 -> ceil = 1, min(1,25) = 1
    codeflash_output = default_gamma(1) # 1.02μs -> 940ns (8.83% faster)
    # 0.1*5 = 0.5 -> ceil = 1, min(1,25) = 1
    codeflash_output = default_gamma(5) # 407ns -> 263ns (54.8% faster)
    # 0.1*10 = 1.0 -> ceil = 1, min(1,25) = 1
    codeflash_output = default_gamma(10) # 230ns -> 181ns (27.1% faster)
    # 0.1*20 = 2.0 -> ceil = 2, min(2,25) = 2
    codeflash_output = default_gamma(20) # 224ns -> 170ns (31.8% faster)
    # 0.1*25 = 2.5 -> ceil = 3, min(3,25) = 3
    codeflash_output = default_gamma(25) # 226ns -> 178ns (27.0% faster)
    # 0.1*50 = 5.0 -> ceil = 5, min(5,25) = 5
    codeflash_output = default_gamma(50) # 219ns -> 167ns (31.1% faster)

def test_gamma_basic_exact_cutoff():
    # Test where gamma hits the cap of 25 exactly
    # 0.1*250 = 25.0 -> ceil = 25, min(25,25) = 25
    codeflash_output = default_gamma(250) # 757ns -> 493ns (53.5% faster)

def test_gamma_basic_above_cutoff():
    # Test where gamma would be above the cap
    # 0.1*260 = 26.0 -> ceil = 26, min(26,25) = 25
    codeflash_output = default_gamma(260) # 794ns -> 477ns (66.5% faster)
    # 0.1*1000 = 100.0 -> ceil = 100, min(100,25) = 25
    codeflash_output = default_gamma(1000) # 383ns -> 207ns (85.0% faster)

# --- Edge Test Cases ---

def test_gamma_zero_and_negative():
    # x = 0: 0.1*0 = 0, ceil(0) = 0, min(0,25) = 0
    codeflash_output = default_gamma(0) # 769ns -> 742ns (3.64% faster)
    # x = -1: 0.1*-1 = -0.1, ceil(-0.1) = 0, min(0,25) = 0
    codeflash_output = default_gamma(-1) # 390ns -> 310ns (25.8% faster)
    # x = -10: 0.1*-10 = -1.0, ceil(-1.0) = -1, min(-1,25) = -1
    codeflash_output = default_gamma(-10) # 324ns -> 288ns (12.5% faster)
    # x = -100: 0.1*-100 = -10.0, ceil(-10.0) = -10, min(-10,25) = -10
    codeflash_output = default_gamma(-100) # 281ns -> 230ns (22.2% faster)

def test_gamma_near_thresholds():
    # Just below the cap
    # x = 249: 0.1*249 = 24.9, ceil = 25, min(25,25) = 25
    codeflash_output = default_gamma(249) # 715ns -> 661ns (8.17% faster)
    # Just above the cap
    # x = 251: 0.1*251 = 25.1, ceil = 26, min(26,25) = 25
    codeflash_output = default_gamma(251) # 418ns -> 260ns (60.8% faster)

def test_gamma_non_integer_result():
    # x = 13: 0.1*13 = 1.3, ceil = 2, min(2,25) = 2
    codeflash_output = default_gamma(13) # 657ns -> 592ns (11.0% faster)
    # x = 19: 0.1*19 = 1.9, ceil = 2, min(2,25) = 2
    codeflash_output = default_gamma(19) # 335ns -> 246ns (36.2% faster)
    # x = 24: 0.1*24 = 2.4, ceil = 3, min(3,25) = 3
    codeflash_output = default_gamma(24) # 225ns -> 174ns (29.3% faster)

def test_gamma_type_behavior():
    # Check that output is always int
    for x in [0, 1, 10, 100, 250, 1000, -10, -100]:
        codeflash_output = default_gamma(x); result = codeflash_output # 2.68μs -> 2.13μs (26.0% faster)

def test_gamma_large_negative():
    # Large negative x: 0.1*-999 = -99.9, ceil = -99, min(-99,25) = -99
    codeflash_output = default_gamma(-999) # 700ns -> 659ns (6.22% faster)

# --- Large Scale Test Cases ---

def test_gamma_large_scale_increasing():
    # Test a range of values from 0 to 999
    for x in range(0, 1000):
        expected = min(math.ceil(0.1 * x), 25)
        codeflash_output = default_gamma(x) # 218μs -> 147μs (47.8% faster)

def test_gamma_large_scale_negative():
    # Test a range of negative values from -1000 to -1
    for x in range(-1000, 0):
        expected = min(math.ceil(0.1 * x), 25)
        codeflash_output = default_gamma(x) # 218μs -> 172μs (26.6% faster)

def test_gamma_large_scale_type_and_bounds():
    # Test type and bounds for large positive values
    for x in [250, 500, 999]:
        codeflash_output = default_gamma(x); result = codeflash_output # 1.61μs -> 994ns (62.3% faster)

def test_gamma_performance_large_input():
    # Test performance for upper-bound input
    # Should not raise or hang for large x
    codeflash_output = default_gamma(999); result = codeflash_output # 720ns -> 413ns (74.3% faster)

def test_gamma_performance_large_negative_input():
    # Test performance for large negative input
    codeflash_output = default_gamma(-999); result = codeflash_output # 740ns -> 811ns (8.75% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from optuna.samplers._tpe.sampler import default_gamma

def test_default_gamma():
    default_gamma(0)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_kivftje7/tmpxds47w_4/test_concolic_coverage.py::test_default_gamma	1.33μs	1.32μs	0.531%✅

To edit these changes git checkout codeflash/optimize-default_gamma-mhjmic7g and push.