⚡️ Speed up function matrix_inverse by 243%

[codeflash-ai]

📄 243% (2.43x) speedup for matrix_inverse in src/numpy_pandas/matrix_operations.py

⏱️ Runtime : 15.1 milliseconds → 4.38 milliseconds (best of 221 runs)

📝 Explanation and details

The optimized code achieves a 243% speedup by eliminating the inner nested loop and leveraging NumPy's vectorized operations for Gaussian elimination.

Key Optimization: Vectorized Row Operations

The original code uses a nested loop structure where for each pivot row i, it iterates through all other rows j to perform elimination:

for j in range(n):
    if i != j:
        factor = augmented[j, i]
        augmented[j] = augmented[j] - factor * augmented[i]

The optimized version replaces this with vectorized operations:

mask = np.arange(n) != i
factors = augmented[mask, i, np.newaxis]
augmented[mask] -= factors * augmented[i]

Why This is Faster:

1. Eliminates Python Loop Overhead: The inner loop in the original code executes O(n²) times with Python's interpreted overhead. The vectorized version delegates this to NumPy's compiled C code.

2. Batch Operations: Instead of updating rows one by one, the optimized version computes elimination factors for all non-pivot rows simultaneously and applies the row operations in a single vectorized subtraction.

3. Memory Access Patterns: Vectorized operations enable better CPU cache utilization and SIMD instruction usage compared to element-by-element operations in Python loops.

Performance Analysis from Line Profiler:

• Original: The nested loop operations (for j and row elimination) consume 86% of total runtime (63.1% + 12.3% + 9.8%)
• Optimized: The vectorized elimination (augmented[mask] -= factors * augmented[i]) takes 63.9% of runtime, but the total runtime is 5× faster

Test Case Performance:

• Small matrices (2x2, 3x3): ~46% slower due to vectorization overhead outweighing benefits
• Medium matrices (10x10): 61-62% faster as vectorization benefits emerge
• Large matrices (50x50, 100x100): 285-334% faster where vectorization provides maximum advantage

The optimization also adds .astype(float) to ensure consistent floating-point arithmetic, preventing potential integer overflow issues during matrix operations.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 41 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.matrix_operations import matrix_inverse

# unit tests

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

def test_identity_matrix_2x2():
    # Inverse of identity is identity
    I = np.eye(2)
    codeflash_output = matrix_inverse(I); inv = codeflash_output # 7.25μs -> 13.8μs (47.6% slower)

def test_identity_matrix_5x5():
    # Larger identity matrix
    I = np.eye(5)
    codeflash_output = matrix_inverse(I); inv = codeflash_output # 24.6μs -> 28.0μs (12.1% slower)

def test_simple_2x2_invertible():
    # Inverse of a simple 2x2 matrix
    A = np.array([[4, 7], [2, 6]], dtype=float)
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 7.50μs -> 14.0μs (46.3% slower)

def test_simple_3x3_invertible():
    # Inverse of a simple 3x3 matrix
    A = np.array([[1, 2, 3], [0, 1, 4], [5, 6, 0]], dtype=float)
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 11.7μs -> 18.7μs (37.5% slower)

def test_negative_entries():
    # Matrix with negative entries
    A = np.array([[2, -1], [-1, 2]], dtype=float)
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 7.46μs -> 13.9μs (46.2% slower)

def test_fractional_entries():
    # Matrix with fractional entries
    A = np.array([[0.5, 0.2], [0.1, 0.7]], dtype=float)
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 7.42μs -> 13.8μs (46.1% slower)

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

def test_non_square_matrix_raises():
    # Non-square matrix should raise ValueError
    A = np.array([[1, 2, 3], [4, 5, 6]], dtype=float)
    with pytest.raises(ValueError):
        matrix_inverse(A) # 500ns -> 500ns (0.000% faster)



def test_almost_singular_matrix():
    # Nearly singular matrix (very small determinant)
    eps = 1e-12
    A = np.array([[1, 1], [1, 1+eps]], dtype=float)
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 7.92μs -> 14.7μs (46.2% slower)

