Lesson 2.6: Arithmetic Part 2 - MATLAB Video Lecture | Introduction to Programming with MATLAB - IT & Software

[MUSIC]
There’re two types of division, the so-called
“matrix division”, and “array division”.
We're going to take up
array division first.
And there are two types of array division.
Here's how you divide X and Y.
First of all, there's X./Y,
and then there's the X.\Y.
In the first case, it kind of looks
like X is over Y, so that's X over Y.
And the other one sort of looks like X is
under Y, so we'll call that X under Y.
And we'll explain what both of those mean.
Here's an example.
You see an X and a Y.
They're both the same shape and size.
That's required for array division.
And now,
let's suppose we use that first example,
X./Y, X over Y, and put that in Z.
So what does Z look like?
Well, over on the right side,
we see X written out and
Y written out,
separated by the dot slash operation.
And over on the left, we see the result.
Let's look at the first
element on the top row.
We see 1 slash 2.
Over on the right, we see a 1 and
a 2 in those positions.
So 1 divided by 2 equals 1 over 2,
and that's what we get for Z.
Of course, MATLAB will carry that out and
give you 0.5.
Every single one of the elements
in Z is equal to the corresponding
element in X divided by the corresponding
element in Y, and that's what dot slash Y means.
Here's what it looks like,
the results, in MATLAB,
when all these divisions are carried out.
And when they're assigned to Z,
this is what Z looks like.
No surprise there.
And what about the backslash case?
Well, everything's the same except that 1,
instead of being divided
by 2, is divided into 2.
This is the 1 under the 2 case.
So 1 under 2,
what do you think that's going to be?
Well, it's 2 instead of one-half.
1 goes into 2 two times.
Same thing happens for
every element at every position.
Here's 1 over 2.
I mean, here's 1 under 2, and
we're showing you that
it's the same as 2 over 1.
And here, the number is carried
out to four decimal places, and
here's what you see when
it's assigned to Z.
You should try some examples of your
own to get used to this array division,
but don't forget the dot.
If you leave the dot out,
then you are in a strange new
territory called “matrix division”.
Matrix division has
different rules completely.
In fact, it's quite
a complicated concept in
linear algebra, and
we're not covering it here.
But if you want to check it out,
you can try the advanced concepts
in the textbook and
get a detailed explanation.
Now, let's look at exponentiation.
2 caret 3.
The caret is the exponentiation operator,
and 2 to the 3rd power is what that means.
2 to the 3rd power is 8.
Not surprising.
But what might be surprising
is that you can do
exponentiation operation with arrays.
Array exponentiation works sort
of like array multiplication.
At least the rules are the same.
Let's look at X, 1, 2; 3, 4.
And let's let N equal
6, 0.5; -1, 2,
x dot caret N is the array
exponentiation operation.
The dot means array exponentiation,
just like the dot means array
multiplication when we have dot star.
And let's look at the result.
What this means is the first
element of X on the first row, 1, is
raised to the first element
on the first row of N.
So 1 to the 6th power of course is 1.
The second element on the first row of X
is raised to the power of the second
element on the first row of N.
So we have 2 raise to the 1/2 power.
Well, that's the square root of 2.
Down here,
we have 3 raised to the -1 power.
Well, that's 1/3, and
4 raised to the 2 power, which is 16.
So that's array exponentiation.
There's no real surprises there.
As you may have guessed,
if we go to matrix exponentiation,
things are going to be more complicated,
just like they were more complicated
when we went from array multiplication
to matrix multiplication.
We'll only cover one case, and
that's the case in which the second
operand is actually a scalar.
Let's do that.
X matrix-exponentiation 3.
What this means is X is
multiplied by itself
using matrix multiplication three times.
So it's the same as this:
X times X times X,
and you can see you get the same result.
It's not possible to raise to X to a power
like this, unless X is a square matrix.
That's true because, as you may
remember for matrix multiplication,
the width of the first matrix has to be
equal to the height of the second matrix.
Since both these matrices are X,
that means the width of X has
to be equal to the height of X.
And that's the definition
of a square matrix.
We've seen that there are strict
rules on the sizes, and shapes of
the operands for both array and
matrix operations.
For array operations, the matrices
must have the same size and shape,
while for matrix operations the width of
the first matrix must equal the height of
the second one.
Now, we're going to see that MATLAB waives
these rules when one operand is a scalar.
We'll show how it works
with some examples.
I'm going to gin up
a couple of matrices first.
Here's my favorite, [CLICKING] and
it's so easy to type.
And another one.
[CLICKING] Just picking
some random digits here.
And we'll start with addition.
You’ll remember that the addition of
two matrices requires that they have
the same size and shape.
A and B here are both 2 by 3,
so we can add them.
And let's do it.
[CLICKING] There, no problem.
But we can violate the same-size-and-shape
rule if one operand is a scalar.
So let's do that one.
[CLICKING] There.
I've got the matrix A which is 2 by 3,
and I've added a scalar, which by
the way is a matrix that's 1 by 1.
And 2 by 3 doesn’t match 1 by 1,
but no error message.
And what happened?
Well, you can see here, if we look at A,
the first element is a 1.
We've added a 3 to that 1 to get a 4.
Second element on the first row is a 2.
We've added a 3 to that,
we've added a 3 to every one of them.
And that's the general idea for
any arithmetic operation that
mixes a scalar and a matrix.
The operation is repeated for each element
using the scalar as one of the operands.
And the scalar can come first or
second as for example [CLICKING] there.
Which, as you would expect,
does the same thing as A plus 3.
Let's do some more examples.
A minus 1 subtracts 1 from each element.
2 dot star A multiplies each element by 2.
2 star A,
the matrix multiplication version,
does the same thing.
And we can divide too. Let's see, A./2,
array division of A by 2,
divides each element by 2.
.
And you can go the other way:
.
2./A [CLICKING] divides
each element of A into 2.
.
The matrix versions of
division with a scalar and
.
a matrix don't work though,
so 2, say, divided by A.
.
MATLAB that doesn't like that.
.
And A under 2,
also gives an error.
Finally, the array version of
exponentiation works as you might
expect it to.
A dot caret 2 applies that exponent, 2,
to each element of A, so
it squares each element.
And it works the other direction too.
Let's look at A again so
we can remember what's in there.
Here, we have 2 because we've
raised 2 to the 1 power here.
Here, we have 4 because we've
raised 2 to the 2 power.
You have an 8 because we've
raised 2 to the 3 power, and so
on until we get all the way
down here to 64,
which is 2 raised
to the 6th power
.
So array exponentiation
works fine with a scalar.
But as we've just seen,
the matrix version
of exponentiation
is kind of picky
.
A caret 2 is no good
unless A is square,
…
and of course,
A is 2 by 3, so
it's not square
.
All these special cases with scalars
may require a little memorization.
It's just like idioms in
a spoken language, but
very little memorization for two reasons.
First, the cases of addition, subtraction
and multiplication work exactly the same
as they do in ordinary
mathematical calculations.
So you might be familiar
with them already.
And second, you can always try out
unfamiliar cases on small examples to
see whether they work, and what they do.
That's what I do.
[MUSIC]
[APPLAUSE]