Matrix Lib

module Matrix;

import std.stdio;
import std.conv;

class Matrix(T, int height, int width) {
    alias Matrix!(T, height, width) matType;
    T[height * width] elements;

    int Height() const @property{
        return height;
    }

    int Width() const @property{
        return width;
    }

    ref T Element(uint x, uint y) {
        if(x + y * width < elements.length)
            return elements[x + y * width];

        throw new Exception ("FUCK, Index out of range!!!1!!11!");
    }

    ref T opIndex(size_t x, size_t y){
        return Element(x,y);
    }

    matType opBinary(string s) (matType rhs) if(s =="-", s =="+") {
        auto m = new matType;

        foreach(i; 0..elements.length) {
            if(s=="+") {
                m.elements[i] = elements[i] + rhs.elements[i];
            }
            else if(s=="-") {
                m.elements[i] = elements[i] - rhs.elements[i];
            }
        }

        return m;
    }

    Matrix!(T, height, rhsWidth) opBinary(string s, RHST, int rhsHeight, int rhsWidth) (Matrix!(RHST, rhsHeight, rhsWidth) rhs)
        if(width == rhsHeight && s == "*") {
        auto result = new Matrix!(T, height, rhsWidth);

        for(size_t i = 0; i < height; i++) {

            for (size_t j = 0; j < rhs.Width; j++) {

                T sum = 0;

                for(int k = 0; k < width; k++) {
                    sum += Element(i, k) * rhs.Element(k, j);

                    writeln(Element(i, k), " * " ,rhs.Element(k, j), " + ");

                }
                result[i,j] = sum;
            }
        }
        return result;
    }

    matType opOpAssign(string s) (matType rhs) {
        foreach(i; 0..elements.length) {
            if(s=="+") {
                elements[i] += rhs.elements[i];
            }
            else if(s=="-") {
                elements[i] -= rhs.elements[i];
            }
        }
        return this;
    }

    matType opUnary(string s)() if(s=="-") {
        auto m = new matType;
        foreach(i; 0..elements.length) {
            m.elements[i] = -elements[i];
        }
        return m;
    }



    override string toString() const{
        string s;
        s ~= "[";

        foreach(i; 0..elements.length) {
            s ~= to!string(elements[i]);

            if(i != elements.length-1)
                s ~= ", ";

            if(i % width == width - 1 && i != elements.length-1)
                s ~= "\n";
        }
        s ~= "]\n";
        return s;
    }
}

alias Matrix!(double, 3,3) Matrix3;

void main() {
    try{
        auto m = new Matrix!(int, 4, 4);

        for(int i = 0; i < m.Width; i++) {
            for (int j = 0; j < m.Height; j++) {
                m[i,j] = i;
            }
        }

        auto n = new Matrix!(int, 4, 4);

        for(int i = 0; i < n.Width; i++) {
            for (int j = 0; j < n.Height; j++) {

                n[i,j] = -j;
            }
        }

        writeln(n);
        writeln(m);

        auto o = n * m;

        writeln(o);


    }catch(Exception e){
        writeln(e.msg);
    }
}