Matrix Calculator

Matrix Operations You Actually Use

Most working developers touch matrices in three places: graphics (every transform in 2D/3D), robotics/physics (state and pose), and the occasional ML or signal-processing detour. For those use cases, 2×2 and 3×3 cover almost everything. Big matrices belong in NumPy. Small matrices belong on a whiteboard, or here, when the whiteboard isn't handy and you want to verify your math before committing it.

The Operations and What They Mean Geometrically

Addition / Subtraction. Element-wise. Geometrically, adding matrix B to matrix A doesn't combine transforms, for that you multiply. Addition is meaningful when matrices represent state (positions, velocities) rather than transformations.

Scalar Multiplication. Multiplies every entry by the same number. Doubles every effect, a transformation that rotates by 45° doesn't suddenly rotate by 90° (rotation isn't linear in that sense), but a scaling matrix that scales by 2 becomes a scaling by 4.

Matrix Multiplication. The big one. C = A·B means "apply B first, then apply A." The output C is a single transform equivalent to the composite. This is how you assemble model-view-projection matrices in graphics: MVP = P·V·M, applied right-to-left to a vertex.

Transpose. Flip across the main diagonal. For rotation matrices specifically, transpose equals inverse, which is why rotation inverses are trivially fast. In general matrices, transpose is just bookkeeping (often needed when going row-major ↔ column-major between APIs).

Determinant. A single number summarizing how a transformation scales volume.

• det = 1 → area-preserving (pure rotations, shears with the right diagonals).
• det = 2 → doubles area.
• det = 0 → collapses to a lower dimension; the matrix is singular (no inverse exists).
• det = -1 → preserves area but flips orientation (reflection).

If your transform mysteriously inverts your scene, check whether you've introduced a negative determinant somewhere.

The 2×2 Case: 2D Linear Transforms

Any 2×2 matrix is a 2D linear transformation: rotation, scale, shear, reflection, or any combination. The four entries:

• a and d are the x- and y-scale.
• b is the x-component when y moves (shear).
• c is the y-component when x moves.

Pure rotation by angle θ:

Pure scale by (sx, sy):

Multiply them: scale-then-rotate vs rotate-then-scale produce visibly different results. Try it in the calculator.

The 3×3 Case: Two Roles

A 3×3 matrix means one of two things depending on context:

1. A 2D affine transform in homogeneous coordinates. Points are (x, y, 1); the bottom-right corner of the matrix handles translation. This is what 2D graphics APIs (Canvas, SVG, CSS transforms) use under the hood.

2. A 3D linear transform. Rotations, scales, shears in 3D. No translation, for that you need 4×4 in 3D (same homogeneous trick, one dimension up).

Rotation by θ around the z-axis (3D):

The 1 in the corner means "z unchanged."

Determinant by Cofactor Expansion (3×3)

For matrix:

Determinant = a(ei − fh) − b(di − fg) + c(dh − eg).

The sign alternation (+, −, +) is the cofactor sign pattern. This is the method the calculator uses; it matches textbook expectations and produces correct results to floating-point precision.

For 4×4 and larger, cofactor expansion becomes O(n!), astronomically slow. Real libraries use LU decomposition (O(n³)). For 3×3, cofactor expansion is fine.

Numerical Precision: Where Things Go Wrong

The calculator uses IEEE 754 double-precision floats (the standard JavaScript number type). About 15-17 significant decimal digits. Operations are exact up to that precision.

Where it bites:

• Determinants near zero. A matrix with determinant 1e-16 is, for all practical purposes, singular, but floating-point may compute a nonzero value, hiding the singularity.
• Multiplying many transforms. Each multiplication introduces a tiny error; after dozens of matrix multiplications (e.g., in skeletal animation), error accumulates. Mitigation: periodically renormalize, or use higher-precision libraries.
• Catastrophic cancellation. Computing ad − bc when ad and bc are huge and nearly equal loses precision. Rare in 2×2/3×3 cases, common in larger numerical algorithms.

For graphics work, these almost never matter. For numerical analysis homework or scientific computing, use a proper linear algebra library that handles conditioning.

Common Use Cases

Sanity-checking a graphics transform. "Should the scale-then-rotate matrix have this third row?" Plug in values, see the answer.

Linear algebra homework. Compute the determinant, verify your hand calculation, identify where you went wrong if not.

Coding interview prep. Rotation matrices come up in unexpected places (image rotation by 90°, encoding spiral matrix order). Refreshing the math here is faster than opening Khan Academy.

Robotics pose verification. Robot end-effector pose composed of joint rotations, does the final 3×3 rotation match expectation? Plug in and check.

Cross-language verification. When porting math from MATLAB to TypeScript, this is a small sandbox for "do I get the same answer here as I did there."

What's NOT Here

• Matrix inverse. For 2×2, easy (1/det · [[d,-b],[-c,a]]); for 3×3, painful by hand. Use NumPy or Wolfram.
• Eigenvalues/eigenvectors. Closed-form for 2×2 is doable, 3×3 is the cubic-roots problem. Use a CAS.
• Systems of equations. Gaussian elimination is straightforward but needs more UI than this tool's grid.
• Larger matrices. Hand calculation stops being useful past 3×3.

For those, the right answer is "open a Python REPL with NumPy." For everything covered above, this tool is faster.

Privacy

Six lines of arithmetic, running in your browser. Matrix data never leaves the tab. Open DevTools Network during a calculation: zero outbound requests.