On Rotation Matrices

A common problem you come across is GIVEN a vector describing a “look” direction, HOW CAN WE MAKE A ROTATION MATRIX THAT WILL “LINE UP” WITH IT? You often want to do something like this when you have a character model that you need to rotate to line up with the direction that the character is currently facing. For example, you are writing a 3d space simulator game and you need the ship’s model to be lined up precisely with the direction the ship is facing.

It turns out, this is easy to do. So easy to do in fact, you’ll kick yourself for not having known this. But it isn’t easy to understand how it works.

So, first, let’s understand the principles of what we’re doing here in 2d, then we’ll extend our answer to 3d.

Rotating something to line up with an object in 2d

Assume you work in a world of vectors. In your 2d game, you need to have the model of your character point in the direction that he is looking.

Have: (red arrow is direction the Triangle character is looking).

But the black triangle and black arrow indicate the stock direction the model faces.

Want:

The most obvious way to solve this problem is just a 2d rotation matrix.

Matrix that rotates a point t degrees counter-clockwise:

The Triangle starts with its Heading vector pointing (1, 0). What we need to do is rotate the Heading vector 60 degrees counter-clockwise.

To make a 60 degree CCW rotation, let’s use the CCW rotation matrix, plugging in 60 degrees for the rotation we want:

So we end up with this set of numbers that promise to rotate a set of points 60 degrees counterclockwise:

Now here’s another way to get that same matrix. Are you ready?

The red vector (which points in the direction we want to face) is called the forward vector. The blue vector, we’ll simply call the side vector. ASSUME BOTH THE forward AND side vectors are UNIT VECTORS (THIS IS VERY IMPORTANT!!)

Since we know the forward vector is a unit vector and it has a 60 degree angle with the x-axis, we can express it as:
x_fwd = cos( 60 )
= 0.5

y_fwd = sin( 60 )
= 0.86

So a unit vector in the plane, when broken down into its x, y components, is always going to be x=cos(t), y=sin(t) where t is the angle that the vector forms with the +x axis.

The blue vector makes (90+60=150) degree angle with the +x axis. So it can be expressed as:
x_perpleft = cos( 150 )
= -0.86

y_perpleft = sin( 150 )
= 0.5

So, speaking in terms of the orientation we want, we have two vectors:

forward (describes direction we want to look in)=( 0.5, 0.86 )
perpleft (90 degrees counter-clockwise perpendicular to the forward vector) = ( -0.86, 0.5 )

We could also derive the perpleft vector by noticing that ( -y, x ) is always going to be a 90 degree counter-clockwise rotated perpendicular to any vector you have.

side note:
You are sure that (-y,x) is a perpendicular to (x,y) because the dot product:
(x,y)*(-y,x) = -yx + xy = 0

and so, (-y,x) is always perpendicular to (x,y).

The other way to derive this is to construct the 90 degree CCW rotation matrix and notice that it always comes out to

[ cos(90)   -sin(90) ] [ x ]
[ sin(90)    cos(90) ] [ y ]

[ 0   -1 ] [ x ] = [ -y ]
[ 1    0 ] [ y ]   [  x ]

So, look at those again:

forward: ( 0.5, 0.86 )
perpleft: ( -0.86, 0.5 )

Does that look familiar?

So we can do this:

Assuming you use column vectors and not row vectors. If you’re using row vectors, you have to transpose it.

Isn’t that neat?

This extends to 3D:

At this point, I’ll direct you to Diana Gruber’s article and leave it at that.

Say you come across

What you do is
break it up

Here’s a great link to the purple math site (a great site).

Matlab plot syntax is easy to use but apparently easy to forget.

Here I’m plotting the line y = x² from x = -20 to +20.

% generate x, y vectors
x = -20:0.01:20;   % x goes from -20 to 20 in steps of 0.01
y = x.^2;            % generate y
plot(x,y);

Hmm the plot would be easier to see if it had grid lines drawn in.

% generate x, y vectors
x = -20:0.01:20;   % x goes from -20 to 20 in steps of 0.01
y = x.^2;            % generate y
plot(x,y);
grid on;

Hmm, I want to zoom the plot in so it shows from -2 to +2 of the x-axis and from -1 to +3 of the y-axis.

% generate x, y vectors
x = -20:0.01:20;   % x goes from -20 to 20 in steps of 0.01
y = x.^2;            % generate y
plot(x,y);
grid on;
axis( [-2, 2, -1, 3] );  % NOTICE this goes AFTER the plot() command, [ xmin, xmax, ymin, ymax ]
% you must have the [], the axis function takes ONE argument with vector type, not 4 different arguments.

Finer control

We can get much finer control over our matlab plots by ACQUIRING THE HANDLE to the axes.

The axes exist as an object in memory somewhere inside the MATLAB “machine”. The ‘handle’ to the axes is YOUR POINTER that you can use to make changes to that axes object, even though the MATLAB program isn’t fully under your control. You have control over PARTS of MATLAB THROUGH these handles you can get.

This is easy.

So howdya get the handle?

% generate x, y vectors
x = -20:0.01:20;   % x goes from -20 to 20 in steps of 0.01
y = x.^2;            % generate y
plot(x,y);

HANDLE = gca;  % "get current axis handle" . . gives you "handle" to the axes that belong to the plot you JUST made.
% Remember, a HANDLE to the axes are just a programmatic "means to control" the axes.

% now try this
get( HANDLE );

%% wow!  you'll see a huge listing here like
%	ActivePositionProperty = outerposition
%	ALim = [0 1]
%	ALimMode = auto
%	AmbientLightColor = [1 1 1]
%	Box = on

% You can customize any of these by choosing something, then SETTING the property using the SET function.

% e.g. let's change the background color to dark blue, and the axes color to
set( HANDLE, 'Color', [0,0.1,0.2] ); %background color to dark blue

How do you change the color of the matlab plot itself?

% generate x, y vectors
x = -20:0.01:20;   % x goes from -20 to 20 in steps of 0.01
y = x.^2;            % generate y
plothandle = plot(x,y);

% now try this
get( plothandle ) ;
%lists all properties you can change of the PLOT itself

set( plothandle, 'Color', [ 1, 0.5, 0 ] );  % plot color to orange
set ( plothandle, 'LineWidth', 1.5 );   % make matlab plot line wider

All the stuff in this section uses code like:

set( HANDLE, 'PropertyName', PropertyValue ) ;

ref

here!

Understanding epsilon-delta proofs

First, get and read this. Really good.

before you even START with epsilon-delta . . .

| x – 3 | < 1;

SAYS in English “x is within 1 unit of 3.”

You have to be fluent with that idea before starting ε-delta; proofs.

Let’s look at a picture of this inequality on the real number line:

So for example, if x = 2.8:

| 2.8 - 3 | < 1
| -0.2 | < 1
0.2 < 1    ===   TRUE

Now let’s try for x = 3.5.

| 3.5 - 3 | < 1
| 0.5 | < 1
0.5 < 1   ===   TRUE

So, | x – 3 | < 1 MEANS x must be within 1 unit of 3 on the real number line.

To be able to understand epsilon-delta at all, you have to get into the habit of looking at an inequality like

| x – 10 | < 5

And immediately just say in a snap “That inequality says that x is within 5 units of 10″

Or
| x – 0.4 | < 0.00001

And say “That inequality says that x is within 0.00001 units of 0.4.”

In general, for any inequality with the format:

| x – c | < a

That says in plain english that “x is within a units of c.”

Epsilon-delta proofs are actually easy.

The meat of epsilon-delta proofs

The meat of epsilon-delta proofs is just this idea.

if
0 < | x – c | < δ

then
| f(x) – L | < ε

Epsilon-delta says:

AS WE RESTRICT x to being within δ units of c, then, as a result of that restriction, f(x) becomes restricted to being within ε units of L.

lim   f(x) = L
x->c

So, here’s the “definition of a limit”, but with more explanation in English words:

The limit:

lim f(x) = L
x->c

exists if and only if

when we restrict x to be within δ units of c,

0 < | x – c | < δ

then, as a consequence of that restriction, we in effect are restricting f(x) to be within ε units of L.

| f(x) – L | < ε

If that happens, then we know that the limit of f(x) as x -> c is equal to L.

Ok, but how do you do an epsilon-delta proof?

So here’s an example of how this stuff works.

