⚡️ Speed up function matrix_inverse by 243%

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:
```python
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:
```python
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.

Author: codeflash-ai[bot]

src/numpy_pandas/matrix_operations.py

@@ -30,14 +30,14 @@ def matrix_inverse(matrix: np.ndarray) -> np.ndarray:
         raise ValueError("Matrix must be square")
     n = matrix.shape[0]
     identity = np.eye(n)
-    augmented = np.hstack((matrix, identity))
+    augmented = np.hstack((matrix.astype(float), identity))
     for i in range(n):
         pivot = augmented[i, i]
         augmented[i] = augmented[i] / pivot
-        for j in range(n):
-            if i != j:
-                factor = augmented[j, i]
-                augmented[j] = augmented[j] - factor * augmented[i]
+        # Vectorized elimination for all other rows
+        mask = np.arange(n) != i
+        factors = augmented[mask, i, np.newaxis]
+        augmented[mask] -= factors * augmented[i]
     return augmented[:, n:]