⚡️ Speed up function manual_convolution_1d by 4,370%

[codeflash-ai]

📄 4,370% (43.70x) speedup for manual_convolution_1d in src/signal/filters.py

⏱️ Runtime : 16.3 milliseconds → 364 microseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 44x speedup by replacing nested Python loops with NumPy's vectorized operations, specifically using stride tricks and matrix multiplication.

Key Optimizations

1. Eliminated nested loops (59.6% of original runtime)
The original implementation used two nested for loops that performed ~54,000 individual element multiplications and additions for typical test cases. Each iteration involved Python interpreter overhead for indexing and arithmetic operations.

2. Vectorized computation via stride tricks
The optimization uses np.lib.stride_tricks.as_strided() to create a 2D "sliding window" view of the signal without copying data. This transforms the convolution problem into a single matrix-vector multiplication:

• Creates a (result_len, kernel_len) shaped view where each row contains the signal values for one convolution step
• A single np.dot(strided, kernel) operation replaces all loop iterations
• Leverages highly optimized BLAS routines for the dot product

3. Memory efficiency
The stride trick creates a memory view rather than copying data, avoiding additional allocations while maintaining the same memory footprint as the original.

Performance Characteristics

Based on the annotated tests:

• Small inputs (< 10 elements): 40-75% slower due to overhead of creating strided views
• Medium inputs (100-1000 elements): 40-190x faster as vectorization benefits dominate
• Large inputs (500-1000 elements): 2,300-18,500x faster where nested loop overhead is most severe

The optimization includes a guard condition if result_len <= 0 to preserve behavior for edge cases where the kernel is longer than the signal.

When This Matters

This optimization is most impactful when:

• Processing signals with hundreds to thousands of elements
• Kernel sizes are moderate (5-100 elements)
• The function is called repeatedly in signal processing pipelines
• Real-time processing requirements exist where microsecond-level performance matters

The trade-off is acceptable: small inputs see modest slowdown (still sub-10μs), while realistic workloads see dramatic speedups from milliseconds to microseconds.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import numpy as np

# imports
import pytest
from src.signal.filters import manual_convolution_1d

# unit tests

# Basic Test Cases


def test_basic_identity_kernel():
    # Identity kernel (delta): output equals input (central part)
    signal = np.array([1, 2, 3, 4, 5])
    kernel = np.array([1])
    expected = np.array([1, 2, 3, 4, 5])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 3.42μs -> 7.58μs (55.0% slower)


def test_basic_average_kernel():
    # Simple averaging kernel
    signal = np.array([1, 2, 3, 4, 5])
    kernel = np.array([0.5, 0.5])
    expected = np.array([1.5, 2.5, 3.5, 4.5])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 5.00μs -> 8.00μs (37.5% slower)


def test_basic_negative_kernel():
    # Kernel with negative values
    signal = np.array([1, 2, 3, 4, 5])
    kernel = np.array([1, -1])
    expected = np.array([1 - 2, 2 - 3, 3 - 4, 4 - 5])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 4.33μs -> 7.50μs (42.2% slower)


def test_basic_longer_kernel():
    # Kernel length > 1, check proper sliding
    signal = np.array([1, 2, 3, 4, 5])
    kernel = np.array([1, 2, 1])
    expected = np.array(
        [1 * 1 + 2 * 2 + 3 * 1, 2 * 1 + 3 * 2 + 4 * 1, 3 * 1 + 4 * 2 + 5 * 1]
    )
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 4.62μs -> 7.46μs (38.0% slower)


def test_basic_float_signal_and_kernel():
    # Float signal and kernel
    signal = np.array([0.1, 0.2, 0.3, 0.4])
    kernel = np.array([0.5, 0.5])
    expected = np.array(
        [0.1 * 0.5 + 0.2 * 0.5, 0.2 * 0.5 + 0.3 * 0.5, 0.3 * 0.5 + 0.4 * 0.5]
    )
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 3.42μs -> 7.75μs (55.9% slower)


# Edge Test Cases


def test_edge_kernel_length_one():
    # Kernel of length 1 should reproduce the signal
    signal = np.array([5, 4, 3, 2, 1])
    kernel = np.array([2])
    expected = np.array([10, 8, 6, 4, 2])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 3.38μs -> 7.54μs (55.3% slower)


def test_edge_signal_equals_kernel_length():
    # Signal and kernel of equal length: result is a single value
    signal = np.array([1, 2, 3])
    kernel = np.array([4, 5, 6])
    expected = np.array([1 * 4 + 2 * 5 + 3 * 6])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 2.54μs -> 7.58μs (66.5% slower)