def test_permutation_matrix():
    # Permutation matrix (should be its own inverse)
    A = np.array([[0, 1], [1, 0]], dtype=float)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 11.7μs -> 18.2μs (35.9% slower)

def test_swap_rows_needed():
    # Matrix requiring row swaps for inversion
    A = np.array([[0, 1], [1, 0]], dtype=float)
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 11.0μs -> 17.8μs (37.8% slower)

def test_large_values():
    # Matrix with very large values
    A = np.array([[1e10, 2e10], [3e10, 4e10]], dtype=float)
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 7.50μs -> 13.8μs (45.5% slower)

def test_small_values():
    # Matrix with very small values
    A = np.array([[1e-10, 2e-10], [3e-10, 4e-10]], dtype=float)
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 7.42μs -> 13.8μs (46.2% slower)

def test_invert_diagonal_matrix():
    # Diagonal matrix (invert by inverting diagonal)
    diag = np.array([2, 3, 4], dtype=float)
    A = np.diag(diag)
    expected = np.diag(1/diag)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 11.4μs -> 18.4μs (38.0% slower)

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

def test_large_10x10_random_matrix():
    # 10x10 random invertible matrix
    rng = np.random.default_rng(42)
    while True:
        A = rng.random((10, 10))
        if abs(np.linalg.det(A)) > 1e-6:
            break
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 87.1μs -> 53.8μs (62.0% faster)

def test_large_50x50_random_matrix():
    # 50x50 random invertible matrix
    rng = np.random.default_rng(123)
    while True:
        A = rng.random((50, 50))
        if abs(np.linalg.det(A)) > 1e-6:
            break
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 2.13ms -> 490μs (334% faster)

def test_inverse_product_is_identity_20x20():
    # Product of matrix and its inverse is identity (20x20)
    rng = np.random.default_rng(321)
    while True:
        A = rng.random((20, 20))
        if abs(np.linalg.det(A)) > 1e-6:
            break
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 334μs -> 112μs (196% faster)
    product = np.dot(A, inv)

def test_inverse_product_is_identity_100x100():
    # Product of matrix and its inverse is identity (100x100)
    rng = np.random.default_rng(456)
    while True:
        A = rng.random((100, 100))
        if abs(np.linalg.det(A)) > 1e-6:
            break
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 9.36ms -> 2.43ms (285% faster)
    product = np.dot(A, inv)

def test_inverse_of_inverse_is_original():
    # Inverse of the inverse is the original matrix (7x7)
    rng = np.random.default_rng(789)
    while True:
        A = rng.random((7, 7))
        if abs(np.linalg.det(A)) > 1e-6:
            break
    codeflash_output = matrix_inverse(A); inv = codeflash_output # 45.2μs -> 37.9μs (19.1% faster)
    codeflash_output = matrix_inverse(inv); invinv = codeflash_output # 42.8μs -> 34.4μs (24.2% faster)

# ---- DETERMINISM TEST ----

def test_determinism():
    # Ensure the result is deterministic (same input, same output)
    A = np.array([[3, 2], [1, 4]], dtype=float)
    codeflash_output = matrix_inverse(A); inv1 = codeflash_output # 7.50μs -> 14.1μs (46.9% slower)
    codeflash_output = matrix_inverse(A); inv2 = codeflash_output # 5.62μs -> 11.7μs (52.0% slower)

# ---- TESTS FOR FLOATING POINT STABILITY ----



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():
    # 1x1 identity
    I1 = np.eye(1)
    codeflash_output = matrix_inverse(I1); inv = codeflash_output # 4.96μs -> 10.8μs (53.9% slower)
    # 2x2 identity
    I2 = np.eye(2)
    codeflash_output = matrix_inverse(I2); inv = codeflash_output # 6.04μs -> 12.4μs (51.3% slower)
    # 5x5 identity
    I5 = np.eye(5)
    codeflash_output = matrix_inverse(I5); inv = codeflash_output # 22.8μs -> 25.5μs (10.5% slower)

