Download – Matrices in Maple – 1 Linear Algebra Package

– Matrices in Maple –
1
October 24, 1994
Linear Algebra Package
The useful linear algebra operations are contained in a special package that is loaded
with the command
> with(linalg);
The list of newly defined and redefined procedures gives an idea of what the package
contains. Use the help command, as in ?dotprod to learn more about what the
procedure does and how to use it.
2
Vectors and Arrays
To create an array, use
> a := array( [ [3,-1,1], [4,-5,4], [4,-7,6] ] );
[ 3
[
a := [ 4
[
[ 4
-1
-5
-7
1 ]
]
4 ]
]
6 ]
Vectors may be defined by listing their elements:
> y := array([3,-5,6]);
y := [ 3, -5, 6 ]
You can also use vector in place of array. With the usual scientific conventions,
these are actually column vectors, despite the display. That can be checked by
multiplying the matrix times the vector as follows.
To multiply a matrix and a vector, use either
> evalm(a &* y);
[ 20, 61, 83 ]
or use multiply(a,y);.
To access an individual vector or array element, use square brackets for the
subscript:
1
> a[1,2],y[3];
-1, 6
The inverse is computed from
> ainv := evalm(a^(-1));
[ 1/3
[
ainv := [ 4/3
[
[ 4/3
1/6
-7/3
-17/6
-1/6 ]
]
4/3 ]
]
11/6 ]
or using inverse(a);
Note that evalm interprets arithmetic operations in matrix language. There is
one subtlety, however. Sometimes we want to multiply a matrix by a scalar and
sometimes we want to multiply a matrix by a matrix or a matrix by a vector. So we
use &* to specify matrix multiplication and * to specify multiplication by a scalar.
To multiply matrices, use
> evalm(a &* ainv);
[ 1
[
[ 0
[
[ 0
0
1
0
0 ]
]
0 ]
]
1 ]
To multiply every element by a scalar or subtract a scalar from the diagonal
elements, use
> evalm(2*a-1);
[ 5
[
[ 8
[
[ 8
2
-2
-11
-14
2 ]
]
8 ]
]
11 ]
The determinant is found from
> det(a);
-6
and the eigenvalues are found using eigenvals(a).
> evalf(eigenvals(a));
3, 2, -1
Dot products can be computed as well, but not with the &* operation:
> w := array([2,1,-1]);
w := [ 2, 1, -1 ]
-------------------------------------------------------------------------------> evalm(w &* y);
Error, (in linalg[multiply]) vector dimensions incompatible
-------------------------------------------------------------------------------> dotprod(w,y);
-5
The problem with &* is that it specifies multiplying two column vectors as though
they were matrices.
Another way to get the dot product is to take the transpose first, as in
> evalm(transpose(w) &* y);
-5
The outer product, on the other hand, is found by multiplying in the opposite order:
> evalm(y &* transpose(w));
[ 6
[
[ -10
[
[ 12
To get a vector crossproduct, use
3
3
-5
6
-3 ]
]
5 ]
]
-6 ]
> crossprod(y,w);
[ -1, 15, 13 ]
which works only for three-dimensional vectors.
Now let’s solve the linear system ax = y with the matrix a and the column
vector y as defined above. We do this easily using
> linsolve(a,y);
[ -5/6, 71/3, 175/6 ]
The evalm operation also handles scalar multiplication and addition. As an
example, we may check the Cayley-Hamilton theorem that a matrix satisfies its own
characteristic equation as follows.
First we construct the characteristic polynomial:
> charpoly(a,lambda);
2
(lambda - 3) (lambda - lambda - 2)
which is the same as det(evalm(a-lambda));. Remember, the roots of the characteristic polynomial are the eigenvalues of the matrix.
Then we replace the scalar variable lambda with the array a using
> subs(lambda=a,");
2
(a - 3) (a
- a - 2)
and finally ask that the equation be read as an equation for matrices, substituting
the actual matrix a we have been using:
> evalm(");
[ 0
[
[ 0
[
[ 0
To get the eigenvectors of a matrix a, use
4
0
0
0
0 ]
]
0 ]
]
0 ]
> eigenvects(a);
[-1, 1, {[ 0, 1, 1 ]}], [2, 1, {[ -1, 0, 1 ]}], [3, 1, {[ 1, 1, 1 ]}]
The result needs a little explaining. There are three items in the list. In each item
are two scalars and a vector. The vector is the actual eigenvector. The scalars
specify the eigenvalue and its multiplicity. In this case there are three distinct
eigenvalues with multiplicity 1. The first in the list with eigenvalue -1 corresponds
to the eigenvector [0,1,1] and so on.
For a final example, let’s explore the power method of generating the leading
eigenvalue and eigenvector. With this method we start with an arbitrary trial vector
x0 and act on it with the matrix a. We keep multiplying by a until the vector is
driven into the subspace corresponding to the largest eigenvalue. From the list above,
we see that the third one with eigenvalue 3 is the largest. Since it has multiplicity
1 the subspace should be simply a constant times the vector [1,1,1], so it should
be easily recognizable.
Let’s start with a unit vector and multiply away:
> x0 := vector([1,0,0]);
x0 := [ 1, 0, 0 ]
-------------------------------------------------------------------------------> evalm(a &* x0);
[ 3, 4, 4 ]
-------------------------------------------------------------------------------> evalm(a &* ");
[ 9, 8, 8 ]
-------------------------------------------------------------------------------> evalm(a &* ");
[ 27, 28, 28 ]
-------------------------------------------------------------------------------> evalm(a &* ");
[ 81, 80, 80 ]
-------------------------------------------------------------------------------5
> evalm(a &* ");
[ 243, 244, 244 ]
-------------------------------------------------------------------------------> evalm(a &* ");
[ 729, 728, 728 ]
We see that the vector is gradually approaching a constant times [1,1,1]. Furthermore, each successive multiplication by a is nearly the same as multiplying by
3, the corresponding eigenvalue.
6