Use epsilon-delta to "show" that

lim  3x - 3  =  12
x->5

I know what you’re thinking. “Can’t we just do this:”

lim  3x - 3
x->5

= 15 - 3

= 12

but nooooooo! That’s not good enough for epsilon-stupid. You must “show” it.

Use epsilon-delta to "show" that

lim  3x - 3  =  12
x->5

So, what we use the “definition of a limit” as stated at the top of this page (you should memorize it really for use on tests (YES they DO ALWAYS put epsilon-delta on tests . . )

The limit above exists if and only if for each ε > 0, there exists a δ > 0 such that:

IF
    0 < | x - c | < δ            [ c = 5 though, plug in: ]
    0 < | x - 5 | < δ

THEN
      | f(x) - L | < ε         [ f(x)= 3x - 3, and L = 12, plug in: ]
      | ( 3x - 3 ) - 12 | < ε

So read that in English as:

“IF x is within δ units of 5 . . . “

“. . . THEN ( 3x – 3 ) is within ε units of 12.”

The key to epsilon-delta proofs is you have to relate epsilon and delta.

You have to argue that IF 0 < | x – 5 | < δ ( x is within δ units of 5 ), THEN we can conclude that | ( 3x – 3 ) – 12 | < ε (THEN ( 3x – 3 ) is within ε units of 12 ).

HMM! Hopefully, this is starting to make some sense. Here is how you proceed.

Let’s work with the THEN part (the | f(x) – L | statement), and break it down a bit:

      | ( 3x - 3 ) - 12 | < ε
      | 3x - 15 | < ε

Let’s FACTOR (because we love to factor)

      | (3)(x - 5) | < ε
     3| (x - 5) | < ε
      | (x - 5) | < ε/3;

That looks familiar! Suddenly, the | f(x) – L | < ε looks a lot like the | x – c | < δ statement.

HMM!!!

We can relate the epsilon statement and the delta statement ( 0 < | x – c | < δ ) in this way:

CHOOSE δ = ε/3. (Get used to the idea of “CHOOSING” δ)

Then, we go:

      | x - 5 | < ε/3   [ CHOOSE δ = ε/3 ]

      | x - 5 | < δ

WOW!!!!! How marvellous. It will seem very very strange to you that in the middle of this “mathematical rigor”, we end up going and “choosing” δ = ε/3. You’ll see that this “choice” doesn’t really hurt the “rigor” of what we’re doing though. . . just keep at it.

Next we have to show that this “δ” we’ve chosen ( δ = ε/3 ) “WORKS”.

So we go back to the original statement:

IF
    0 < | x - c | < δ            [ c = 5, chose δ = ε/3 ]
    0 < | x - 5 | < ε/3;

THEN
      | f(x) - L | < ε         [ f(x)= 3x - 3, and L = 12, plug in: ]
      | ( 3x - 3 ) - 12 | < ε
      | 3x - 15 | < ε
     3| x - 5 | < ε
      | x - 5 | < ε/3

Wonder of wonders! It “WORKS”, because the statement has now changed from:

“IF x is within δ units of 5 . . . THEN ( 3x – 3 ) is within ε units of 12.”

To:
“IF x is within ε/3 units of 5, THEN x is within ε/3 units of 5.”

Which cannot be argued against.

Remember, its not stupid. Its “rigorous”.

*This list is being expanded

• The period . operator.

  You put the . in front of an operator like ^ or * to get “element by element” operation behavior. Its best explained by example.

  Say you have a row matrix called ‘x’ that has 10000 values in it.

  You want a plot of y = x², so you need to create another row vector to save values of y to put those values in.

  Instead of writing a loop like:

  for( i = 1:length(x) )
  y(i) = x(i)^2;
  end

  Just use the special . notation and write:

  x = -3:0.01:3;
  y = x.^(2);

  Here, .^ means to raise every element of x to the power of 2, not to try to raise the ENTIRE matrix to the power 2 (which clearly generates an error).

  matlab docs ref

In plotting a simple cube root function y = x^1/3, you expect to see a graph like this:

But when you do

x = -3:0.01:3;
y = x.^(1/3);
plot(x,y)

You get:

Why?

“Pete wanted it that way.”

No, but really. Why is the plot of the cube root complex-valued, and not real-valued?

You should know that there are in fact __3__ cube roots for any number.

For instance, -3 has 1 real, and 2 COMPLEX cube roots:

The three cube roots of -3 are:

• 0.7211 + 1.2490i
• 0.7211 – 1.2490i
• -1.44224

They look like this in the complex plane. Notice that they are separated by 120 degrees.

When you multiply those cube roots together, you get -3 again:

(0.7211 + 1.249i)*(0.7211 - 1.249i)*(-1.44224)
= (2.08)(-1.44224)
= -3

When you do:

x = -3:0.01:3;
y = x.^(1/3);
plot(x,y)

Matlab is putting the first cube root inside y (values like 0.7211 + 1.2490i as the cube root of -3), hence giving y complex values.

Howdya get it to give you just the real ones? Use Matlab’s nthroot function. For example, try:

x = -3:0.01:3;
y = nthroot( x, 3 );
plot(x,y);

Ref:
just see this.

You can find the slope of a curve

m = lim(x->c) f(x) - f(c)
              -----------
                 x - c

How to complete the square

Usually you have to complete the square when you’re trying to draw a graph of a parabola that has an equation like:

x² + 5x + 3 = 0

You only know where the vertex of the parabola goes if you can get it in the form

(x – a)² + C = 0

The cool thing about “completing the square” is when you do it, you actually will always be able to get any polynomial into that (x – a)² + C = 0 form.

How to complete the square

Working with our example x² + 5x + 3 = 0

1 >> Take the 5 (from the 5x term) and divide it by 2.

5
-
2

2 >> Square it.

52
-
22

= 25
  --
  4

3 >> Add AND subtract that squared number from the original polynomial

Now, all you have to do is take that value you just got (25/4) and ADD AND SUBTRACT 25/4 FROM THE ORIGINAL x² + 5x + 3 = 0.

Here is how you do it (pay special attention to WHERE I’m putting the 25/4):

x2 + 5x + 3 = 0

x2 + 5x + 25/4 - 25/4 + 3 = 0

Now the important thing to realize is that what I’ve just written is completely 100%-ly MATHEMATICALLY EQUAL to the original

x2 + 5x + 25/4 - 25/4 + 3 = x2 + 5x + 3

OK?? Make sure you know that.

4 >> “complete the square”

Next, what you do is, you just write this:

x2 + 5x + 25/4 - 25/4 + 3 = 0

(x + 5/2)2 - 25/4 + 3 = 0

(x + 5/2)2 - 13/4 = 0

Notice the 5/2 value . . . we’ve seen that before (go look where).

And that’s how its done.

We can check that the answer we’ve written is correct by multiplying back out. We should get the original polynomial when we’re done:

(x + 5/2)2 - 13/4 = 0

(x + 5/2)(x + 5/2) - 13/4 = 0

x2 + 2(5/2)x + (5/2)2 - 13/4 = 0

x2 + 5x + 25/4 - 13/4 = 0

x2 + 5x + 12/4 = 0

x2 + 5x + 3 = 0

And that’s the same as the original polynomial.

Ok, that was a specific example. What doing this to polynomials in general?

Just apply the pattern. In general, if you have

x² + Bx + C = 0

You complete the square by doing this:

x2 + Bx + C = 0

( x + (B/2) )2 - (B/2)2 + C = 0

Note also that if you have a polynomial of the form

Ax2 + Bx + C = 0

You change it to being in the form:

A(x2 + (B/A)x) + C = 0

So for example, given

5x2 + 7x + 10 = 0

5( x2 + (7/5)x ) + 10 = 0

5( x + (7/10) 2 - (7/10)2 ) + 10 = 0

5( x + (7/10) )2 - 49/100 ) + 10 = 0

5( x + (7/10) )2 - (5)(49)/100 + 10 = 0

5( x + (7/10) )2 + 151/20 = 0

Check its correct by multiplying back out.

5( x + (7/10) )2 + 151/20 = 0

5( x2 + 2(7/10)x + 49/100 ) + 151/20 = 0

5x2 + 7x + 49/20 + 151/20 = 0

5x2 + 7x + 10 = 0

Which is the same as the original.