⚡️ Speed up function matrix_sum by 48%

[codeflash-ai]

📄 48% (0.48x) speedup for matrix_sum in src/dsa/various.py

⏱️ Runtime : 8.23 milliseconds → 5.58 milliseconds (best of 50 runs)

📝 Explanation and details

The optimized code eliminates a critical performance bottleneck: redundant sum calculations. In the original list comprehension [sum(matrix[i]) for i in range(len(matrix)) if sum(matrix[i]) > 0], each row's sum is computed twice - once for the condition check and once for the result. The optimized version calculates each sum only once by storing it in variable s.

Additionally, the optimization replaces inefficient indexing (matrix[i]) with direct iteration over rows, which avoids the overhead of index lookups and len() calls.

Key improvements:

1. Single sum calculation per row instead of double calculation
2. Direct row iteration (for row in matrix) vs indexed access (matrix[i])
3. Explicit loop structure that's more cache-friendly than list comprehension for this use case

The performance gains are most pronounced for:

• Large matrices with many positive sums (91-166% speedup in large-scale tests)
• Single large rows (119% speedup for 1000-element row)
• Mixed positive/negative scenarios where the double sum calculation penalty is most visible

Even small matrices benefit (20-57% speedup) due to reduced function call overhead and more efficient memory access patterns.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from src.dsa.various import matrix_sum

# unit tests

# -------------------------------
# 1. BASIC TEST CASES
# -------------------------------

def test_basic_single_row_positive():
    # Single row, all positive numbers
    matrix = [[1, 2, 3]]
    codeflash_output = matrix_sum(matrix) # 833ns -> 583ns (42.9% faster)

def test_basic_single_row_negative():
    # Single row, all negative numbers
    matrix = [[-1, -2, -3]]
    codeflash_output = matrix_sum(matrix) # 708ns -> 542ns (30.6% faster)

def test_basic_single_row_mixed():
    # Single row, mixed positive and negative
    matrix = [[-1, 2, -3, 4]]
    codeflash_output = matrix_sum(matrix) # 875ns -> 584ns (49.8% faster)

def test_basic_multiple_rows_all_positive():
    # Multiple rows, all positive numbers
    matrix = [
        [1, 2],
        [3, 4],
        [5, 6]
    ]
    codeflash_output = matrix_sum(matrix) # 1.04μs -> 750ns (38.9% faster)

def test_basic_multiple_rows_mixed():
    # Multiple rows, some with sum <= 0
    matrix = [
        [1, -1],   # sum = 0
        [2, -1],   # sum = 1
        [-2, -2],  # sum = -4
        [4, 0]     # sum = 4
    ]
    codeflash_output = matrix_sum(matrix) # 1.04μs -> 834ns (24.9% faster)

def test_basic_empty_matrix():
    # Empty matrix
    matrix = []
    codeflash_output = matrix_sum(matrix) # 542ns -> 375ns (44.5% faster)

def test_basic_empty_row():
    # Matrix with one empty row
    matrix = [[]]
    codeflash_output = matrix_sum(matrix) # 667ns -> 541ns (23.3% faster)

def test_basic_multiple_empty_rows():
    # Matrix with several empty rows
    matrix = [[], [], []]
    codeflash_output = matrix_sum(matrix) # 833ns -> 667ns (24.9% faster)

def test_basic_zero_rows():
    # Matrix where all rows sum to zero
    matrix = [
        [1, -1],
        [2, -2],
        [0, 0]
    ]
    codeflash_output = matrix_sum(matrix) # 833ns -> 708ns (17.7% faster)

# -------------------------------
# 2. EDGE TEST CASES
# -------------------------------

def test_edge_row_with_zero_sum():
    # Row with elements summing to exactly zero
    matrix = [
        [1, -1, 0],
        [0, 0, 0],
        [5, -5]
    ]
    codeflash_output = matrix_sum(matrix) # 917ns -> 708ns (29.5% faster)

def test_edge_row_with_large_positive_and_negative():
    # Large positive and negative numbers
    matrix = [
        [10**6, -10**6, 1],  # sum = 1
        [-10**8, 10**8],     # sum = 0
        [10**9, 10**9]       # sum = 2*10^9
    ]
    codeflash_output = matrix_sum(matrix) # 1.38μs -> 1.08μs (27.0% faster)

def test_edge_row_with_single_element():
    # Each row has a single element
    matrix = [
        [0],    # sum = 0
        [5],    # sum = 5
        [-3],   # sum = -3
        [10]    # sum = 10
    ]
    codeflash_output = matrix_sum(matrix) # 1.04μs -> 875ns (19.1% faster)

def test_edge_row_with_all_zeros():
    # All elements are zero
    matrix = [
        [0, 0, 0],
        [0],
        [0, 0]
    ]
    codeflash_output = matrix_sum(matrix) # 875ns -> 708ns (23.6% faster)

def test_edge_row_with_empty_and_nonempty():
    # Mix of empty and nonempty rows
    matrix = [
        [],
        [1, 2, 3],
        [],
        [-1, -2, -3]
    ]
    codeflash_output = matrix_sum(matrix) # 1.08μs -> 917ns (18.2% faster)


def test_edge_matrix_is_not_list_of_lists():
    # Matrix is not a list of lists
    matrix = [1, 2, 3]
    with pytest.raises(TypeError):
        matrix_sum(matrix) # 1.50μs -> 1.17μs (28.6% faster)

def test_edge_matrix_with_non_list_row():
    # Matrix contains a non-list row
    matrix = [[1, 2], "not_a_list", [3, 4]]
    with pytest.raises(TypeError):
        matrix_sum(matrix) # 2.00μs -> 1.58μs (26.3% faster)

def test_edge_matrix_with_none_row():
    # Matrix contains None as a row
    matrix = [[1, 2], None, [3, 4]]
    with pytest.raises(TypeError):
        matrix_sum(matrix) # 1.54μs -> 1.17μs (32.0% faster)

def test_edge_matrix_with_non_int_element():
    # Matrix contains a non-int element
    matrix = [[1, 2], [3, "four"]]
    with pytest.raises(TypeError):
        matrix_sum(matrix) # 1.62μs -> 1.38μs (18.2% faster)

# -------------------------------
# 3. LARGE SCALE TEST CASES
# -------------------------------

def test_large_matrix_all_positive():
    # Large matrix (1000 rows, 10 elements each), all positive
    matrix = [[1]*10 for _ in range(1000)]
    # Each row sums to 10, all > 0
    codeflash_output = matrix_sum(matrix) # 159μs -> 83.2μs (91.9% faster)

def test_large_matrix_mixed_rows():
    # Large matrix (1000 rows), half rows sum > 0, half <= 0
    matrix = []
    for i in range(500):
        matrix.append([1]*10)       # sum = 10
    for i in range(500):
        matrix.append([-1]*10)      # sum = -10
    codeflash_output = matrix_sum(matrix) # 120μs -> 78.4μs (54.0% faster)

def test_large_matrix_some_empty_rows():
    # Large matrix with some empty rows
    matrix = [[1]*5 for _ in range(990)] + [[] for _ in range(10)]
    # Only non-empty rows have sum > 0
    codeflash_output = matrix_sum(matrix) # 115μs -> 66.0μs (75.0% faster)

def test_large_matrix_all_zero_rows():
    # Large matrix, all rows sum to zero
    matrix = [[0]*10 for _ in range(1000)]
    codeflash_output = matrix_sum(matrix) # 77.2μs -> 68.9μs (12.1% faster)

def test_large_matrix_varied_sums():
    # Large matrix, alternating positive/negative/zero sums
    matrix = []
    for i in range(333):
        matrix.append([1]*3)         # sum = 3
        matrix.append([-1]*3)        # sum = -3
        matrix.append([0]*3)         # sum = 0
    codeflash_output = matrix_sum(matrix) # 75.9μs -> 56.0μs (35.6% faster)

def test_large_matrix_single_large_row():
    # Matrix with a single very large row
    matrix = [[1]*1000]
    codeflash_output = matrix_sum(matrix) # 7.67μs -> 3.50μs (119% faster)

def test_large_matrix_large_numbers():
    # Matrix with large numbers
    matrix = [[10**6]*1000]
    codeflash_output = matrix_sum(matrix) # 11.6μs -> 4.38μs (166% faster)

def test_large_matrix_all_rows_negative():
    # Large matrix, all rows negative
    matrix = [[-1]*1000 for _ in range(1000)]
    codeflash_output = matrix_sum(matrix) # 3.35ms -> 2.90ms (15.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

# imports
import pytest  # used for our unit tests
from src.dsa.various import matrix_sum

# unit tests

# --- Basic Test Cases ---

def test_single_row_single_col_positive():
    # Test with a 1x1 matrix with a positive number
    codeflash_output = matrix_sum([[5]]) # 1.00μs -> 750ns (33.3% faster)

def test_single_row_single_col_zero():
    # Test with a 1x1 matrix with zero
    codeflash_output = matrix_sum([[0]]) # 791ns -> 583ns (35.7% faster)

def test_single_row_single_col_negative():
    # Test with a 1x1 matrix with a negative number
    codeflash_output = matrix_sum([[-3]]) # 708ns -> 500ns (41.6% faster)

def test_single_row_multiple_cols_all_positive():
    # Test with a single row and multiple positive numbers
    codeflash_output = matrix_sum([[1, 2, 3, 4]]) # 917ns -> 583ns (57.3% faster)

def test_single_row_multiple_cols_sum_zero():
    # Test with a single row whose sum is zero
    codeflash_output = matrix_sum([[2, -2]]) # 708ns -> 541ns (30.9% faster)

def test_multiple_rows_all_positive():
    # Test with multiple rows, all with positive sums
    codeflash_output = matrix_sum([[1, 2], [3, 4], [5, 6]]) # 1.17μs -> 875ns (33.4% faster)

def test_multiple_rows_some_negative_sum():
    # Test with multiple rows, some with negative or zero sums
    codeflash_output = matrix_sum([[1, -1], [2, 2], [-3, -4], [5, 0]]) # 1.21μs -> 1.00μs (20.8% faster)

def test_multiple_rows_all_zero_sum():
    # Test with multiple rows, all with zero sum
    codeflash_output = matrix_sum([[0, 0], [1, -1], [-2, 2]]) # 875ns -> 708ns (23.6% faster)

def test_multiple_rows_mixed():
    # Test with a mix of positive, zero, and negative sums
    codeflash_output = matrix_sum([[1, 2], [0, 0], [-1, -1], [3, 4]]) # 1.17μs -> 916ns (27.4% faster)

# --- Edge Test Cases ---

def test_empty_matrix():
    # Test with an empty matrix (no rows)
    codeflash_output = matrix_sum([]) # 542ns -> 375ns (44.5% faster)

def test_rows_empty_lists():
    # Test with a matrix where rows are empty lists
    codeflash_output = matrix_sum([[], [], []]) # 875ns -> 625ns (40.0% faster)

def test_row_with_all_zeros():
    # Test with a row containing all zeros
    codeflash_output = matrix_sum([[0, 0, 0]]) # 667ns -> 542ns (23.1% faster)

def test_row_with_large_negative_numbers():
    # Test with a row containing large negative numbers
    codeflash_output = matrix_sum([[-1000, -2000, -3000]]) # 750ns -> 625ns (20.0% faster)

def test_row_with_large_positive_numbers():
    # Test with a row containing large positive numbers
    codeflash_output = matrix_sum([[1000, 2000, 3000]]) # 875ns -> 625ns (40.0% faster)

def test_row_with_mixed_large_numbers():
    # Test with a row containing both large positive and negative numbers
    codeflash_output = matrix_sum([[1000, -500, 200, -700]]) # 750ns -> 542ns (38.4% faster)

def test_matrix_with_varying_row_lengths():
    # Test with a matrix where rows have different lengths
    codeflash_output = matrix_sum([[1, 2], [3], [], [4, 5, 6]]) # 1.25μs -> 958ns (30.5% faster)


def test_matrix_with_non_list_row():
    # Test with a row that is not a list should raise TypeError
    with pytest.raises(TypeError):
        matrix_sum([[1, 2], "not_a_list"]) # 2.58μs -> 2.12μs (21.6% faster)

def test_matrix_with_none_row():
    # Test with a row that is None should raise TypeError
    with pytest.raises(TypeError):
        matrix_sum([[1, 2], None]) # 1.71μs -> 1.38μs (24.2% faster)

