⚡️ Speed up function matrix_inverse by 52%

[codeflash-ai]

📄 52% (0.52x) speedup for matrix_inverse in src/numpy_pandas/matrix_operations.py

⏱️ Runtime : 629 milliseconds → 413 milliseconds (best of 18 runs)

📝 Explanation and details

The optimization replaces a nested loop structure with vectorized NumPy operations, achieving a 52% speedup.

Key Changes:

1. Eliminated inner loop: The original code used for j in range(n) with individual element operations, which generated ~297K loop iterations for larger matrices
2. Vectorized row elimination: Replaced the inner loop with:
   • mask = np.arange(n) != i to select all rows except the pivot row
   • factors = augmented[mask, i][:, None] to extract elimination factors as a column vector
   • augmented[mask] -= factors * augmented[i] to perform elimination on all rows simultaneously

Performance Impact:

• The original code spent 69% of its time in the inner loop's row elimination step (augmented[j] = augmented[j] - factor * augmented[i])
• The optimized version consolidates this into a single vectorized operation that takes 97.4% of the total time but runs much faster overall
• Line profiler shows the critical elimination step dropped from ~757ms to ~613ms total execution time

Best Performance Gains:
The optimization excels with larger matrices where vectorization benefits are most pronounced:

• Large matrices (50x50 to 100x100): 258-270% faster
• Medium matrices (20x20): 139-224% faster
• Small matrices show modest slowdowns (26-50% slower) due to vectorization overhead

This is a classic example of trading loop overhead for NumPy's optimized C implementations, particularly effective for the O(n³) Gaussian elimination algorithm.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 42 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
🔮 Hypothesis Tests	✅ 2 Passed
📊 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.matrix_operations import matrix_inverse

# unit tests

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

def test_identity_matrix_inverse():
    # Test that the inverse of the identity matrix is itself
    I = np.eye(3)
    codeflash_output = matrix_inverse(I); inv = codeflash_output # 36.9μs -> 49.9μs (26.0% slower)

def test_simple_2x2_matrix():
    # Test inverse of a simple 2x2 matrix
    A = np.array([[4, 7], [2, 6]], dtype=float)
    expected = np.array([[0.6, -0.7], [-0.2, 0.4]])
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 17.2μs -> 29.8μs (42.2% slower)

def test_simple_3x3_matrix():
    # Test inverse of a simple 3x3 matrix
    A = np.array([[1, 2, 3], [0, 1, 4], [5, 6, 0]], dtype=float)
    expected = np.array([[-24, 18, 5], [20, -15, -4], [-5, 4, 1]])
    expected = expected / 1.0  # determinant is 1
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 22.9μs -> 34.2μs (33.1% slower)

def test_inverse_times_original_is_identity():
    # Test that A @ A_inv == I for a random invertible matrix
    rng = np.random.default_rng(42)
    A = rng.random((4, 4))
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 34.0μs -> 43.6μs (22.0% slower)
    I = np.eye(4)

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

def test_non_square_matrix_raises():
    # Test that non-square matrices raise ValueError
    A = np.array([[1, 2, 3], [4, 5, 6]], dtype=float)
    with pytest.raises(ValueError):
        matrix_inverse(A) # 1.17μs -> 1.08μs (7.66% faster)



def test_inverse_of_negative_diagonal():
    # Test matrix with negative diagonal elements
    A = np.diag([-1, -2, -3])
    expected = np.diag([-1, -0.5, -1/3])
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 23.4μs -> 36.1μs (35.1% slower)


def test_inverse_of_1x1_matrix():
    # Test inverse of a 1x1 matrix
    A = np.array([[5]], dtype=float)
    expected = np.array([[0.2]])
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 13.8μs -> 22.9μs (40.0% slower)

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

def test_large_random_matrix_inverse():
    # Test inverse of a large random matrix (100x100)
    rng = np.random.default_rng(123)
    A = rng.random((100, 100))
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 16.4ms -> 4.57ms (258% faster)
    # Check that A @ inv is close to identity
    I = np.eye(100)

def test_large_diagonal_matrix_inverse():
    # Test inverse of a large diagonal matrix
    diag = np.arange(1, 501, dtype=float)
    A = np.diag(diag)
    expected = np.diag(1 / diag)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 553ms -> 391ms (41.4% faster)

def test_large_sparse_matrix_inverse():
    # Test inverse of a sparse matrix (mostly zeros, but invertible)
    n = 50
    A = np.eye(n) + np.diag(np.ones(n-1), k=1)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 3.76ms -> 1.05ms (258% faster)
    expected = np.linalg.inv(A)

def test_inverse_random_seed_determinism():
    # Make sure random matrix inverse is deterministic given the same seed
    rng = np.random.default_rng(999)
    A1 = rng.random((20, 20))
    rng = np.random.default_rng(999)
    A2 = rng.random((20, 20))
    codeflash_output = matrix_inverse(A1); inv1 = codeflash_output # 613μs -> 196μs (213% faster)
    codeflash_output = matrix_inverse(A2); inv2 = codeflash_output # 595μs -> 183μs (224% 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.matrix_operations import matrix_inverse

# unit tests

# --- BASIC TEST CASES ---

def test_inverse_identity():
    # Inverse of identity matrix is itself
    for n in [1, 2, 3, 5]:
        I = np.eye(n)
        codeflash_output = matrix_inverse(I); inv = codeflash_output # 78.4μs -> 108μs (27.9% slower)

