Matrices and matrix multiplication

Every time a BIM tool moves, rotates, scales or mirrors something, it multiplies coordinates by a matrix: a rectangular grid of numbers. One matrix holds the whole recipe, so the same few lines of code can place a door, rotate a building footprint or turn model coordinates into screen pixels.

A 2×2 matrix acts on 2D points. Pick a preset or move the four sliders, and watch the grid, the “F” and the point P all move together.

A matrix times a point

Write the matrix with entries a, c on the top row and b, d on the bottom row, and the point P = (x, y) as a column. Then x′ = a·x + c·y and y′ = b·x + d·y: each output is one row of the matrix dotted with the point.

There is a more useful way to read the same sum: M·P = x × (first column) + y × (second column). The point (1, 0) lands on the first column and (0, 1) on the second. So the columns are where the X and Y axes go, and every other point follows, because it is a mix of the two axes. That is what the green and purple arrows in the widget show, and it is how you can write down a matrix just by thinking about where the axes should end up.

Multiplying two matrices

To do one transform and then another, multiply their matrices. Entry (i, j) of A·B is row i of A dotted with column j of B. The sizes must fit: an m×n matrix can multiply an n×p one, and the result is m×p. A point written as a column is just an n×1 matrix, so the same function handles both.

1double[,] rotate90 = { { 0, -1 }, { 1, 0 } };2double[,] stretchX = { { 2, 0 }, { 0, 1 } };3 4Print("Stretch, then rotate (R * S)", Multiply(rotate90, stretchX));5Print("Rotate, then stretch (S * R)", Multiply(stretchX, rotate90));6 7double[,] p = { { 1 }, { 1 } };          // the point (1, 1) as a 2x1 column8Print("(R * S) * p", Multiply(Multiply(rotate90, stretchX), p));9 10static double[,] Multiply(double[,] a, double[,] b)11{12    int n = a.GetLength(0), m = a.GetLength(1), q = b.GetLength(1);13    if (b.GetLength(0) != m)14        throw new ArgumentException($"Cannot multiply {n}x{m} by {b.GetLength(0)}x{q}");15    var c = new double[n, q];16    for (int i = 0; i < n; i++)17        for (int j = 0; j < q; j++)18            for (int k = 0; k < m; k++)19                c[i, j] += a[i, k] * b[k, j];      // row i of a, dotted with column j of b20    return c;21}22 23static void Print(string title, double[,] m)24{25    Console.WriteLine(title + ":");26    for (int i = 0; i < m.GetLength(0); i++)27    {28        var row = new string[m.GetLength(1)];29        for (int j = 0; j < row.Length; j++) row[j] = m[i, j].ToString("0.###").PadLeft(3);30        Console.WriteLine("  [" + string.Join(" ", row) + " ]");31    }32}

Stretch, then rotate (R * S):
  [  0  -1 ]
  [  2   0 ]
Rotate, then stretch (S * R):
  [  0  -2 ]
  [  1   0 ]
(R * S) * p:
  [ -1 ]
  [  2 ]

The two products are different matrices. Matrix multiplication is not commutative: A·B is usually not B·A, just as “stretch, then rotate” is not “rotate, then stretch”. It is, however, associative: (A·B)·C = A·(B·C). That is what lets a program multiply a long chain of transforms into one matrix once, then apply that single matrix to thousands of points.

The determinant

For a 2×2 matrix, det = a·d − b·c. It is the factor by which the matrix scales every area: the unit square becomes a parallelogram of area |det|, and every room, slab and hatch scales the same way. The sign carries meaning too:

• det > 0: shapes keep their orientation. Rotations have det = 1, so they keep areas exactly.
• det < 0: the transform includes a mirror. Outlines reverse their winding, and an “F” reads backwards.
• det = 0: the plane is squashed onto a line (or a point). Areas become 0, and the matrix has no inverse: you cannot undo it.

1var room = new V2[] { new(0, 0), new(6, 0), new(6, 4), new(0, 4) };2var matrices = new (string Name, double A, double B, double C, double D)[]3{4    ("Scale x2", 2, 0, 0, 2),5    ("Shear 0.5", 1, 0, 0.5, 1),6    ("Mirror in Y", -1, 0, 0, 1),7    ("Squash", 1, 0.5, 2, 1)8};9 10Console.WriteLine($"Room: {Area(room)} m2");11foreach (var (name, a, b, c, d) in matrices)12{13    var moved = room.Select(p => new V2(a * p.X + c * p.Y, b * p.X + d * p.Y)).ToArray();14    Console.WriteLine($"{name,-12} det {a * d - b * c,3}   signed area {Area(moved),4} m2");15}16 17static double Area(V2[] p)18{19    double s = 0;20    for (int i = 0; i < p.Length; i++)21    {22        V2 u = p[i], v = p[(i + 1) % p.Length];23        s += u.X * v.Y - v.X * u.Y;24    }25    return s / 2;26}27 28readonly record struct V2(double X, double Y)29{30    public static V2 operator +(V2 a, V2 b) => new(a.X + b.X, a.Y + b.Y);31    public static V2 operator -(V2 a, V2 b) => new(a.X - b.X, a.Y - b.Y);32    public static V2 operator *(V2 v, double k) => new(v.X * k, v.Y * k);33    public double Length => Math.Sqrt(X * X + Y * Y);34    static string F(double v) => Math.Abs(v) < 5e-4 ? "0" : v.ToString("0.###");35    public override string ToString() => $"({F(X)}, {F(Y)})";36}

Room: 24 m2
Scale x2     det   4   signed area   96 m2
Shear 0.5    det   1   signed area   24 m2
Mirror in Y  det  -1   signed area  -24 m2
Squash       det   0   signed area    0 m2

Every signed area is exactly det × 24. The mirror gives −24: the same size, but the corners now run clockwise, which is the shoelace formula’s way of saying “mirrored”.

1double c30 = Math.Cos(Math.PI / 6), s30 = Math.Sin(Math.PI / 6);2var tests = new (string Name, double A, double B, double C, double D)[]3{4    ("Rotate 30", c30, s30, -s30, c30),5    ("Drawing 1:100", 0.01, 0, 0, 0.01),6    ("Mirror in X", 1, 0, 0, -1),7    ("Columns (1,0.5) (2,1)", 1, 0.5, 2, 1),8    ("Shear", 1, 0, 0.5, 1)9};10 11foreach (var (name, a, b, c, d) in tests)12{13    double det = Det2(a, b, c, d);14    string kind =15        Math.Abs(det) < 1e-9 ? "squashes onto a line, no inverse" :16        det < 0 ? $"mirrors, areas x {Math.Abs(det):0.####}" :17        Math.Abs(det - 1) < 1e-9 ? "keeps areas" :18        $"scales areas by {det:0.####}";19    Console.WriteLine($"{name}: {kind}");20}21 22static double Det2(double a, double b, double c, double d) => a * d - b * c;

Rotate 30: keeps areas
Drawing 1:100: scales areas by 0.0001
Mirror in X: mirrors, areas x 1
Columns (1,0.5) (2,1): squashes onto a line, no inverse
Shear: keeps areas