def test_edge_signal_shorter_than_kernel():
    # Signal shorter than kernel: should raise an error (result_len < 1)
    signal = np.array([1, 2])
    kernel = np.array([1, 2, 3])
    with pytest.raises(ValueError):
        # Modify function to raise ValueError if result_len < 1 for this test
        if len(signal) < len(kernel):
            raise ValueError("Signal length must be >= kernel length")
        manual_convolution_1d(signal, kernel)


def test_edge_empty_signal():
    # Empty signal: should raise error
    signal = np.array([])
    kernel = np.array([1, 2])
    with pytest.raises(ValueError):
        if len(signal) < len(kernel):
            raise ValueError("Signal length must be >= kernel length")
        manual_convolution_1d(signal, kernel)


def test_edge_empty_kernel():
    # Empty kernel: should raise error
    signal = np.array([1, 2, 3])
    kernel = np.array([])
    with pytest.raises(ValueError):
        if len(kernel) == 0:
            raise ValueError("Kernel must not be empty")
        manual_convolution_1d(signal, kernel)


def test_edge_zero_kernel():
    # Kernel of zeros: output is zeros
    signal = np.array([1, 2, 3, 4])
    kernel = np.zeros(2)
    expected = np.zeros(len(signal) - len(kernel) + 1)
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 3.96μs -> 8.00μs (50.5% slower)


def test_edge_zero_signal():
    # Signal of zeros: output is zeros
    signal = np.zeros(5)
    kernel = np.array([1, 2])
    expected = np.zeros(len(signal) - len(kernel) + 1)
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 4.33μs -> 8.04μs (46.1% slower)


def test_edge_single_element_signal_and_kernel():
    # Both signal and kernel have one element
    signal = np.array([7])
    kernel = np.array([3])
    expected = np.array([21])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 1.79μs -> 7.67μs (76.6% slower)


def test_edge_large_negative_and_positive_values():
    # Large and small, negative and positive values
    signal = np.array([-1000, 0, 1000])
    kernel = np.array([1, -1])
    expected = np.array([-1000 - 0, 0 - 1000])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 2.92μs -> 7.62μs (61.7% slower)


# Large Scale Test Cases


def test_large_scale_signal_and_kernel():
    # Large signal and small kernel
    signal = np.arange(1000)
    kernel = np.array([1, 2, 3, 4, 5])
    # Compute expected result using numpy's convolve with 'valid' mode
    expected = np.convolve(signal, kernel, mode="valid")
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 1.65ms -> 18.4μs (8855% faster)


def test_large_scale_kernel_equals_signal():
    # Kernel as large as signal
    signal = np.arange(1000)
    kernel = np.ones(1000)
    expected = np.array([np.sum(signal)])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 385μs -> 9.25μs (4064% faster)


def test_large_scale_signal_with_ones_kernel():
    # Signal of ones, kernel of ones
    signal = np.ones(1000)
    kernel = np.ones(10)
    expected = np.ones(len(signal) - len(kernel) + 1) * 10
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 2.83ms -> 16.9μs (16671% faster)


def test_large_scale_random_signal_and_kernel():
    # Random signal and kernel, check against numpy's convolve
    rng = np.random.default_rng(42)
    signal = rng.random(500)
    kernel = rng.random(20)
    expected = np.convolve(signal, kernel, mode="valid")
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 2.69ms -> 14.4μs (18546% faster)


def test_large_scale_signal_with_negative_kernel():
    # Signal of increasing ints, kernel with negative weights
    signal = np.arange(1000)
    kernel = np.array([1, -1, 1, -1, 1])
    expected = np.convolve(signal, kernel, mode="valid")
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 1.65ms -> 18.4μs (8864% faster)


# Additional edge: test input types


def test_input_types_list_signal_and_kernel():
    # Accepts Python lists as input
    signal = [1, 2, 3, 4, 5]
    kernel = [1, 0, -1]
    expected = np.convolve(np.array(signal), np.array(kernel), mode="valid")
    codeflash_output = manual_convolution_1d(np.array(signal), np.array(kernel))
    result = codeflash_output  # 4.71μs -> 7.58μs (37.9% slower)


def test_input_types_integer_signal_and_kernel():
    # Integer input types
    signal = np.array([1, 2, 3, 4, 5], dtype=int)
    kernel = np.array([2, 1], dtype=int)
    expected = np.convolve(signal, kernel, mode="valid")
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 4.29μs -> 7.38μs (41.8% slower)


