/*
    Hyperbolic Tessellations
    Copyright (C) 2007 Dmitry Brant
    http://dmitrybrant.com

    Based largely on code from
    http://www.plunk.org/~hatch/HyperbolicApplet/
*/
#ifndef _matrix_h
#define _matrix_h

#include "myvector.h"

//The almighty recursive Matrix class

template <class T>
class Matrix : public Vector<T> {
public:

    //dimension of matrix
    int dimension;   //cannot be < 1

    //pointer to lower dimensions
    Vector<T>* items;   //each of these will have dimension-1

    Matrix() : Vector<T>(), dimension(1), items(NULL) { }

    ~Matrix(){
        if(items){ delete [] items; items = NULL; }
    }

    Matrix(const Matrix<T>& a){
        dimension = a.dimension;
        length = a.length;
        if(dimension == 2){
            items = new Vector<T>[length];
        }else{
            items = new Matrix<T>[length];
        }
        for(int i=length-1; i>=0; i--) items[i] = a.items[i];
    }

    Vector<T>& operator=(const Matrix<T>& a){
        if(items){ delete [] items; items = NULL; }
        dimension = a.dimension;
        length = a.length;
        if(dimension == 2){
            items = new Vector<T>[length];
        }else{
            items = new Matrix<T>[length];
        }
        for(int i=length-1; i>=0; i--) items[i] = a.items[i];
        return *this;
    }




    Matrix(int a, int b){                           //2-d
        dimension = 2;
        length = a;
        items = new Vector<T>[length];
        for(int i=length-1; i>=0; i--) items[i].Resize(b);
    }

    Matrix(int a, int b, int c){                    //3-d
        dimension = 3;
        length = a;
        items = new Matrix<T>(b,c)[length];
    }

    Matrix(int a, int b, int c, int d){             //4-d
        dimension = 4;
        length = a;
        items = new Matrix<T>(b,c,d)[length];
    }

    Matrix(int a, int b, int c, int d, int e){      //5-d
        dimension = 5;
        length = a;
        items = new Matrix<T>(b,c,d,e)[length];
    }

    Vector<T>& operator[](int index){ return items[index]; }

    Vector<T>& operator*=(const T& t){
        for(int i=length-1; i>=0; i--) items[i] *= t;
        return *this;
    }

    Vector<T>& operator/=(const T& t){
        for(int i=length-1; i>=0; i--) items[i] /= t;
        return *this;
    }

    Vector<T>& operator+=(const Matrix<T>& a){
        for(int i=length-1; i>=0; i--) items[i] += a.items[i];
        return *this;
    }

    Vector<T>& operator-=(const Matrix<T>& a){
        for(int i=length-1; i>=0; i--) items[i] -= a.items[i];
        return *this;
    }


    String toString(){
        String s;
        for(int i=length-1; i>=0; i--) s += items[i].toString() + "\r\n";
        return s;
    }

};

#define DoubleMatrix        Matrix<double>
#define IntMatrix           Matrix<int>




template <class T>
Matrix<T> operator+(Matrix<T>& a, Matrix<T>& b){
    Matrix<T> c(a);
    c += b;
    return c;
}

template <class T>
Matrix<T> operator-(Matrix<T>& a, Matrix<T>& b){
    Matrix<T> c(a);
    c -= b;
    return c;
}

template <class T>
Matrix<T> operator*(Matrix<T>& a, Matrix<T>& b){
    Matrix<T> c(a);
    c += b;
    return c;
}






#endif