⚡️ Speed up function histogram_equalization by 23,027%

[codeflash-ai]

📄 23,027% (230.27x) speedup for histogram_equalization in src/numpy_pandas/signal_processing.py

⏱️ Runtime : 3.25 seconds → 14.1 milliseconds (best of 384 runs)

📝 Explanation and details

The optimized code achieves a 23,027% speedup by replacing nested Python loops with vectorized NumPy operations, which is the core optimization principle here.

Key Optimizations Applied:

1. Histogram computation: Replaced nested loops with np.bincount(image.ravel(), minlength=256)

   • Original: Double nested loop iterating over every pixel position O(height × width) with Python overhead
   • Optimized: Single vectorized operation that counts all pixel values at once using optimized C code

2. CDF calculation: Used histogram.cumsum() / image.size instead of iterative accumulation

   • Original: 255 iterations with manual cumulative sum calculation
   • Optimized: Single vectorized cumulative sum operation

3. Image mapping: Applied vectorized indexing cdf[image] instead of pixel-by-pixel assignment

   • Original: Another double nested loop accessing each pixel individually
   • Optimized: NumPy's advanced indexing maps all pixels simultaneously

Why This Creates Such Dramatic Speedup:

The line profiler shows the bottlenecks were the nested loops (77.7% and 10.4% of runtime). These loops had 3.45 million iterations each, causing:

• Python interpreter overhead for each iteration
• Individual memory access patterns instead of bulk operations
• No opportunity for CPU vectorization or cache optimization

The vectorized approach leverages:

• NumPy's optimized C implementations that process arrays in bulk
• CPU SIMD instructions for parallel computation
• Better memory locality and cache efficiency
• Elimination of Python loop overhead

Performance Across Test Cases:

The optimization is particularly effective for:

• Large images (20,000%+ speedup): More pixels = more loop iterations eliminated
• All image types: Uniform performance gain regardless of content (uniform, random, checkerboard patterns all see similar improvements)
• Small images (400-900% speedup): Even minimal cases benefit from eliminating Python loop overhead

The consistent speedup across all test cases demonstrates that the optimization fundamentally changes the algorithmic complexity from Python-loop-bound to vectorized-operation-bound execution.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import numpy as np
# imports
import pytest  # used for our unit tests
from src.numpy_pandas.signal_processing import histogram_equalization

# unit tests

# 1. BASIC TEST CASES

def test_uniform_image():
    # All pixels are the same value; output should be all zeros (since CDF is flat)
    img = np.full((4, 4), 128, dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 53.1μs -> 6.25μs (750% faster)

def test_two_level_image():
    # Image with two levels, half 0 and half 255
    img = np.array([[0, 0, 255, 255],
                    [0, 0, 255, 255],
                    [0, 0, 255, 255],
                    [0, 0, 255, 255]], dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 53.0μs -> 6.25μs (747% faster)

def test_linear_ramp():
    # Image with values from 0 to 15
    img = np.arange(16, dtype=np.uint8).reshape((4,4))
    codeflash_output = histogram_equalization(img); result = codeflash_output # 52.5μs -> 6.25μs (741% faster)
    # Each value should be spread out over 0-255
    expected = np.round(np.linspace(255/15*0, 255, 16)).astype(np.uint8).reshape((4,4))

def test_small_random_image():
    # Small random image, check that output is still in 0-255 and shape is preserved
    rng = np.random.default_rng(42)
    img = rng.integers(0, 256, size=(3,3), dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 46.1μs -> 6.08μs (658% faster)

# 2. EDGE TEST CASES


def test_single_pixel():
    # Edge: 1x1 image
    img = np.array([[42]], dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 39.8μs -> 7.00μs (469% faster)

def test_max_value_image():
    # Edge: All pixels at 255
    img = np.full((5, 5), 255, dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 62.3μs -> 6.46μs (865% faster)

def test_min_value_image():
    # Edge: All pixels at 0
    img = np.zeros((5, 5), dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 62.4μs -> 6.38μs (878% faster)

def test_high_dynamic_range():
    # Edge: Image with only min and max values
    img = np.array([[0, 255], [255, 0]], dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 40.7μs -> 6.21μs (556% faster)

def test_non_square_image():
    # Edge: Non-square image
    img = np.tile(np.arange(8, dtype=np.uint8), (2,1))
    codeflash_output = histogram_equalization(img); result = codeflash_output # 52.7μs -> 6.12μs (761% faster)

def test_image_with_missing_levels():
    # Edge: Image missing some intensity levels
    img = np.array([[0, 0, 4, 4], [0, 0, 4, 4]], dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 44.6μs -> 6.21μs (619% faster)

def test_non_uint8_image():
    # Edge: Input is int32, should still work and output same shape/dtype as input
    img = np.arange(9, dtype=np.int32).reshape((3,3))
    codeflash_output = histogram_equalization(img); result = codeflash_output # 46.0μs -> 6.29μs (632% faster)

# 3. LARGE SCALE TEST CASES

def test_large_uniform_image():
    # Large image with uniform value
    img = np.full((1000, 1000), 100, dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 950ms -> 4.63ms (20425% faster)

def test_large_random_image():
    # Large random image, values should be spread over 0-255
    rng = np.random.default_rng(123)
    img = rng.integers(0, 256, size=(1000, 1000), dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 939ms -> 3.40ms (27554% faster)

def test_large_low_dynamic_range():
    # Large image, but only uses a small range of values
    img = np.random.randint(100, 110, size=(500, 900), dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 423ms -> 1.62ms (26101% faster)

def test_large_checkerboard():
    # Large checkerboard pattern: half zeros, half 255s
    img = np.indices((1000,1000)).sum(axis=0) % 2 * 255
    img = img.astype(np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 936ms -> 4.33ms (21509% faster)

# Additional: mutation-detecting test
def test_mutation_detection():
    # If function is mutated to skip histogram or CDF, output will not match
    img = np.array([[0, 1], [2, 3]], dtype=np.uint8)
    codeflash_output = histogram_equalization(img); result = codeflash_output # 43.6μs -> 6.83μs (538% faster)
# 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
# imports
import pytest  # used for our unit tests
from src.numpy_pandas.signal_processing import histogram_equalization

# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.


from src.numpy_pandas.signal_processing import histogram_equalization

To edit these changes git checkout codeflash/optimize-histogram_equalization-mdpho5lf and push.