Matrix Calculator
Enter values in the matrix grids and select an operation. Supports 2-2 to 5-5 matrices.
Last reviewed: April 2026New to this tool? Click here for instructions
Matrix A
Matrix B
How to Use the Matrix Calculator
To use the Matrix Calculator, follow these steps:
1. Select an operation using the chips: Add, Subtract, Multiply, Scalar, Transpose, Determinant, or Inverse.
2. Set matrix dimensions using the rows/cols dropdowns (2 to 5 for each dimension).
3. Enter values directly into the grid cells. Use decimals or negatives freely.
4. Click Calculate to see the result matrix and a step-by-step breakdown.
When to Use the Matrix Calculator in Real Workflows
Matrices are central to several major areas of software development, including computer graphics and game development, machine learning, and data science. Understanding how matrix operations work gives you a practical edge in these fields.
How the Matrix Calculator Works
The Matrix Calculator uses 100% client-side computation, ensuring fast and secure results. It supports 2-2 to 5-5 matrices and performs various operations, including addition, subtraction, multiplication, transpose, determinant, and inverse.
Tips, Edge Cases, and Limitations
Here are some tips and considerations when using the Matrix Calculator:
1. Matrix addition and subtraction require identical dimensions.
2. Matrix multiplication is generally not commutative.
3. The calculator uses cofactor expansion for larger matrices and Gaussian elimination for 5-5 matrices.
Frequently Asked Questions
This calculator handles matrix addition, subtraction, multiplication, transpose, determinant, and inverse — all computed in your browser with no server round-trips. Whether you're verifying a hand-coded GLSL transformation matrix, checking covariance calculations before writing NumPy, or working through a linear algebra problem, the results are cross-checked against NumPy/SciPy for numerical stability on well-conditioned matrices up to 5×5.
What This Tool Does
Six matrix operations are available: addition, subtraction, multiplication, transpose, determinant, and inverse. All computation runs 100% client-side — your input never leaves the browser tab. Results have been cross-checked against NumPy 1.26 and SciPy 1.11 reference outputs on well-conditioned test matrices to confirm numerical stability.
Supported Operations
Addition and subtraction work on any matching rectangular matrices the UI can display. Multiplication accepts any m×n times n×p pairing where the inner dimensions match. Transpose works on any rectangular matrix. Determinant and inverse are scoped to square matrices up to 5×5 — beyond that size, the tool surfaces a recommendation to use NumPy or SciPy, where batch processing and higher-precision decompositions are more practical.
Matrix Size Limits and Input Formats
Every input cell accepts any IEEE 754 double-precision float: positive, negative, integer, or decimal. You can enter -0.003, 1e4, or 3.14159 directly into any cell. The output panel displays results to six decimal places by default, with a toggle to show full 15-digit double precision when debugging floating-point edge cases.
How to Use It
A complete matrix multiplication takes four steps and under 60 seconds on a first visit.
Step-by-step input guide
- Select operation from the chip bar at the top of the tool (Add, Subtract, Multiply, Transpose, Determinant, Inverse).
- Set dimensions for Matrix A using the rows × cols dropdowns. For operations requiring a second matrix (addition, subtraction, multiplication), the Matrix B panel appears with its own dimension selectors.
- Enter values — click any cell and type; Tab moves to the next cell. Decimals and negative numbers are accepted in all fields.
- Click Calculate. The tool validates that inner dimensions match before computing. The result renders in the right pane immediately, with Copy and Download buttons.
Try Example button
The Try Example button pre-fills Matrix A = [[4.7, −2.1], [1.3, 5.8]] and Matrix B = [[3.2, 0.9, −1.4], [2.5, −0.6, 4.1]] for a 2×2 × 2×3 multiplication, producing a 2×3 result. Run this first to confirm the tool is working as expected before entering your own values.
Reading the output panel
Results display as a formatted matrix grid. The status bar beneath the grid shows the output dimensions (e.g., "2×3 result"), the operation name, and a warning badge if the matrix is near-singular or the condition number exceeds 10¹². Use the Copy button to grab the result as a JSON array or CSV for pasting directly into code.
Worked Example: 2×2 Times 2×3 Multiplication
The following example uses the exact values from the Try Example preset. Working through it manually lets you verify the tool's output cell by cell.
- Matrix A (2×2)
[[4.7, -2.1], [1.3, 5.8]]- Matrix B (2×3)
[[3.2, 0.9, -1.4], [2.5, -0.6, 4.1]]- Operation
- Multiply A × B
Dimension rule: (m×n) × (n×p) = (m×p)
A is 2×2 and B is 2×3. The inner dimensions (both 2) match, so the product C is defined and has dimensions 2×3. Per Strang, Introduction to Linear Algebra §1.3: "The entry in row i and column j of AB is (row i of A) · (column j of B)."
Row-by-column dot products
Each entry C[i][j] is the dot product of row i from A with column j from B:
- C[0][0] = 4.7 × 3.2 + (−2.1) × 2.5 = 15.04 − 5.25 = 9.79
- C[0][1] = 4.7 × 0.9 + (−2.1) × (−0.6) = 4.23 + 1.26 = 5.49
- C[0][2] = 4.7 × (−1.4) + (−2.1) × 4.1 = −6.58 − 8.61 = −15.19
- C[1][0] = 1.3 × 3.2 + 5.8 × 2.5 = 4.16 + 14.50 = 18.66
- C[1][1] = 1.3 × 0.9 + 5.8 × (−0.6) = 1.17 − 3.48 = −2.31
- C[1][2] = 1.3 × (−1.4) + 5.8 × 4.1 = −1.82 + 23.78 = 21.96
Full result matrix
Result C (2×3):
[[ 9.79, 5.49, -15.19 ],
[ 18.66, -2.31, 21.96 ]]Paste this directly into a shader uniform or a NumPy array literal — the tool's Copy → JSON Array button produces [[9.79,5.49,-15.19],[18.66,-2.31,21.96]] with no extra formatting.
Matrix Operations Explained
Each operation has distinct dimension requirements and a different algorithmic cost. The table below summarizes them; the subsections that follow cover the ones most likely to surprise you.
| Operation | Required Dimensions | Output Dimensions | Time Complexity | Singular / Error Condition |
|---|---|---|---|---|
| Addition | A and B must be identical m×n | m×n | O(n²) | Dimension mismatch |
| Subtraction | A and B must be identical m×n | m×n | O(n²) | Dimension mismatch |
| Multiplication | A is m×n; B is n×p (inner dims match) | m×p | O(n³) | Inner dimension mismatch |
| Transpose | Any m×n | n×m | O(n²) | None |
| Determinant | Square n×n (n ≤ 5) | Scalar | O(n³) | Result = 0 → matrix is singular |
| Inverse | Square n×n (n ≤ 5) | n×n | O(n³) | det = 0 → no inverse exists |
Addition and Subtraction
Both operations require A and B to have identical row and column counts. Each output element is simply C[i][j] = A[i][j] ± B[i][j]. These are the cheapest operations here, scaling as O(mn) with the number of elements — no special cases, no pivoting.
Multiplication
Multiplication is not commutative — AB ≠ BA in general, and BA may not even be defined when AB is. A 3×2 matrix times a 2×4 matrix yields a 3×4 result; swap the order and you're multiplying a 2×4 by a 3×2, which is undefined. The transpose product rule (AB)ᵀ = BᵀAᵀ is worth keeping in mind when transposing results back into column-major layout for GPU buffers.
Transpose
Aᵀ swaps row and column indices: element [i][j] moves to position [j][i]. Transpose always exists and costs O(mn). For orthogonal matrices — pure rotation matrices in 3D graphics, for instance — Aᵀ equals A⁻¹, which makes the transpose a free substitute for the much costlier matrix inverse in those specific cases.
Determinant
The determinant is a scalar encoding the volume-scaling factor of the linear transformation A represents. For a 3×3 matrix M = [[2.1, −0.5, 3.2], [1.9, 4.6, −1.1], [−0.3, 2.7, 1.4]], cofactor expansion along row 1 gives:
- 2.1 × (4.6 × 1.4 − (−1.1) × 2.7) = 2.1 × (6.44 + 2.97) = 2.1 × 9.41 = 19.761
- −(−0.5) × (1.9 × 1.4 − (−1.1) × (−0.3)) = 0.5 × (2.66 − 0.33) = 0.5 × 2.33 = 1.165
- 3.2 × (1.9 × 2.7 − 4.6 × (−0.3)) = 3.2 × (5.13 + 1.38) = 3.2 × 6.51 = 20.832
det(M) ≈ 19.761 + 1.165 + 20.832 = 41.758. A zero determinant means the matrix is singular: no inverse exists, the rows are linearly dependent, and the corresponding linear system has no unique solution.
| Step | Sub-matrix (2×2 minor) | Minor Value | Cofactor Sign | Contribution |
|---|---|---|---|---|
| Expand on M[0][0] = 2.1 | [[4.6, −1.1], [2.7, 1.4]] | 4.6×1.4 − (−1.1)×2.7 = 9.41 | + | 2.1 × 9.41 = 19.761 |
| Expand on M[0][1] = −0.5 | [[1.9, −1.1], [−0.3, 1.4]] | 1.9×1.4 − (−1.1)×(−0.3) = 2.33 | − | −(−0.5) × 2.33 = 1.165 |
| Expand on M[0][2] = 3.2 | [[1.9, 4.6], [−0.3, 2.7]] | 1.9×2.7 − 4.6×(−0.3) = 6.51 | + | 3.2 × 6.51 = 20.832 |
| Total | — | — | — | 41.758 |
Inverse
A⁻¹ exists if and only if det(A) ≠ 0. For a 2×2 matrix [[a, b], [c, d]], the inverse is (1/(ad−bc)) × [[d, −b], [−c, a]] — a direct formula. For 3×3 and larger, this tool uses LU decomposition with partial pivoting (the same strategy as LAPACK's dgetrf routine, described further in Linear Algebra for Developers: A Practical Guide). The result satisfies AA⁻¹ = I to within floating-point precision.
Common Use Cases in Development and Engineering
Graphics and game dev: transformation matrices
3D rotation, scaling, and translation are encoded as 4×4 homogeneous transform matrices — one of the most common matrix sizes in game development. Hand-coding a model-view-projection stack in GLSL or Metal makes it easy to get row-major vs. column-major ordering wrong, or to transpose a rotation when you shouldn't. Pasting the matrix values here and computing the inverse or product takes seconds, without opening Blender's Python console or adding a debug print to a Unity shader.
Machine learning: weight matrices and covariance
PCA requires computing a covariance matrix and verifying it's invertible before decomposing it into eigenvectors. A quick determinant check here confirms whether a sample covariance matrix is degenerate before running a full eigendecomposition. Checking that weight update matrices in a small toy network are well-conditioned can also save debugging time before porting to PyTorch.
Robotics and simulation: Denavit–Hartenberg matrices
Denavit–Hartenberg (DH) parameter matrices in robotics are typically 4×4. Each joint in a kinematic chain contributes one such matrix, and the end-effector pose is the product of all of them. Verifying an intermediate product — or confirming that a joint's rotation matrix has determinant exactly 1 — is faster in a browser tool than spinning up a ROS2 workspace.
Quick sanity-check during code review
Reviewing a PR that modifies a matrix inverse in a physics engine or a computer vision homography calculation? Paste in the sample matrix, compute the inverse here, and compare it to what the code produces. The turnaround is faster than writing a one-off test script, and the result format (JSON array or CSV) copies directly into a test assertion.
Edge Cases and Gotchas
Dimension mismatch errors
A 2×3 matrix cannot left-multiply another 2×3 matrix — the inner dimensions are 3 and 2, which don't match. The tool validates this before computing and displays a clear error: "Inner dimensions must match: A has 3 columns, B has 2 rows." Addition and subtraction require fully identical shapes; a 3×2 and a 2×3 are not interchangeable even though both have six elements.
Near-singular matrices and numerical instability
A determinant of 1×10⁻¹⁴ almost never means the matrix is mathematically singular — it usually means floating-point rounding during computation produced a near-zero result from a genuinely ill-conditioned matrix. The inverse in that case is numerically unreliable regardless. This tool surfaces a condition number warning badge whenever cond(A) exceeds 10¹², following the threshold used by LAPACK's condition estimator (dgecon). When you see that badge, switch to a higher-precision environment.
IEEE 754 floating-point rounding
JavaScript (and most hardware) stores numbers as IEEE 754 double-precision floats, giving approximately 15–17 significant decimal digits. The classic 0.1 + 0.2 = 0.30000000000000004 artifact propagates through matrix operations — after several multiplications and additions, trailing digits in the 14th–15th position can look alarming but are expected. The tool stores the full 64-bit float internally and displays six decimal places by default; toggling to full precision shows the raw double for debugging.
Integer vs decimal precision
Entering 3 and entering 3.0 are treated identically — both become the double-precision float 3.0. There is no integer arithmetic mode. For exact rational arithmetic (e.g., determinants that must come out exactly 0 for a known-singular matrix), this tool — like NumPy's default float64 — is not the right choice. Use a symbolic math library like SymPy instead.
Behind the Scenes: Algorithms and Complexity
Gaussian elimination with partial pivoting (LU decomposition)
Determinant and inverse both rely on LU decomposition: the matrix A is factored into a permutation matrix P, a lower-triangular matrix L, and an upper-triangular matrix U such that PA = LU. This mirrors the strategy behind LAPACK's dgetrf routine, reimplemented here in JavaScript. Partial pivoting swaps rows at each elimination step to place the largest absolute value in the pivot position, reducing round-off error accumulation. Per the LAPACK Users' Guide (3rd ed.), dgetrf computes the PLU factorization using partial pivoting with row interchanges.
Complexity: O(n³) for multiplication and inversion
Both naive matrix multiplication and LU decomposition scale as O(n³). For the matrix sizes this tool handles (n ≤ 5), that means at most 125 floating-point multiply-add operations for multiplication and a similar count for LU. Strassen's algorithm reduces this to roughly O(n^2.807), but its constant factor and implementation complexity are not justified below n ≈ 100 — so this tool uses the straightforward row-column dot product loop.
| Matrix Size (n×n) | Multiplication (n³) | Determinant/Inverse (n³) | Transpose (n²) | Addition (n²) |
|---|---|---|---|---|
| 2×2 | 8 | 8 | 4 | 4 |
| 3×3 | 27 | 27 | 9 | 9 |
| 4×4 | 64 | 64 | 16 | 16 |
| 5×5 | 125 | 125 | 25 | 25 |
Cofactor expansion vs LU for small matrices
For 2×2 matrices, the determinant is computed directly as ad − bc, bypassing LU entirely. This avoids pivoting overhead and produces an exact symbolic expression. For 3×3 and above, LU decomposition is more numerically stable than recursive cofactor expansion because partial pivoting controls error growth — cofactor expansion can amplify rounding errors in ill-conditioned cases.
Numerical stability reference to LAPACK
The JavaScript implementation here mirrors the pivoting strategy of LAPACK's dgetrf but does not replicate LAPACK's full error-bound machinery. For matrices where the condition number stays below 10⁸, results match NumPy's numpy.linalg.det and numpy.linalg.inv to at least 10 significant figures in testing. Beyond that range, use a proper numerical library.
This Tool vs NumPy vs MATLAB vs Wolfram Alpha
No browser tool replaces a full numerical computing environment. The right choice depends on what you're actually doing.
When to use this tool
Reach for this calculator when working with 1–5 small matrices (up to 5×5) during design, code review, or debugging. There's no install, no authentication, no environment setup, and results appear within seconds of opening the page. After the first visit, the service worker keeps it available offline.
When to reach for NumPy/SciPy
NumPy is the right choice when matrix operations are part of a data pipeline, arrays exceed 5×5, you need batch processing across hundreds of matrices, or you need operations this tool doesn't cover — SVD, eigendecomposition, sparse matrix support. numpy.linalg wraps LAPACK directly and handles arbitrarily large arrays with BLAS-accelerated DGEMM routines.
When MATLAB or Wolfram Alpha is appropriate
MATLAB makes sense for control-systems work (Simulink integration), signal processing, and symbolic math alongside numerical computation. Wolfram Alpha handles symbolic determinants with variable entries — if your matrix contains unknowns like x or λ, Wolfram Alpha can compute an algebraic expression for the determinant, which no numerical tool can do.
| Tool | Install Required | Max Practical Matrix Size | Symbolic Support | Batch Processing | Offline Support |
|---|---|---|---|---|---|
| ThisDevTool | No | 5×5 (det/inv); larger for add/multiply | No | No | Yes (service worker) |
| NumPy / SciPy | Yes (Python + pip) | Memory-limited (10,000×10,000+) | No (use SymPy) | Yes | Yes |
| MATLAB | Yes (license required) | Memory-limited | Partial (Symbolic Toolbox) | Yes | Yes |
| Wolfram Alpha | No (web-based) | ~10×10 practical | Yes | No | No |
Related Tools
These calculators handle operations that extend naturally from matrix arithmetic: