/home/marcvs/Desktop/working/pa-materiale/pa/codeBase/C++/include/Matrix.h

#ifndef __MATRIX_H__
#define __MATRIX_H__

#pragma once

#include <iostream>
#include <cstdlib>
#include <cstring>

template<class Type> class Matrix;

template<class Type>
Matrix<Type> operator* (const Matrix<Type>& left,const Matrix<Type>& right)
{
        if (left.n_col != right.n_lin){
                std::cerr << "Warning! Ingnoring \"*\" between matrices of sizes (" << left.n_lin << "," << left.n_col << ") and (" << right.n_lin << "," << right.n_col << ").\n";
                return Matrix<Type>();
        } else {
                Matrix<Type> result(left.n_lin, right.n_col, Matrix<Type>::Zero);
                for (int i = 0; i < left.n_lin; i++){
                        for (int j = 0; j < right.n_col; j++){
                                for (int k = 0; k < left.n_col; k++){
                                        result[i][j] += left[i][k] * right[k][j];
                                }
                        }
                }
                return result;
        }
}

template<class Type>
Matrix<Type> operator+ (const Matrix<Type>& left, const Matrix<Type>& right) 
{
        if (left.n_lin != right.n_lin || left.n_col != right.n_col){
                std::cerr << "Warning! Ingnoring \"+\" between matrices of sizes (" << left.n_lin << "," << left.n_col << ") and (" << right.n_lin << "," << right.n_col << ").\n";
                return Matrix<Type>();
        } else {
                Matrix<Type> result(left.n_lin, right.n_col, Matrix<Type>::Zero);
                for (int i = 0; i < left.n_lin; i++){
                        for (int j = 0; j < right.n_col; j++){
                                result[i][j] = left[i][j] + right[i][j];
                        }
                }
                return result;
        }
}

template<class Type>
Matrix<Type> operator- (const Matrix<Type>& left, const Matrix<Type>& right)
{
        if (left.n_lin != right.n_lin || left.n_col != right.n_col){
                std::cerr << "Warning! Ingnoring \"+\" between matrices of sizes (" << left.n_lin << "," << left.n_col << ") and (" << right.n_lin << "," << right.n_col << ").\n";
                return Matrix<Type>();
        } else {
                Matrix<Type> result(left.n_lin, right.n_col, Matrix<Type>::Zero);
                for (int i = 0; i < left.n_lin; i++){
                        for (int j = 0; j < right.n_col; j++){
                                result[i][j] = left[i][j] - right[i][j];
                        }
                }
                return result;
        }
}

template<class Type>
std::istream& operator>> (std::istream& in, Matrix<Type> &right)
{
        for (int i = 0; i < right.n_lin; i++){
                for (int j = 0; j < right.n_col; j++){
                        in >> right[i][j];
                }
        }
        return in;
}

template<class Type>
std::ostream& operator<< (std::ostream& out, Matrix<Type> right)
{
        for (int i = 0; i < right.n_lin; i++){
                for (int j = 0; j < right.n_col; j++){
                        out << (j == 0 ? "" : " ") << right[i][j];
                }
                out << std::endl;
        }
        return out;
}

template <class Type>
class Matrix{
private:
    int n_lin, n_col;
    Type* m;
    
        void deallocate()
        {
                if (n_lin | n_col){
                        delete[] m;
                        n_lin = n_col = 0;
                }
        }
        
        void allocate(int init)
        {
                m = new Type[n_lin*n_col];
                if (init == Zero){
                        // Set all the memory to 0
                        memset(m, 0x00, sizeof(Type)*n_col*n_lin);
                } else if (init == Unit && n_lin == n_col){
                        // Set the matrix as a unit matrix
                        memset(m, 0x00, sizeof(Type)*n_col*n_lin);
                        for (int i = 0; i < n_lin; i++){
                                m[i*n_col+i] = 1;
                        }
                } 
        }
        
        void allocate(const Matrix<Type>& right)
        {
                m = new Type[n_lin*n_col];
                memcpy(m, right.m, sizeof(Type)*n_col*n_lin);
        }
        
public:
    Matrix(int n_lin, int n_col, int init = None):
        n_lin(n_lin),
                n_col(n_col)
        {
                if (n_lin > 0 && n_col > 0){
                        allocate(init);
                } else {
                        n_lin = 0;
                        n_col = 0;
                        m = NULL;
                }
        }

    Matrix(const Matrix<Type>& right):
        n_lin(right.n_lin),
                n_col(right.n_col)
        {
                allocate(right);
        }

    Matrix():
        n_lin(0),
                n_col(0),
                m(NULL)
        {
        }

        inline int get_n_lin() const { 
                return n_lin;
        }
        
        inline int get_n_col() const {
                return n_col;
        }
    
    ~Matrix()
    {
        deallocate();
    }
    
    static const int Zero = 0;
    static const int Unit = 1;
    static const int None = 2;

        Matrix<Type> submatrix(int start_lin, int start_col, int n_lines, int n_columns) const 
        {
                if (start_lin + n_lines > n_lin || start_col + n_columns > n_col){
                        std::cerr << "Error! Request for sumatrix of size (" << n_lines << "," << n_columns << ") exceeds size of original matrix!\n";
                        return Matrix<Type>();
                } else {
                        Matrix<Type> result(n_lines, n_columns);
                        for (int i = 0; i < n_lines; i++){
                                for (int j = 0; j < n_columns; j++){
                                        result[i][j] = m[(start_lin+i)*n_col+start_col+j];
                                }
                        }
                        return result;
                }
        }

        Matrix<Type>& copy(int start_lin, int start_col, const Matrix<Type>& source)
        {
                if (start_lin + source.n_lin > n_lin || start_col + source.n_col > n_col){
                        std::cerr << "Error! Copy-ing matrix of size (" << source.n_lin << "," << source.n_col << ") will exceed size of original matrix!\n";
                } else {
                        for (int i = 0; i < source.n_lin; i++){
                                for (int j = 0; j < source.n_col; j++){
                                        m[(i+start_lin)*n_col+j+start_col] = source[i][j];
                                }
                        }
                }
                return (*this);
        }

        inline Type* operator[](int line) const
        { 
                return m+line*n_col; 
        }

        Matrix<Type>& operator= (const Matrix<Type>& right)
        {
                if (this != &right){
                        if (n_lin > 0 && n_col > 0){
                                deallocate();
                        }
                        n_lin = right.n_lin;
                        n_col = right.n_col;
                        allocate(right);
                }
                return (*this);
        }
        
        Matrix<Type>& operator+= (const Matrix<Type>& right)
        {
                if (this == &right){
                        std::cerr << "Error! Ignoring increment with self! Try m=m+m instead of m+=m!\n";
                } else if (n_lin != right.n_lin || n_col != right.n_col){
                        std::cerr << "Warning! Ingnoring \"+=\" between matrices of sizes (" << n_lin << "," << n_col << ") and (" << right.n_lin << "," << right.n_col << ").\n";
                } else {
                        for (int i = 0; i < n_lin; i++){
                                for (int j = 0; j < n_col; j++){
                                        m[i*n_col+j] += right[i][j];
                                }
                        }
                }
                return (*this);
        }
        
        Matrix<Type>& operator-= (const Matrix<Type>& right)
        {
                if (this == &right){
                        std::cerr << "Error! Ignoring decrement by self! Try m=m-m instead of m-=m!\n";
                } else if (n_lin != right.n_lin || n_col != right.n_col){
                        std::cerr << "Warning! Ingnoring \"-=\" between matrices of sizes (" << n_lin << "," << n_col << ") and (" << right.n_lin << "," << right.n_col << ").\n";      
                } else {
                        for (int i = 0; i < n_lin; i++){
                                for (int j = 0; j < n_col; j++){
                                        m[i*n_col+j] -= right[i][j];
                                }
                        }
                }
                return (*this);
        }

        friend std::istream& operator>> <>(std::istream&, Matrix<Type>& right);
        friend std::ostream& operator<< <>(std::ostream&, const Matrix<Type> right);
        friend Matrix<Type> operator* <>(const Matrix<Type>& left, const Matrix<Type>& right);
        friend Matrix<Type> operator+ <>(const Matrix<Type>& left, const Matrix<Type>& right);
        friend Matrix<Type> operator- <>(const Matrix<Type>& left, const Matrix<Type>& right);
};

#endif