## Matrices for programmers

Following the fine tradition of the colour theory post, you are getting another crash course. This time, a lesson in matrices. You’re going to be fine. And yes, I’ll hold your hand while you do this. *smile*

For those who are mathematically inclined, we’ll be working in the realm of real numbers (which I talked about briefly when discussing floating points). Let’s start with…

### Scalars

Scalars are simply numbers. For example, 2 is a scalar. So is 3.14159 and 1.618. And so is -273.15. Bonus points if you can figure out what those numbers are special for.

Scalars are stored as normal variables in code. Your `int`

s, `float`

s, `double`

s come in handy.

Scalars are typically denoted by a lowercase alphabet, such as a or b or c.

### Vectors

Vectors are series of scalars. For example, [1 3 5 7 9] is a vector.

You typically store vectors as an array. For example,

int[] v = new int[] { 1, 3, 5, 7, 9 };

Vectors are typically denoted by a lowercase alphabet in bold, such as **v**.

### Matrices

Matrices are series of series of scalars, or series of vectors. In code, they are typically stored as an array of arrays.

int[,] A = new int[3, 3];

Matrices are also known as *multidimensional arrays*. The *dimension* of a matrix is m-by-n, where m is the number of rows and n is the number of columns.

When either m or n is 1, we get a vector. So a vector is a special case of a matrix. And because of this, we have to define…

### Row and column vectors

It’s easier to just show you how they look like.

A *row vector* is a matrix where the number of rows is 1. A *column vector* is a matrix where the number of columns is 1. While we’re at it, a scalar can be thought of as a matrix where the number of rows and columns are both 1.

For our purposes of working towards 3D programming, we’ll be focusing on the column vector. It doesn’t matter which one we use when coding, but in terms of notation, we’ll be using column vectors. You will see why later on.

### Matrix entries

Individual entries are referred to with the notation A[i,j] (or a_{i,j}) where A is the matrix, i is the i-th row and j is the j-th column. Typically, we have

1 <= i <= m and 1 <= j <= n, where m is the number of rows and n is the number of columns.
Take note, because you'll be using them in code. So know how your programming language does indices of arrays. If your language starts with the 0-th element, make sure to shift positions by one less. Then you have
0 <= i <= m-1 and 0 <= j <= n-1.
The 0 index has tripped many a programmer, so be careful.

### Square matrices

This is a special case where both the number of rows and number of columns are equal. For example, a 3 by 3 matrix, or a 4 by 4 matrix.

In a stroke of coincidence, we will also be focusing on 3 by 3 and 4 by 4 matrices. Hint: It’s because we’re working in 3D.

### Identity matrix

In math, there is a number such that when you multiply anything by it, you get back the same thing. It’s the number 1. For example, 8 * 1 = 1 * 8 = 8.

We have the same concept for matrices. There is a matrix such that when you multiply any matrix by it, you get the same original matrix back. It’s called the identity matrix, typically denoted by an uppercase “I”.

We’ll look at matrix operations soon.

### Zero matrix

You know that multiplication unity described above when defining the identity matrix? Guess what, there’s a number such that when you add anything to it, you get back the same thing. It’s the number 0. For example, 8 + 0 = 0 + 8 = 8.

Similarly, we have the zero matrix. It’s simply a matrix with zeroes in all its entries. It’s denoted by a big gigantic 0. Probably not quite useful to you, but nevertheless, you now know something more.

### Symmetrical matrices

Symmetrical matrices are symmetrical about the *diagonal*. Where’s the diagonal? Look at this:

For a 3 by 3 matrix with values:

a b c

d e f

g h i

Entries a, e and i form the diagonal. Notation wise, A[i,i] are the *diagonal entries*.

If a matrix has zeroes in entries below the diagonal, it’s known as an upper triangular matrix. In our case, d = g = h = 0.

Similarly, if a matrix has zeroes in entries above the diagonal, it’s known as a lower triangular matrix. In our case, b = c = f = 0.

What symmetry means in this case is b=d, c=g and f=h. The general formula is

A[i,j] = A[j,i]

To speed up computations when checking symmetry, some algorithms use

