How to organize, add and multiply matrices - Bill Shillito

Translator: Andrea McDonough Reviewer: Bedirhan Cinar

By now, I'm sure you know

that in just about anything you do in life,

you need numbers.

In particular, though,

some fields don't just need a few numbers,

they need lots of them.

How do you keep track of all those numbers?

Well, mathematicians dating back

as early as ancient China

came up with a way to represent

arrays of many numbers at once.

Nowadays we call such an array a "matrix,"

and many of them hanging out together, "matrices".

Matrices are everywhere.

They are all around us,

even now in this very room.

Sorry, let's get back on track.

Matrices really are everywhere, though.

They are used in business,

economics,

cryptography,

physics,

electronics,

and computer graphics.

One reason matrices are so cool

is that we can pack so much information into them

and then turn a huge series of different problems

into one single problem.

So, to use matrices, we need to learn how they work.

It turns out, you can treat matrices

just like regular numbers.

You can add them,

subtract them,

even multiply them.

You can't divide them,

but that's a rabbit hole of its own.

Adding matrices is pretty simple.

All you have to do is add the corresponding entries

in the order they come.

So the first entries get added together,

the second entries,

the third,

all the way down.

Of course, your matrices have to be the same size,

but that's pretty intuitive anyway.

You can also multiply the whole matrix

by a number, called a scalar.

Just multiply every entry by that number.

But wait, there's more!

You can actually multiply one matrix by another matrix.

It's not like adding them, though,

where you do it entry by entry.

It's more unique

and pretty cool once you get the hang of it.

Here's how it works.

Let's say you have two matrices.

Let's make them both two by two,

meaning two rows by two columns.

Write the first matrix to the left

and the second matrix goes next to it

and translated up a bit,

kind of like we are making a table.

The product we get when we multiply the matrices together

will go right between them.

We'll also draw some gridlines to help us along.

Now, look at the first row of the first matrix

and the first column of the second matrix.

See how there's two numbers in each?

Multiply the first number in the row

by the first number in the column:

1 times 2 is 2.

Now do the next ones:

3 times 3 is 9.

Now add them up:

2 plus 9 is 11.

Let's put that number in the top-left position

so that it matches up with the rows and columns

we used to get it.

See how that works?

You can do the same thing to get the other entries.

-4 plus 0 is -4.

4 plus -3 is 1.

-8 plus 0 is -8.

So, here's your answer.

Not all that bad, is it?

There's one catch, though.

Just like with addition,

your matrices have to be the right size.

Look at these two matrices.

2 times 8 is 16.

3 times 4 is 12.

3 times

wait a minute,

there are no more rows in the second matrix.

We ran out of room.

So, these matrices can't be multiplied.

The number of columns in the first matrix

has to be the same as the number of rows in the second matrix.

As long as you're careful

to match up your dimensions right, though,

it's pretty easy.

Understanding matrix multiplication

is just the beginning, by the way.

There's so much you can do with them.

For example, let's say you want

to encrypt a secret message.

Let's say it's "Math rules".

Though, why anybody would want to keep this a secret

is beyond me.

Letting numbers stand for letters,

you can put the numbers in a matrix

and then an encryption key in another.

Multiply them together

and you've got a new encoded matrix.

The only way to decode the new matrix

and read the message

is to have the key,

that second matrix.

There's even a branch of mathematics

that uses matrices constantly,

called Linear Algebra.

If you ever get a chance to study Linear Algebra,

do it, it's pretty awesome.

But just remember,

once you know how to use matrices,

you can do pretty much anything.