def test_simple_2x2_matrix():
    # Invertible 2x2 matrix
    A = np.array([[4, 7], [2, 6]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 7.83μs -> 14.3μs (45.2% slower)

def test_simple_3x3_matrix():
    # Invertible 3x3 matrix
    A = np.array([[1, 2, 3], [0, 1, 4], [5, 6, 0]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 11.9μs -> 19.0μs (37.4% slower)

def test_negative_entries():
    # Matrix with negative entries
    A = np.array([[2, -1], [-1, 2]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 7.54μs -> 13.9μs (45.8% slower)

def test_float_entries():
    # Matrix with float entries
    A = np.array([[1.5, 2.5], [3.5, 4.5]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 7.50μs -> 13.9μs (45.9% slower)

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

def test_non_square_matrix_raises():
    # Non-square matrix should raise ValueError
    A = np.array([[1, 2, 3], [4, 5, 6]])
    with pytest.raises(ValueError):
        matrix_inverse(A) # 500ns -> 500ns (0.000% faster)


def test_nearly_singular_matrix():
    # Matrix with very small determinant, should still invert (but warn if unstable)
    A = np.array([[1, 1], [1, 1.0000001]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 7.96μs -> 14.7μs (45.7% slower)


def test_permutation_matrix():
    # Permutation matrix (row swaps)
    A = np.array([[0, 1], [1, 0]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 12.0μs -> 18.9μs (36.4% slower)

def test_swap_rows_needed():
    # Matrix requiring row swaps for pivoting
    A = np.array([[0, 1], [1, 0]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 11.2μs -> 17.8μs (36.8% slower)


def test_integer_matrix():
    # Integer matrix, result should be float
    A = np.array([[2, 3], [1, 4]])
    codeflash_output = matrix_inverse(A); result = codeflash_output # 9.12μs -> 16.1μs (43.3% slower)

def test_1x1_matrix():
    # 1x1 matrix
    A = np.array([[5]])
    expected = np.array([[0.2]])
    codeflash_output = matrix_inverse(A); result = codeflash_output # 5.29μs -> 10.5μs (49.4% slower)

def test_large_values_matrix():
    # Matrix with large values
    A = np.array([[1e8, 2e8], [3e8, 4e8]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 7.75μs -> 14.2μs (45.5% slower)

def test_small_values_matrix():
    # Matrix with small values
    A = np.array([[1e-8, 2e-8], [3e-8, 4e-8]])
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 7.62μs -> 14.0μs (45.4% slower)

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

def test_large_10x10_random_matrix():
    # Large 10x10 random matrix
    rng = np.random.default_rng(42)
    A = rng.random((10, 10))
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 87.2μs -> 54.0μs (61.4% faster)

def test_large_50x50_random_matrix():
    # Large 50x50 random matrix
    rng = np.random.default_rng(123)
    A = rng.random((50, 50))
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 2.12ms -> 489μs (333% faster)

def test_inverse_property_large():
    # For a random 20x20 matrix, check that A @ inv(A) == I
    rng = np.random.default_rng(100)
    A = rng.random((20, 20))
    codeflash_output = matrix_inverse(A); invA = codeflash_output # 335μs -> 112μs (198% faster)
    I = np.eye(20)
    product = np.dot(A, invA)

def test_inverse_property_medium():
    # For a random 8x8 matrix, check that inv(A) @ A == I
    rng = np.random.default_rng(200)
    A = rng.random((8, 8))
    codeflash_output = matrix_inverse(A); invA = codeflash_output # 57.3μs -> 42.1μs (36.1% faster)
    I = np.eye(8)
    product = np.dot(invA, A)

def test_large_matrix_with_integer_entries():
    # 15x15 matrix with integer entries
    rng = np.random.default_rng(321)
    A = rng.integers(1, 10, size=(15, 15))
    expected = np.linalg.inv(A)
    codeflash_output = matrix_inverse(A); result = codeflash_output # 192μs -> 80.8μs (138% 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.numpy_pandas.matrix_operations import matrix_inverse

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