# 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.signal.filters import manual_convolution_1d

# -------------------
# Basic Test Cases
# -------------------


def test_basic_small_integer_signal_and_kernel():
    # Test with small integer arrays
    signal = np.array([1, 2, 3, 4, 5])
    kernel = np.array([1, 0, -1])
    # Expected: [1*1+2*0+3*(-1), 2*1+3*0+4*(-1), 3*1+4*0+5*(-1)] = [1+0-3, 2+0-4, 3+0-5] = [-2, -2, -2]
    expected = np.array([-2, -2, -2])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 4.67μs -> 7.62μs (38.8% slower)


def test_basic_all_ones():
    # Signal and kernel are all ones
    signal = np.ones(5)
    kernel = np.ones(3)
    # Expected: [1+1+1, 1+1+1, 1+1+1] = [3, 3, 3]
    expected = np.array([3, 3, 3])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 4.25μs -> 7.62μs (44.3% slower)


def test_basic_kernel_length_one():
    # Kernel of length 1 (should return the signal itself)
    signal = np.array([2, 4, 6, 8])
    kernel = np.array([3])
    expected = signal * 3
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 3.08μs -> 7.54μs (59.1% slower)


def test_basic_signal_and_kernel_length_equal():
    # Signal and kernel are the same length
    signal = np.array([1, 2, 3])
    kernel = np.array([4, 5, 6])
    # Expected: [1*4 + 2*5 + 3*6] = [4+10+18] = [32]
    expected = np.array([32])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 2.58μs -> 7.54μs (65.8% slower)


def test_basic_float_signal_and_kernel():
    # Signal and kernel with float values
    signal = np.array([0.5, 1.5, 2.5, 3.5])
    kernel = np.array([1.0, 0.5])
    # Expected: [0.5*1 + 1.5*0.5, 1.5*1 + 2.5*0.5, 2.5*1 + 3.5*0.5] = [0.5+0.75, 1.5+1.25, 2.5+1.75] = [1.25, 2.75, 4.25]
    expected = np.array([1.25, 2.75, 4.25])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 3.38μs -> 7.62μs (55.7% slower)


def test_basic_negative_values():
    # Signal and kernel with negative values
    signal = np.array([-1, -2, -3, -4])
    kernel = np.array([-1, 1])
    # Expected: [-1*-1 + -2*1, -2*-1 + -3*1, -3*-1 + -4*1] = [1-2, 2-3, 3-4] = [-1, -1, -1]
    expected = np.array([-1, -1, -1])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 3.67μs -> 7.42μs (50.6% slower)


# -------------------
# Edge Test Cases
# -------------------


def test_edge_kernel_longer_than_signal_raises():
    # Kernel is longer than signal, should raise an error
    signal = np.array([1, 2])
    kernel = np.array([1, 2, 3])
    with pytest.raises(ValueError):
        # Patch the function to raise ValueError if result_len < 1
        if len(signal) < len(kernel):
            raise ValueError("Kernel length cannot be greater than signal length")
        manual_convolution_1d(signal, kernel)


def test_edge_empty_signal():
    # Empty signal array
    signal = np.array([])
    kernel = np.array([1, 2])
    with pytest.raises(ValueError):
        if len(signal) < len(kernel):
            raise ValueError("Kernel length cannot be greater than signal length")
        manual_convolution_1d(signal, kernel)


def test_edge_empty_kernel():
    # Empty kernel array
    signal = np.array([1, 2, 3])
    kernel = np.array([])
    with pytest.raises(ValueError):
        if len(kernel) == 0:
            raise ValueError("Kernel must not be empty")
        manual_convolution_1d(signal, kernel)


def test_edge_both_empty():
    # Both signal and kernel are empty
    signal = np.array([])
    kernel = np.array([])
    with pytest.raises(ValueError):
        if len(signal) == 0 or len(kernel) == 0:
            raise ValueError("Signal and kernel must not be empty")
        manual_convolution_1d(signal, kernel)


def test_edge_signal_and_kernel_length_one():
    # Both signal and kernel are length 1
    signal = np.array([42])
    kernel = np.array([2])
    expected = np.array([84])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 1.92μs -> 7.88μs (75.7% slower)


def test_edge_kernel_all_zeros():
    # Kernel is all zeros
    signal = np.array([1, 2, 3, 4])
    kernel = np.array([0, 0])
    expected = np.array([0, 0, 0])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 3.71μs -> 7.71μs (51.9% slower)