def test_inverse_simple_2x2():
    # Test inverse of a simple 2x2 matrix
    A = np.array([[1, 2], [3, 4]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 15.5μs -> 25.4μs (39.2% slower)

def test_inverse_simple_3x3():
    # Test inverse of a simple 3x3 matrix
    A = np.array([[2, 0, 1], [1, 1, 0], [0, 2, 1]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 22.0μs -> 33.1μs (33.6% slower)

def test_inverse_negative_values():
    # Matrix with negative values
    A = np.array([[2, -1], [-1, 2]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 14.3μs -> 24.8μs (42.1% slower)

def test_inverse_float_values():
    # Matrix with float values
    A = np.array([[1.5, 2.5], [3.5, 4.5]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 14.2μs -> 24.3μs (41.4% slower)

# --- EDGE TEST CASES ---

def test_non_square_matrix_raises():
    # Should raise ValueError for non-square matrix
    A = np.array([[1, 2, 3], [4, 5, 6]])
    with pytest.raises(ValueError):
        matrix_inverse(A) # 1.29μs -> 1.21μs (6.95% faster)


def test_almost_singular_matrix():
    # Matrix with very small determinant, test for numerical stability
    eps = 1e-10
    A = np.array([[1, 1], [1, 1+eps]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 16.7μs -> 27.1μs (38.5% slower)

def test_inverse_1x1():
    # Inverse of a 1x1 matrix is 1/value
    A = np.array([[7]])
    expected = np.array([[1/7]])
    codeflash_output = matrix_inverse(A); result = codeflash_output # 10.0μs -> 17.6μs (42.9% slower)

def test_inverse_with_zeros():
    # Matrix with zeros but invertible
    A = np.array([[0, 1], [1, 0]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 25.6μs -> 34.9μs (26.6% slower)

def test_inverse_diagonal_matrix():
    # Diagonal matrix
    D = np.diag([2, 3, 4])
    expected = np.linalg.inv(D)
    codeflash_output = matrix_inverse(D); result = codeflash_output # 21.7μs -> 33.0μs (34.3% slower)

def test_inverse_permutation_matrix():
    # Permutation matrix (should be its own inverse)
    P = np.array([[0,1,0],[0,0,1],[1,0,0]])
    expected = np.linalg.inv(P)
    codeflash_output = matrix_inverse(P); result = codeflash_output # 31.0μs -> 42.5μs (27.0% slower)

# --- LARGE SCALE TEST CASES ---

def test_inverse_large_random_matrix():
    # Large random invertible matrix
    np.random.seed(42)
    n = 50
    A = np.random.rand(n, n)
    # Make sure it's invertible by adding n*I
    A = A + n * np.eye(n)
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 3.83ms -> 1.03ms (270% faster)

def test_inverse_large_diagonal_matrix():
    # Large diagonal matrix
    n = 100
    D = np.diag(np.arange(1, n+1))
    expected = np.linalg.inv(D)
    codeflash_output = matrix_inverse(D); result = codeflash_output # 16.2ms -> 4.51ms (260% faster)

def test_inverse_large_sparse_matrix():
    # Large sparse matrix with random nonzero diagonal
    n = 100
    D = np.diag(np.random.uniform(1, 10, size=n))
    # Add a few off-diagonal elements
    D[0, 1] = 0.1
    D[1, 0] = 0.2
    D[50, 25] = 0.3
    expected = np.linalg.inv(D)
    codeflash_output = matrix_inverse(D); result = codeflash_output # 16.2ms -> 4.52ms (258% faster)

def test_inverse_large_permutation_matrix():
    # Large permutation matrix (should be its own inverse)
    n = 100
    P = np.eye(n)[::-1]
    expected = np.linalg.inv(P)
    codeflash_output = matrix_inverse(P); result = codeflash_output # 16.3ms -> 4.55ms (258% faster)

# --- FUNCTIONALITY TESTS ---

def test_inverse_product_is_identity():
    # For random invertible matrix, A * A_inv should be identity
    np.random.seed(123)
    for n in [2, 5, 10, 20]:
        A = np.random.rand(n, n) + n * np.eye(n)
        codeflash_output = matrix_inverse(A); A_inv = codeflash_output # 808μs -> 337μs (139% faster)
        product = np.dot(A, A_inv)

def test_inverse_inverse_is_original():
    # Inverse of the inverse is the original matrix
    np.random.seed(7)
    for n in [2, 5, 10]:
        A = np.random.rand(n, n) + n * np.eye(n)
        codeflash_output = matrix_inverse(A); A_inv = codeflash_output # 205μs -> 149μs (37.3% faster)
        codeflash_output = matrix_inverse(A_inv); A_inv_inv = codeflash_output # 200μs -> 141μs (41.8% faster)

# --- DETERMINISM TEST ---

def test_deterministic_output():
    # The output should be deterministic for the same input
    A = np.array([[1,2],[3,4]])
    codeflash_output = matrix_inverse(A); inv1 = codeflash_output # 14.1μs -> 24.3μs (42.1% slower)
    codeflash_output = matrix_inverse(A); inv2 = codeflash_output # 9.96μs -> 20.1μs (50.5% 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.numpy_pandas.matrix_operations import matrix_inverse

To edit these changes git checkout codeflash/optimize-matrix_inverse-mha4an80 and push.