⚡️ Speed up function sigmoid_stable by 208%

[codeflash-ai]

📄 208% (2.08x) speedup for sigmoid_stable in codeflash/process/infer.py

⏱️ Runtime : 1.79 milliseconds → 581 microseconds (best of 384 runs)

📝 Explanation and details

Here is an optimized version of your program. The original code inadvertently computes np.exp(x) twice when x < 0, incurring redundant computation. By computing it once and caching the result, you eliminate the duplicate work. This reduces runtime, especially on large arrays.

This form reduces repeated computation and will run faster, especially for large NumPy arrays.
All comments are preserved unless their code portion changed.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import numpy as np  # used for numerical operations
# imports
import pytest  # used for our unit tests
from codeflash.process.infer import sigmoid_stable

# unit tests

# --- Basic Test Cases ---

def test_sigmoid_zero():
    # Sigmoid(0) should be exactly 0.5
    codeflash_output = sigmoid_stable(0.0)

def test_sigmoid_positive_scalar():
    # Test a positive scalar input
    val = 2.0
    expected = 1 / (1 + np.exp(-val))

def test_sigmoid_negative_scalar():
    # Test a negative scalar input
    val = -2.0
    expected = 1 / (1 + np.exp(-val))

def test_sigmoid_array_basic():
    # Test a small array of mixed values
    arr = np.array([-1, 0, 1])
    expected = 1 / (1 + np.exp(-arr))
    codeflash_output = sigmoid_stable(arr)


def test_sigmoid_large_positive():
    # For very large positive x, sigmoid(x) should approach 1
    large_pos = 1000
    codeflash_output = sigmoid_stable(large_pos); result = codeflash_output

def test_sigmoid_large_negative():
    # For very large negative x, sigmoid(x) should approach 0
    large_neg = -1000
    codeflash_output = sigmoid_stable(large_neg); result = codeflash_output

def test_sigmoid_inf():
    # Test positive and negative infinity
    codeflash_output = sigmoid_stable(np.inf)
    codeflash_output = sigmoid_stable(-np.inf)

def test_sigmoid_nan():
    # Test NaN input, output should be NaN
    codeflash_output = sigmoid_stable(np.nan); result = codeflash_output

def test_sigmoid_array_extremes():
    # Test array with extreme values and zeros
    arr = np.array([-1000, -100, 0, 100, 1000])
    expected = np.array([0.0, 3.72007598e-44, 0.5, 1.0, 1.0])
    codeflash_output = sigmoid_stable(arr)

def test_sigmoid_dtype_preservation():
    # Test dtype preservation for float32 and float64
    arr32 = np.array([0, 1, -1], dtype=np.float32)
    codeflash_output = sigmoid_stable(arr32); out32 = codeflash_output
    arr64 = np.array([0, 1, -1], dtype=np.float64)
    codeflash_output = sigmoid_stable(arr64); out64 = codeflash_output

def test_sigmoid_empty_array():
    # Test with empty array input
    arr = np.array([])
    codeflash_output = sigmoid_stable(arr); result = codeflash_output

# --- Large Scale Test Cases ---

def test_sigmoid_large_array():
    # Test with a large array of 1000 elements spanning a wide range
    arr = np.linspace(-1000, 1000, 1000)
    codeflash_output = sigmoid_stable(arr); result = codeflash_output

def test_sigmoid_large_random_array():
    # Test with a large random array
    rng = np.random.default_rng(42)
    arr = rng.normal(size=1000)
    codeflash_output = sigmoid_stable(arr); result = codeflash_output

def test_sigmoid_large_negative_array():
    # Test with a large array of large negative numbers
    arr = np.full(1000, -1000)
    codeflash_output = sigmoid_stable(arr); result = codeflash_output

def test_sigmoid_large_positive_array():
    # Test with a large array of large positive numbers
    arr = np.full(1000, 1000)
    codeflash_output = sigmoid_stable(arr); result = codeflash_output
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import numpy as np  # used for vectorized operations and array handling
# imports
import pytest  # used for our unit tests
from codeflash.process.infer import sigmoid_stable