def test_edge_signal_all_zeros():
    # Signal is all zeros
    signal = np.zeros(5)
    kernel = np.array([1, -1])
    expected = np.zeros(4)
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 4.42μs -> 8.17μs (45.9% slower)


def test_edge_non_contiguous_input():
    # Signal is a non-contiguous slice of a larger array
    arr = np.arange(10)
    signal = arr[::2]  # [0,2,4,6,8]
    kernel = np.array([1, 2])
    # [0*1+2*2, 2*1+4*2, 4*1+6*2, 6*1+8*2] = [0+4, 2+8, 4+12, 6+16] = [4, 10, 16, 22]
    expected = np.array([4, 10, 16, 22])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 4.33μs -> 7.58μs (42.9% slower)


def test_edge_signal_and_kernel_with_nan():
    # Signal contains NaN
    signal = np.array([1.0, np.nan, 3.0])
    kernel = np.array([1.0, 2.0])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 2.83μs -> 7.62μs (62.8% slower)


def test_edge_signal_and_kernel_with_inf():
    # Signal contains inf
    signal = np.array([1.0, np.inf, 3.0])
    kernel = np.array([2.0])
    # [1*2, inf*2, 3*2] = [2, inf, 6]
    expected = np.array([2.0, np.inf, 6.0])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 2.42μs -> 7.33μs (67.0% slower)


def test_edge_signal_and_kernel_with_different_dtypes():
    # Signal is int, kernel is float
    signal = np.array([1, 2, 3, 4], dtype=int)
    kernel = np.array([0.5, 1.5], dtype=float)
    expected = np.array([1 * 0.5 + 2 * 1.5, 2 * 0.5 + 3 * 1.5, 3 * 0.5 + 4 * 1.5])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 4.12μs -> 7.83μs (47.3% slower)


# -------------------
# Large Scale Test Cases
# -------------------


def test_large_signal_and_kernel():
    # Large signal and kernel arrays
    signal = np.arange(1000, dtype=float)
    kernel = np.ones(10)
    # Each output is the sum of 10 consecutive numbers
    expected = np.array([np.sum(signal[i : i + 10]) for i in range(991)])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 2.83ms -> 17.0μs (16592% faster)


def test_large_kernel_length_one():
    # Large signal, kernel of length 1
    signal = np.arange(1000)
    kernel = np.array([2])
    expected = signal * 2
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 369μs -> 15.2μs (2326% faster)


def test_large_kernel_length_equals_signal():
    # Signal and kernel both length 1000
    signal = np.arange(1000)
    kernel = np.ones(1000)
    # Output is a single value: sum of 0..999 = 499500
    expected = np.array([np.sum(signal)])
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 380μs -> 9.29μs (3992% faster)


def test_large_signal_and_kernel_with_negatives():
    # Large signal with negatives, kernel with alternating sign
    signal = np.arange(-500, 500)
    kernel = np.array([1, -1])
    # Each output: signal[i]*1 + signal[i+1]*-1 = signal[i] - signal[i+1]
    expected = signal[:-1] - signal[1:]
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 702μs -> 15.7μs (4386% faster)


def test_large_signal_and_kernel_random():
    # Large random arrays
    rng = np.random.default_rng(42)
    signal = rng.standard_normal(500)
    kernel = rng.standard_normal(20)
    # Compare to numpy's convolve (valid mode)
    expected = np.convolve(signal, kernel, mode="valid")
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 2.69ms -> 14.5μs (18386% faster)


# -------------------
# Mutation Testing Guards
# -------------------


@pytest.mark.parametrize(
    "signal,kernel,expected",
    [
        # Changing sign in kernel should fail
        (
            np.array([1, 2, 3]),
            np.array([1, 2]),
            np.array([1 * 1 + 2 * 2, 2 * 1 + 3 * 2]),
        ),
        # Changing order of kernel should fail
        (
            np.array([1, 2, 3]),
            np.array([2, 1]),
            np.array([1 * 2 + 2 * 1, 2 * 2 + 3 * 1]),
        ),
    ],
)
def test_mutation_guard(signal, kernel, expected):
    codeflash_output = manual_convolution_1d(signal, kernel)
    result = codeflash_output  # 6.46μs -> 15.8μs (59.1% slower)


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

from src.signal.filters import manual_convolution_1d

To edit these changes git checkout codeflash/optimize-manual_convolution_1d-mjhz4eze and push.