The 3 common methods of describing a point in a three dimensional coordinate system are Cartesian, Cylindrical and Spherical. The most simple is Cartesian but certain teachers find it necessary to use the others. There are a few simple conversions between them but first it is necessary to know their notation.

Cartesian:

Cylindrical:

Spherical:

In most cases you will only need to work from Cartesian to Cylindrical or Spherical OR back, so I will only supply those equations. If you need to work between Cylindrical and Spherical, it would be one more simple step working from one of those, to Cartesian, then on to the other.

Cartesian Cylindrical:

Cartesian Cylindrical:

Cartesian Spherical:

Cartesian Spherical:

Plug the values from any given points into the correct equation to convert to a different type of coordinate system.

Suppose you are interested in finding the unit vector between two points, and , which are described in cartesian coordinates as and , respectively.

You would begin by finding the vector between these two points. The direction of this vector may be important so look for key words such as . Once we have established the direction we’re going in, to in this case, we subtract the beginning point from the end point. . This will give us the vector we are looking for. The next step would be to convert this vector into a unit vector, by dividing it by it’s magnitude.

These are the two formulas we are looking at:

Note:
Here I use as my vector from to and denotes the unit vector from to .

Implementing these formulas:

Hmm.. The End

A Finite State Machine (FSM), or just state machine, is a model of behavior composed of a finite number of states. We use these in computer engineering to model a “machine” with primitive memory. Based on the signals  we recieve, we go to a certain state where information is processed, and then we wait for the signal that indicates we move to the next state.  There are two types of FSMs we will talk about: Moore machines and Mealy machines.

Moore Machines

Moore machines are state machines where the output is determined by only the current state, not the inputs. For example, if we  had designed a system where the state table looks like this:

we can see that it doesn’t even matter what the input and outputs are, the next state only depends on the current state. A typical example of Moore style state machines is a synchronous circuit composed of flip-flops connected to a clock. The state can only change when the clock pulses, and for flip-flops, the output(next state) is a function of the input(current state).

Mealy Machines

By contrast there are FSMs called Mealy machines where the next state is a function of both the current state, and the input.

Consider the truth table we discussed earler. In our Moore state machine design, we didn’t care what the input was. Now, however, we have decided that if the current state is 00 and the input is 0 , the next state is 01 .

We can see above that the next state is a function of the current state, and the input. A real world example of a  Mealy machine is a mathematical cypher machine.

Mealy machines are typically sequential logic, whereas Moore machines are combinatorial logic.

Vector dot product rules

Another simple review of the vector dot product, for those of you that have forgotten.  The operation that involves multiplying two vectors together can be done in a few ways.  The first operation is called either the scalar product or the dot product.  One of the well known definitions looks like this:

RULE 1:

This is a scalar product that is equal to the two magnitudes multiplied together and multiplied by the cosine of the angle between them.  If  the two vectors are perpendicular to each other then the angle between them is 90 degrees, which will make the dot product equal zero.  This is an equivalent equation.

RULE 2:

When you finish your dot product, you should have a number, not a directional vector.  So if you get something like this you did something wrong: .  If you ended up with (any #) then you don’t have to completely rule out your answer.

Practice vectors

A few vectors to practice with:

Okay, now we have found our dot product by applying RULE 2 above.  We can use this value along with our individual vector magnitudes to apply RULE 1 and obtain the angle .

We can calculate the projection of the vector A onto the vector B by this relationship:

Note that this is a scalar quantity, and that we can also define the projection of B onto vector A in a similar fashion:

Performing a vector dot product in MATLAB

Perform a dot product in MATLAB like so:

>>A = [ 1 2 3];

>>B = [2 3 4];

>>dot(A,B)

Enjoy

This is a very simple post and a very simple subject, but every once in a while even the experts need to be reminded how to do simple addition and subtraction with vectors.  Let’s go ahead and specify a couple vectors that we can work with.

Vector

In MATLAB: >>A = [1 2 4];

Vector

In MATLAB: >>B = [2 3 4];

When you add vectors together, you add each individual directional component ().  Subtraction works the exact same way.  Lets go ahead and do a few, C will represent the vector that results from the addition and subtraction.

These vectors are all in 3-dimensional space with a X, Y and Z component.  The number in front of each directional component is the weight or magnitude of that particular directional component of the vector.  There it is, short and sweet