# unit tests

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

def test_sigmoid_basic_zero():
    # Sigmoid at 0 should be exactly 0.5
    codeflash_output = sigmoid_stable(0); result = codeflash_output

def test_sigmoid_basic_positive():
    # Test for a typical positive value
    codeflash_output = sigmoid_stable(2); result = codeflash_output
    expected = 1 / (1 + np.exp(-2))

def test_sigmoid_basic_negative():
    # Test for a typical negative value
    codeflash_output = sigmoid_stable(-2); result = codeflash_output
    expected = 1 / (1 + np.exp(2))

def test_sigmoid_basic_array():
    # Test for a small array of mixed values
    arr = np.array([-1, 0, 1])
    codeflash_output = sigmoid_stable(arr); result = codeflash_output
    expected = 1 / (1 + np.exp(-arr))

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

def test_sigmoid_large_positive():
    # Test for a very large positive value (should approach 1)
    codeflash_output = sigmoid_stable(1000); result = codeflash_output

def test_sigmoid_large_negative():
    # Test for a very large negative value (should approach 0)
    codeflash_output = sigmoid_stable(-1000); result = codeflash_output

def test_sigmoid_inf():
    # Test for positive and negative infinity
    codeflash_output = sigmoid_stable(np.inf); result_pos_inf = codeflash_output
    codeflash_output = sigmoid_stable(-np.inf); result_neg_inf = codeflash_output

def test_sigmoid_nan():
    # Test for nan input (should return nan)
    codeflash_output = sigmoid_stable(np.nan); result = codeflash_output

def test_sigmoid_extreme_array():
    # Test for array with extreme values
    arr = np.array([-1000, -100, -10, 0, 10, 100, 1000])
    codeflash_output = sigmoid_stable(arr); result = codeflash_output
    expected = np.array([0.0, 3.72007598e-44, 4.53978687e-05, 0.5,
                         0.9999546, 1.0, 1.0])

def test_sigmoid_dtype_preservation():
    # Test that the output dtype is float64 for integer input
    arr = np.array([1, 2, 3], dtype=int)
    codeflash_output = sigmoid_stable(arr); result = codeflash_output

def test_sigmoid_scalar_python_float():
    # Test for plain Python float input
    codeflash_output = sigmoid_stable(1.5); result = codeflash_output
    expected = 1 / (1 + np.exp(-1.5))

def test_sigmoid_scalar_python_int():
    # Test for plain Python int input
    codeflash_output = sigmoid_stable(-3); result = codeflash_output
    expected = 1 / (1 + np.exp(3))

def test_sigmoid_empty_array():
    # Test for empty array input
    arr = np.array([])
    codeflash_output = sigmoid_stable(arr); result = codeflash_output

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

def test_sigmoid_large_array():
    # Test for large array input (performance and correctness)
    arr = np.linspace(-10, 10, 1000)
    codeflash_output = sigmoid_stable(arr); result = codeflash_output
    expected = 1 / (1 + np.exp(-arr))

def test_sigmoid_large_range_extremes():
    # Test for large array with extreme values to check for stability
    arr = np.concatenate([
        np.full(500, -1000),  # all should be ~0
        np.full(500, 1000)    # all should be ~1
    ])
    codeflash_output = sigmoid_stable(arr); result = codeflash_output

def test_sigmoid_large_random_array():
    # Test for large array of random numbers (robustness)
    rng = np.random.default_rng(seed=42)
    arr = rng.normal(loc=0, scale=100, size=999)
    codeflash_output = sigmoid_stable(arr); result = codeflash_output

# -------------------------
# Additional Robustness Cases
# -------------------------


def test_sigmoid_multidimensional_array():
    # Test for 2D array input
    arr = np.array([[-1, 0], [1, 2]])
    codeflash_output = sigmoid_stable(arr); result = codeflash_output
    expected = 1 / (1 + np.exp(-arr))
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup

To edit these changes git checkout codeflash/optimize-sigmoid_stable-mde1oeft and push.