def test_matrix_with_non_numeric_elements():
    # Test with a row containing non-numeric elements should raise TypeError
    with pytest.raises(TypeError):
        matrix_sum([[1, "a"], [2, 3]]) # 1.50μs -> 1.21μs (24.2% faster)

# --- Large Scale Test Cases ---

def test_large_matrix_all_positive():
    # Test with a large matrix (1000 rows, each with 10 positive numbers)
    matrix = [[i for i in range(1, 11)] for _ in range(1000)]
    # Each row sum is 55
    codeflash_output = matrix_sum(matrix) # 164μs -> 85.0μs (93.0% faster)

def test_large_matrix_all_zero():
    # Test with a large matrix (1000 rows, each with 10 zeros)
    matrix = [[0 for _ in range(10)] for _ in range(1000)]
    codeflash_output = matrix_sum(matrix) # 76.5μs -> 68.8μs (11.2% faster)

def test_large_matrix_mixed_sums():
    # Test with a large matrix (1000 rows), alternating positive and negative sums
    matrix = []
    for i in range(1000):
        if i % 2 == 0:
            matrix.append([1] * 10)  # sum = 10
        else:
            matrix.append([-1] * 10) # sum = -10
    # Only even-index rows should be included
    codeflash_output = matrix_sum(matrix) # 124μs -> 81.8μs (52.1% faster)

def test_large_matrix_some_empty_rows():
    # Test with a large matrix (1000 rows), some rows are empty
    matrix = [[1, 2, 3]] * 500 + [[]] * 500
    codeflash_output = matrix_sum(matrix) # 74.5μs -> 49.9μs (49.5% faster)

def test_large_matrix_varying_row_lengths():
    # Test with a large matrix (1000 rows), each row has increasing length
    matrix = [list(range(i)) for i in range(1000)]
    # Only rows with positive sum are included (i >= 2)
    expected = [sum(range(i)) for i in range(2, 1000)]
    codeflash_output = matrix_sum(matrix) # 3.72ms -> 1.92ms (93.7% faster)

# --- Determinism and Mutation Sensitivity ---

def test_mutation_sensitivity():
    # Changing the sign of any number should change the output
    matrix = [[1, 2], [3, 4]]
    codeflash_output = matrix_sum(matrix) # 1.04μs -> 708ns (47.0% faster)
    matrix_mutated = [[-1, 2], [3, 4]]
    codeflash_output = matrix_sum(matrix_mutated) # 625ns -> 375ns (66.7% faster)

def test_zero_row_exclusion():
    # Row with sum zero should be excluded
    matrix = [[1, -1], [2, -2], [3, 3]]
    codeflash_output = matrix_sum(matrix) # 1.00μs -> 750ns (33.3% faster)

def test_negative_row_exclusion():
    # Row with negative sum should be excluded
    matrix = [[-5, -5], [10, -5], [4, 2]]
    codeflash_output = matrix_sum(matrix) # 1.12μs -> 834ns (34.9% faster)

# --- Miscellaneous ---

def test_matrix_with_one_empty_row_and_one_positive_row():
    # Matrix with one empty row and one positive row
    codeflash_output = matrix_sum([[], [1, 2, 3]]) # 917ns -> 667ns (37.5% faster)

def test_matrix_with_all_empty_rows():
    # Matrix with all empty rows
    codeflash_output = matrix_sum([[], [], []]) # 834ns -> 625ns (33.4% faster)

def test_matrix_with_large_row_of_zeros():
    # Matrix with a single row of 1000 zeros
    codeflash_output = matrix_sum([[0]*1000]) # 4.08μs -> 4.12μs (0.994% slower)

def test_matrix_with_large_row_of_ones():
    # Matrix with a single row of 1000 ones
    codeflash_output = matrix_sum([[1]*1000]) # 7.67μs -> 4.17μs (84.0% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from src.dsa.various import matrix_sum

def test_matrix_sum():
    matrix_sum([[], [401]])

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_fb1xiyqb/tmp0sqty7r_/test_concolic_coverage.py::test_matrix_sum	958ns	708ns	35.3%✅

To edit these changes git checkout codeflash/optimize-matrix_sum-mha5y69u and push.