The idea behind this project was to allow the user to treat matrices and 
vectors like any of the other data types.  The way that I implemented this was
through using a class template structure.  

    The base class is Arraymd<T>.  This is a virtual class so you can't make
an instance of it.  By making this the base class, I have allowed the user to
add arrays of order 3 or higher to the existing program structure.

    The Matrix<T> class is a daughter class of Arraymd<T>.  This allows you to
create a matrix by calling:

	Matrix<double> mat(5,5);

The above call will create a 5x5 matrix of double precision floating point
numbers.  You can set all of the elements equal to a number by saying:

	mat = 2.0;

Now all of the elements for your matrix are equal to 2.0.  You can also set
the values of individual matrix elements by saying:

	mat(1,1) = -1.5;

This will set (1,1) element to -1.5.  The () operator has been overloaded so
that you can access each data member of the matrix easily. We can also set to
matrices equal to each other by saying:

	Matrix<double> mat2 = mat;

The will create a copy of mat in the structure mat2.  This will create another
instance, mat2 is not the same as mat.  There are other functions which allow
you to manipulate the internal structure of the matrix.  These are:

	addrow (int i, Vector<T>& v);  Adds the row vector v to row i of matrix
	addcol (int i, Vector<T>& v);  Same as above but to column i.
	subrow (int i, Vector<T>& v);  Subtract vector v from row i of matrix.
	subcol (int i, Vector<T>& v);  Same as above but to column i.
	scalerow (int i, T val);  Multipliy each alement of row i by val
	scalecol (int i, T val); Same as above but to column i.
	swaprow (int i, int j);  Switch row i with row j.
	swapcol (int i, int j);  Switch col i with col j.

These are all called by mat.func(arg 1, arg2).  These will change the matrix
and thus the results are sent back by reference instead of by value.  In
addition all of the arithmetic operations have been overloaded.  So +, -, *,
/, +=, -=, *=, and /= have all been implemented.  You can do these operations
with two matrices or with a number and a matrix.  For example:

	Matrix<double> mat3 = mat2 * mat;
	Matrix<double> mat4 = 3.0/mat;

In the first case we simply multiply mat2 and mat to get mat 3.  In the
second, mat4 = 3.0* each element of inverse(mat).  The display operator has
been overloaded so that  cout<<mat; will display your matrix.  You can also
find the transpose of a matrix and its determinant (if one exists).

    The class Vector<T> is also a daughter class of Arraymd<T>.  It works
exactly the same way as Matrix<T> except that you only give the length of the
vector to the constructor.  In other words:

	Vector<double> vec(5);

This will create a 5 element vector of double precision numbers.  The rest of
the structure is about the same as for Matrix<T> except where the function
wouldn't make any sence.  Please note, that as in the case of Matrix<T>, I
have overloaded () to access the vector elements.

    There is also a class Eigen<T>.  Given some input matrix, this class can
find its eigenvalues and eigenvectors.  You should note that this routine will
only work for square, symmetric matrices.  To use this you create your matrix
using the Matrix<T> class.  Then, you:

	Eigen<double> eig(mat);

This creates an instance eig that has data members for the eigenvealues and
eigenvectors.  To get the eigenvalues (or vectors):

	Matrix<double> vectors = eig.get_vectors();
	Vector<double> values = eig.get_values();

That's all there is to it.  While you can make Eigen of any data type, I 
suggest that you only use DOUBLE.  Otherwise, you may lose information.  
Beacause of this, make sure that your input matrix is also of type double or 
the program will not compile!


    So your saying to yourself what do I need to do to use this, well download:

	Matrix.h
	Global.C
	Matrix.C
	Vector.C
	Eigen.h
	Error.h

You should also download my test programs:

	testmatrix.C
	testvector.C
	testEigen.C

To compile any of the test programs just type g++ program.C.  Do not
compile Global.C, Matrix.C, and Vector.C.  These files have been
included at the end of Matrix.h and are only used to make the program a
little easier to read.