Vectors

 1 Note about kill(all)

In this lesson, we will be defining custom operations and bindings.  It is strongly advised that you
avoid using the kill(all) command as it will destroy those customizations!

 2 Basic Vector Operations

Vectors in Maxima are nothing more than lists indicated by square brackets.  So, for example,
the vector <1,0> and <0,1> are encoded as:

We can encode 3-vectors in the same way:

Addition, subtraction, and scalar multiplication work in the obvious ways:

And we can bind vectors to variables as usual:

 3 Standard Basis Vectors i,j,k

Note that Maxima does not come equipped with i, j, or k, but we can make them ourselves.
we could bind:

And now we can define a vector <a,b,c> in the usual way:

Note that, unlike humans, Maxima doesn't have the luxury of knowing the *context* of i and j, and so
it doesn't know when i and j are supposed to be vectors in 2D or 3D. Our definition above forces
i and j to be 3D vectors.  If we want 2D vectors, we could define:

And now:

But it is definitely not the case that i=I or j=J:

Note again that if you use kill(all), this will unbind i,j,k, I, J and these will no longer hold the basis vectors that
you intend!  So caution with this technique is advised.

 4 The Dot Product and Magnitude

The dot product between two vectors is given by the English period (.).  So for instance:

Recall the magnitude of a vector u is related to the dot product by way of:

|u| = sqrt(u.u)

This is exactly how we can compute the magnitude of a vector irrespective of whether or not it
is 2D or 3D:

If we know that we are going to be computing a lot of magnitudes, we can define a function:

So that the above calculations become:

Again, if you call kill(all), this function will be obliterated --- so caution is advised.

 4.1 Making Unit Vectors

We know that a vector u can be normalized by u/|u|.  Now that we have a magnitude function, this can
easily be done in Maxima:

Note that:

as required.

We can even define a function hat() that takes in a vector and automatically produces its unit form:

So that:

Notice that since we used vector operations to define hat(), the above definition works equally well for
2D vectors:

This shortcut could come in really handy -- as we will see in the following section.

 4.2 The Angle Between Two Vectors

The dot product is related to the angle between two vectors via:

u.v = |u||v|cos(%theta)

If we divide both sides by the magnitudes we get:

hat(u).hat(v) = cos(%theta)

So let's say we have defined the hat() function and we want to know the angle between u=<1,0,0> and v=<1,1,0>.
We know that the answer should be %pi/4, so let's check.  Note that acos() is arccos:

Perfect!  Of course, we do not require the hat() function to make the above work, it just makes life a little simpler.
Let's find the angle between the vectors i and -i+j:

Or using hat():

What if the angle isn't so pretty?

Maxima resorts -- as always -- to giving us the most exact answer possible.  In this case that means it leaves the
arccosine unevaluated.  We can force the result by way of float():

We see that the angle between <1,0> and <2,3> is just shy of 1 radian, or just a little south of 100*%pi/315 since:

(If you think about it for just a second, you should be able to figure out where 100%pi/315 came from --- hint:
what is %pi to three decimal places?)

 5 The Cross Product

Maxima does not have a cross product loaded by default.  In order to gain access to it we must load the "vect" package like so:

Note: when you first load the vect package, it may need to be compiled -- and a string of messages may appear in your session telling you the progress of the compilation.  If you want to supress these messages altogether, you can simply call:

load("vect")$

With a dollar sign after it.  In any case, don't worry about any of the compiling messages!  It's normal.  Once it is loaded, we compute the cross product with the tilde (~) which is in the upper left hand corner of most keyboards.  It is computed like so:

Wait... what?!  The above is actually calculated, but it's not being expressed in the form that is convenient for humans.
To get the human readable answer, we ask for:

Note that as usual:

So, to take a cross product, we do: express(u~v):

 5.1 Crossing 2D Vectors:

Let's see what happens when we cross two 2D vectors:

Hmmm... that's not a vector... let's try a few more:

That's good that the result is negative, but it's still not clear what's going on...

Aha!  We recognize this as the usual cross product for 2D vectors --- without the k vector!
When you give Maxima two 2D vectors, it only gives back the k *component* of the cross
product and not the vector.

This is due to the common practice of defining the cross product of two 2D vectors as simply a
scalar -- since k does not technically exist in 2D space, this is reasonable, though a little problematic
when we consider the cross product in 3D.

Our advice on this issue is to only cross 3D vectors.  If you want to cross [1,2] and [3,4] for instance
then:

If we have defined i,j,k as three vectors, then this poses no real issue since:

Looks the same in 2D as in 3D and yields the correct (more general) vector result.

 5.2 (Re)Defining the Cross Product for Convenience: The ## Helper

If the call to express() bugs you, then you can define your own custom cross product that includes the call to express by way of:

The first line tells Maxima that ## is going to be a new operator, while the second line tells Maxima how that operator will do
its work.  The word "infix" means that the operator is "fixed" with"in" two things.  There are also prefix, postfix, and matchfix
operators that work pre-, post-, and around expressions as well!  We will define a prefix operator @ in a later section.

Let's see the results of this new addition:

Extreme caution must be taken when defining your own custom operators, as you are overloading the default behavior
of the core language.  For simple calculations that we need, this shouldn't pose too much of a problem however.

Again, if you kill(all), you will lose the above.

Finally, we note that when using our custom ## we must take care to use parentheses for compound expressions,
since we did not tell Maxima exactly where ## sits in the order of operations!

 6 Scalar Triple Product

The scalar triple product of three vectors u,v,w is defined to be u.(v~w) and so we can now compute it via:

u.express(v~w)

As a test case, let's consider i.express(j~k) which should give 1, and j.express(i~k) which is -1:

If we use our redefined cross product:

As one further test, note that the scalar triple product just gives the determinant of the matrix with
rows (or columns) given by the vectors u,v,w.  So let's test that the above is doing the right thing:

Careful comparison with the formula for the determinant of the 3x3 matrix with rows
given by u,v, and w shows that the above both yield the correct result, and we
can be confident in our computations.

 6.1 Creating a Custom Triple Product

If we have defined ## as the cross product, then it is pretty simple to type in u.(v##w)
to get the triple product.  But suppose we want a function to do that for us.  We can
define:

So now, if u,v, and w are symbollically given by:

Which can be really nice if you already have u,v, and w previously defined!

Or for display purposes: