Matrix Operation Benchmark — NumPy Performance Across Matrix Sizes
Real benchmark data for 8 NumPy matrix operations across 6 matrix sizes (10x10 to 1000x1000). Each measurement is the average of 5 runs with standard deviation, executed on Apple Silicon with Accelerate BLAS.
By Michael Lip · Updated April 2026
Methodology
Benchmarks were executed on April 11, 2026 using Python 3.9 with NumPy on macOS (Apple Silicon) with Apple Accelerate as the BLAS backend. Each operation was timed using time.perf_counter() with 5 repetitions per (operation, size) pair. Input matrices are random float64 values from np.random.randn(n, n). Operations per second = 1000 / avg_ms. All times in milliseconds. The determinant overflow warning at large sizes is expected and does not affect timing accuracy.
| Operation | Matrix Size | Avg Time (ms) | Std Dev (ms) | Ops/Second | Complexity |
|---|---|---|---|---|---|
| matmul | 10x10 | 0.006 | 0.010 | 166,667 | O(n^3) |
| matmul | 50x50 | 0.208 | 0.406 | 4,808 | O(n^3) |
| matmul | 100x100 | 0.012 | 0.002 | 83,333 | O(n^3) |
| matmul | 250x250 | 0.096 | 0.001 | 10,417 | O(n^3) |
| matmul | 500x500 | 0.676 | 0.071 | 1,479 | O(n^3) |
| matmul | 1000x1000 | 5.447 | 0.888 | 184 | O(n^3) |
| inverse | 10x10 | 0.010 | 0.008 | 100,000 | O(n^3) |
| inverse | 50x50 | 0.211 | 0.351 | 4,739 | O(n^3) |
| inverse | 100x100 | 0.095 | 0.013 | 10,526 | O(n^3) |
| inverse | 250x250 | 0.558 | 0.033 | 1,792 | O(n^3) |
| inverse | 500x500 | 2.670 | 0.110 | 375 | O(n^3) |
| inverse | 1000x1000 | 15.627 | 0.670 | 64 | O(n^3) |
| determinant | 10x10 | 0.300 | 0.592 | 3,333 | O(n^3) |
| determinant | 50x50 | 0.133 | 0.238 | 7,519 | O(n^3) |
| determinant | 100x100 | 0.390 | 0.701 | 2,564 | O(n^3) |
| determinant | 250x250 | 0.229 | 0.005 | 4,367 | O(n^3) |
| determinant | 500x500 | 1.377 | 0.643 | 726 | O(n^3) |
| determinant | 1000x1000 | 4.486 | 0.127 | 223 | O(n^3) |
| eigenvalues | 10x10 | 0.340 | 0.629 | 2,941 | O(n^3) |
| eigenvalues | 50x50 | 0.474 | 0.401 | 2,110 | O(n^3) |
| eigenvalues | 100x100 | 1.919 | 0.129 | 521 | O(n^3) |
| eigenvalues | 250x250 | 12.876 | 0.102 | 78 | O(n^3) |
| eigenvalues | 500x500 | 48.411 | 0.341 | 21 | O(n^3) |
| eigenvalues | 1000x1000 | 237.491 | 2.326 | 4 | O(n^3) |
| svd | 10x10 | 0.291 | 0.539 | 3,436 | O(n^3) |
| svd | 50x50 | 0.661 | 0.844 | 1,513 | O(n^3) |
| svd | 100x100 | 0.863 | 0.043 | 1,159 | O(n^3) |
| svd | 250x250 | 5.305 | 0.410 | 189 | O(n^3) |
| svd | 500x500 | 22.130 | 0.771 | 45 | O(n^3) |
| svd | 1000x1000 | 105.221 | 1.920 | 10 | O(n^3) |
| transpose | 10x10 | 0.001 | 0.001 | 1,000,000 | O(n^2) |
| transpose | 50x50 | 0.002 | 0.001 | 500,000 | O(n^2) |
| transpose | 100x100 | 0.004 | 0.001 | 250,000 | O(n^2) |
| transpose | 250x250 | 0.026 | 0.008 | 38,462 | O(n^2) |
| transpose | 500x500 | 0.103 | 0.031 | 9,709 | O(n^2) |
| transpose | 1000x1000 | 0.641 | 0.035 | 1,560 | O(n^2) |
| trace | 10x10 | 0.002 | 0.002 | 500,000 | O(n) |
| trace | 50x50 | 0.002 | 0.001 | 500,000 | O(n) |
| trace | 100x100 | 0.002 | 0.001 | 500,000 | O(n) |
| trace | 250x250 | 0.002 | 0.002 | 500,000 | O(n) |
| trace | 500x500 | 0.004 | 0.004 | 250,000 | O(n) |
| trace | 1000x1000 | 0.003 | 0.002 | 333,333 | O(n) |
| qr | 10x10 | 0.029 | 0.024 | 34,483 | O(n^3) |
| qr | 50x50 | 0.972 | 1.830 | 1,029 | O(n^3) |
| qr | 100x100 | 0.184 | 0.013 | 5,435 | O(n^3) |
| qr | 250x250 | 1.079 | 0.038 | 927 | O(n^3) |
| qr | 500x500 | 4.586 | 0.150 | 218 | O(n^3) |
| qr | 1000x1000 | 24.492 | 0.313 | 41 | O(n^3) |
Key Findings
Eigenvalue computation is the bottleneck. At 1000x1000, eigenvalues take 237.5 ms — 44x slower than matmul (5.4 ms) and 2.3x slower than SVD (105.2 ms). This reflects the iterative QR algorithm's convergence requirements versus direct computation in matmul.
Trace is essentially free. At O(n) complexity, trace takes 0.003 ms even at 1000x1000 — it simply sums n diagonal elements. Transpose at O(n^2) is the next fastest, requiring a memory copy but no computation.
BLAS makes matmul deceptively fast. The 100x100 matmul (0.012 ms) is faster than 50x50 (0.208 ms) because BLAS achieves better vectorization and cache utilization at larger sizes. The first call also includes JIT/dispatch overhead that amortizes over larger computations.
Scaling follows cubic complexity. From 500x500 to 1000x1000 (2x dimension), matmul goes from 0.676 to 5.447 ms (8.1x), inverse from 2.670 to 15.627 ms (5.9x), and eigenvalues from 48.4 to 237.5 ms (4.9x). The sub-8x scaling for some operations indicates better hardware utilization at larger sizes.
Frequently Asked Questions
How fast is NumPy matrix multiplication?
NumPy matmul is extremely fast thanks to BLAS. A 100x100 matmul takes 0.012 ms, 500x500 takes 0.676 ms, and 1000x1000 takes 5.447 ms. NumPy delegates to hardware-optimized routines (Accelerate, OpenBLAS, MKL) using SIMD, cache blocking, and multi-threading.
Why is eigenvalue computation so much slower than matrix multiplication?
Eigenvalue computation requires O(10n^3) operations vs O(n^3) for matmul. At 1000x1000, eigenvalues take 237.5 ms vs 5.4 ms for matmul — 44x slower. It uses iterative QR steps that converge gradually, while matmul is a single direct computation.
What is the fastest matrix operation in NumPy?
Trace is fastest — it sums diagonal elements in O(n) time, taking 0.003 ms at 1000x1000. Transpose is second at 0.641 ms (O(n^2) copy). Neither invokes LAPACK. Among LAPACK operations, matmul is fastest due to optimized BLAS Level 3 (GEMM).
How does matrix size affect NumPy performance?
Doubling the dimension increases time by ~8x for O(n^3) operations. However, BLAS achieves better utilization at larger sizes — 1000x1000 matmul runs at higher GFLOPS than 100x100 due to better cache line, SIMD, and multi-core utilization.
Which BLAS backend does NumPy use and does it matter?
NumPy supports Accelerate (macOS), OpenBLAS (Linux), MKL (Anaconda), and BLIS. For 1000x1000 matmul, MKL and Accelerate are typically 10-30% faster than OpenBLAS. Check your backend with np.show_config(). For eigenvalue/SVD, LAPACK quality matters more than BLAS backend.