A[i,j] = A[j,i], where i < j
The extra condition leaves out the diagonal and entries below the diagonal. No point double checking values, right?

### Transpose of a matrix

Now that we know what a symmetrical matrix and its diagonal, we can define the transpose of a matrix. What you do is simply flip the matrix about its diagonal.

For a matrix A whose values are:

a b c

d e f

g h i

Its transpose is:

a d g

b e h

c f i

The transpose of a matrix A is denoted by A^{T}. So if A = A^{T}, A is a symmetrical matrix.

Yes, we’re dealing with square matrices. Rectangular matrices aren’t useful for our purposes in 3D programming, and you’re welcome to research on its practical uses (try “operations research“).

### The inverse of a matrix

The inverse of a square matrix A is denoted by A^{-1}, where

AA^{-1} = A^{-1}A = I

Yes, I know I still haven’t covered matrix multiplication. Just go with it a little longer…

For a matrix product AB, it’s inverse is

(AB)^{-1} = B^{-1}A^{-1}

Then this looks beautiful:

(AB)^{-1}AB

= B^{-1}A^{-1}AB

= B^{-1}IB

= B^{-1}B

= I

Don’t you think that looks beautiful? *smile*

### Matrix equality

Matrices A and B are said to be equal if every corresponding entry of both matrices are equal. In notation, A[i,j] = B[i,j] for all i and j.

### Matrix addition (and subtraction)

A matrix C is said to be the sum of matrices A and B if

C[i,j] = A[i,j] + B[i,j] for all i and j.

Subtraction is similar. Let me show you a scalar example.

8 – 5 = 8 + (-5)

Same thing for matrices. The negative sign is “pushed in” to individual entries.

### Matrix multiplication by scalar

Let’s multiply matrices by scalars first. It’s easy.

Just multiply the scalar with all the entries in the matrix.

### Matrix multiplication by vector

This one’s a little more complicated. For our purposes, we are concerned with multiplying a matrix A by a column vector **v**. Yes, the order and the type of vector matters. Let’s look at a diagram.

The result is a column vector. Suppose we multiply matrix A by column vector **x** and we get a column vector **y**, the general formula is

y[i] = A[i,0] * x[0] + A[i,1] * x[1] + … + A[i,n] * x[n]

It actually looks much more concise if I can use the summation notation… BUT, I’m trying to simplify things for you. Hopefully, you can visualise how it works with the diagram. I’ll write another post with code to explain this.

You can’t multiply a matrix by a row vector though. Hopefully through the diagram, you’ll see why it doesn’t work. What happens is, you multiply each row of the matrix by the values *down* the column vector. Since a row vector only has one value “down the column”, it doesn’t make sense to multiply matrices by row vectors.

You can multiply a row vector by a matrix to get a row vector. But it’s not useful for our purposes. If you understand a little about 3D transformations, then A is a transformation matrix, and x is a vertex. For example, A could be a translation matrix and moves x to point y. If you don’t understand any of this, relax, we’ll get there together soon.

### Matrix and matrix multiplication

This is complicated to show and explain, but once you get the idea, it’s actually easy to code.

I’ll leave it to you to figure out the general formula… It’s similar to the one with matrix by vector multiplication, only with more vectors. *smile* This is what I do in university, write out a’s and subscripts, and summation notations in my lecture notes and tutorial questions…

I’ll write another post explaining this (together with the matrix by vector multiplication) with code to illustrate the use.

In terms of 3D transformations, you could have a bunch of transformations done, say you rotate something, then translate (move) it. So you have something like TRx, where R is the rotation matrix, T is the translation matrix and x is the vertex.

Note the order. The earlier (in order) a transformation is done, the closer it is to the vertex in question. Basically you reverse the order of transformations when implementing.

Since we’re at it, matrix multiplications are *not* commutative. What it means is that

AB != BA

The order is important.

As an exercise, visualise the difference between moving something then rotate, and rotate then move.

### End of crash course

Whew… *wipe sweat* How’re you doing? Still with me?

Good. This sets the foundation you need for understanding 3D programming. Yay! Review what you’ve read, do some research if needed, and I’ll see you next time.