Neat template matrix library that I wrote in highschool

matrix.h

template<int r, int c, class T> class Matrix;

template<int d, class T>
class Vector
{
public:
  Vector()
  {  }

  Vector(const T v[])
  {
    for (int j=0;j<d;j++)
      vect[j]=v[j];
  }

  T& x() { return vect[0]; }
  T& y() { return vect[1]; }
  T& z() { return vect[2]; }
  T& w() { return vect[3]; }
  T& s() { return vect[4]; }
  T& t() { return vect[5]; }
  T& u() { return vect[6]; }
  T& v() { return vect[7]; }

  T& operator () (int n) { return vect[n]; }
  T& operator[](int n) { return vect[n]; }

  Vector<d,T>& operator= (const T v[])
  {
    for (int j=0;j<d;j++)
      vect[j]=v[j];
    return this;
  }

  Vector<d,T>& operator= (const Matrix<1,d,T>& other)
  {
    for (int j=0;j<d;j++)
      vect[j]=other[1][j];
    return this;
  }

  T square() const
  {
    T sum=0;
    for (int j=0;j<d;j++)
    {
      sum+=vect[j]*vect[j];
    }
    return sum;
  }

  T magnitude() const
  {
    return q_sqrt(square());
  }

  void normalize()
  {
    T tmp;
    tmp=1/magnitude();
    for (int j=0;j<d;j++)
      vect[j]*=tmp;
  }

  T vect[d];
};

template<class T> Vector<3,T> operator^ (Vector<3,T>& v1, Vector<3,T>& v2)
{
  Vector<3,T> result;
  result.x() = v1.y() * v2.z() - v1.z() * v2.y();
  result.y() = v1.x() * v2.z() - v1.z() * v2.x();
  result.z() = v1.x() * v2.y() - v1.y() * v2.x();
  return result;
}

template<int d, class T> T operator/ (const Vector<d,T>& v1, const Vector<d,T>& v2)
{
  T result;
  result = (T)acos(v1*v2) / (v1.magnitude()*v2.magnitude());
  return result;
}

template<int d, class T> T operator* (const Vector<d,T>& v1, const Vector<d,T>& v2)
{
  T result=0;
  for (int j=0;j<d;j++)
    result+=v1[j]*v2[j];
  return result;
}

template<int d, class T> Vector<d,T> operator+ (const Vector<d,T>& v1, const Vector<d,T>& v2)
{
  Vector<d,T> result;
  for (int j=0;j<d;j++)
    result[j]=v1[j]+v2[j];
  return result;
}


template<int d, class T> Vector<d,T> operator- (const Vector<d,T>& v1, const Vector<d,T>& v2)
{
  Vector<d,T> result;
  for (int j=0;j<d;j++)
    result[j]=v1[j]+v2[j];
  return result;
}

template<int d, class T> Vector<d,T> operator- (const Vector<d,T>& v)
{
  Vector<d,T> result;
  for (int j=0;j<d;j++)
    result[j]=-v[j];
  return result;
}


/**********************************************

End vector code start matrix code

**********************************************/



template<int r, int c, class T>
class Matrix
{
public:
  T& operator () (int row, int column) { return matrix[row][column]; }
  const T* operator[](int n) const { return matrix[n]; }
  //	T& value(int row, int column) { return matrix[row][column]; }

  void clear()
  {
    int j,k;
    for (j=0;j<r;j++)
      for (k=0;k<c;k++)
        matrix[j][k]=0;
  }

  void identity()
  {
    int j,k;
    for (j=0;j<r;j++)
      for (k=0;k<c;k++)
        if (j==k)
          matrix[j][k]=1;
        else
          matrix[j][k]=0;
  }

  Matrix<1,c,T>& operator=(const Vector<c,T>& other)
  {
    int j;
    for (j=0;j<r;j++)
      matrix[1][j]=other.vect[j];
    return this;
  }

  void transpose()
  {
    int j,k;
    T tmp;
    for (j=0;j<r;j++)
      for (k=0;k<c;k++)
      {
        tmp=matrix[j][k];
        matrix[j][k]=matrix[k][j];
        matrix[k][j]=tmp;
      }
  }

  T matrix[r][c];
};

template<int x, int y, int r, class T> Matrix<x,y,T> operator*(const Matrix<x,r,T>& other, const Matrix<r,y,T>& one)
{
  Matrix<x,y,T> result;
  for (int column = 0; column < y; column++)
    for (int row = 0; row < x; row++)
      for (int index = 0; index < r; index++)
        result(column, row) += other[column][index] * one[index][row];
  return result;
}