⚡️ Speed up function FFT by 102%

[codeflash-ai]

📄 102% (1.02x) speedup for FFT in src/numpy_pandas/signal_processing.py

⏱️ Runtime : 18.2 milliseconds → 9.04 milliseconds (best of 311 runs)

📝 Explanation and details

The optimized code implements an iterative FFT algorithm that replaces the recursive Cooley-Tukey approach with a more cache-efficient, bottom-up computation strategy.

Key optimizations:

1. Eliminated recursion overhead: The original recursive implementation created deep call stacks and repeatedly sliced arrays (x[0::2], x[1::2]), causing significant memory allocation and copying. The optimized version uses an iterative approach that processes the FFT in-place.

2. Bit-reversal preprocessing: Instead of recursively splitting arrays, the optimized version pre-computes the bit-reversed indices using efficient bitwise operations. This eliminates the need for array slicing entirely and arranges input data in the correct order for the iterative algorithm.

3. Reduced twiddle factor computation: The original code computed np.exp(-2j * np.pi * np.arange(n) / n) for every recursive call. The optimized version computes twiddle factors only once (np.exp(-2j * np.pi * np.arange(n // 2) / n)) and reuses them throughout the iterative process.

4. In-place butterfly operations: The iterative algorithm performs FFT butterfly operations directly on the result array, avoiding temporary array allocations that occurred in the recursive approach.

Performance characteristics by input size:

• Small arrays (n≤8): The optimization overhead makes it slightly slower due to bit-reversal setup costs
• Large power-of-2 arrays (n=1024): Achieves ~155% speedup due to eliminated recursion and reduced memory operations
• Non-power-of-2 arrays: Falls back to the original recursive implementation to maintain correctness

The optimization is most effective for large power-of-2 inputs where the recursive overhead and memory allocation costs dominate the computation time.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 19 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 FFT

# unit tests

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

def test_fft_single_element():
    # Test FFT of a single element array
    x = np.array([1], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 166ns -> 166ns (0.000% faster)

def test_fft_two_elements():
    # Test FFT of two elements
    x = np.array([1, -1], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 3.83μs -> 15.0μs (74.4% slower)
    # FFT([a, b]) = [a+b, a-b]
    expected = np.array([0, 2], dtype=complex)

def test_fft_four_elements_real():
    # Test FFT of four real numbers
    x = np.array([1, 2, 3, 4], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 8.88μs -> 16.0μs (44.4% slower)
    expected = np.fft.fft(x)

def test_fft_four_elements_complex():
    # Test FFT of four complex numbers
    x = np.array([1+1j, 2-1j, 3+2j, 4-2j], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 8.79μs -> 16.0μs (45.1% slower)
    expected = np.fft.fft(x)

def test_fft_eight_elements():
    # Test FFT of eight elements
    x = np.arange(8, dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 19.0μs -> 18.3μs (3.87% faster)
    expected = np.fft.fft(x)

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



def test_fft_all_zeros():
    # FFT of all zeros should be all zeros
    x = np.zeros(8, dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 20.1μs -> 19.4μs (3.65% faster)
    expected = np.zeros(8, dtype=complex)

def test_fft_all_same_value():
    # FFT of all same value: Only DC component is nonzero
    x = np.full(8, 5, dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 19.2μs -> 18.5μs (3.84% faster)
    # Only first element should be 8*5, rest zero
    expected = np.zeros(8, dtype=complex)
    expected[0] = 8*5

def test_fft_alternating_signs():
    # FFT of alternating +1/-1 values
    x = np.array([1, -1, 1, -1, 1, -1, 1, -1], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 19.0μs -> 18.3μs (3.63% faster)
    expected = np.fft.fft(x)

def test_fft_large_values():
    # FFT of array with large values
    x = np.array([1e10, -1e10, 1e10, -1e10, 1e10, -1e10, 1e10, -1e10], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 19.0μs -> 18.3μs (3.86% faster)
    expected = np.fft.fft(x)

def test_fft_small_values():
    # FFT of array with very small values
    x = np.array([1e-10, -1e-10, 1e-10, -1e-10, 1e-10, -1e-10, 1e-10, -1e-10], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 19.0μs -> 18.2μs (3.88% faster)
    expected = np.fft.fft(x)

def test_fft_imaginary_only():
    # FFT of array with only imaginary values
    x = np.array([1j, 2j, 3j, 4j], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 8.67μs -> 16.1μs (46.3% slower)
    expected = np.fft.fft(x)

def test_fft_real_only():
    # FFT of array with only real values
    x = np.array([1, 2, 3, 4], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 8.62μs -> 15.8μs (45.2% slower)
    expected = np.fft.fft(x)

def test_fft_negative_values():
    # FFT of array with negative values
    x = np.array([-1, -2, -3, -4], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 8.67μs -> 15.8μs (45.3% slower)
    expected = np.fft.fft(x)

def test_fft_mixed_types():
    # FFT of array with mixed int and float types
    x = np.array([1, 2.0, 3, 4.0], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 8.71μs -> 16.0μs (45.4% slower)
    expected = np.fft.fft(x)

# ----------- LARGE SCALE TEST CASES -----------

def test_fft_large_power_of_two():
    # FFT of a large array (length 1024)
    x = np.random.rand(1024) + 1j * np.random.rand(1024)
    x = x.astype(complex)
    codeflash_output = FFT(x); result = codeflash_output # 3.63ms -> 1.42ms (155% faster)
    expected = np.fft.fft(x)

def test_fft_large_real():
    # FFT of a large real array
    x = np.random.rand(1024)
    x = x.astype(complex)
    codeflash_output = FFT(x); result = codeflash_output # 3.64ms -> 1.41ms (157% faster)
    expected = np.fft.fft(x)

def test_fft_large_integer():
    # FFT of a large integer array
    x = np.arange(1024, dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 3.64ms -> 1.42ms (156% faster)
    expected = np.fft.fft(x)

def test_fft_large_zeros():
    # FFT of a large zeros array
    x = np.zeros(1024, dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 3.64ms -> 1.42ms (157% faster)
    expected = np.zeros(1024, dtype=complex)

def test_fft_large_alternating():
    # FFT of large alternating sign array
    x = np.array([1 if i % 2 == 0 else -1 for i in range(1000)], dtype=complex)
    codeflash_output = FFT(x); result = codeflash_output # 3.52ms -> 3.15ms (11.9% faster)
    expected = np.fft.fft(x)
# 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 FFT

To edit these changes git checkout codeflash/optimize-FFT-mfelmm2r and push.