#include "matrix.h"

RcMatrix::RcMatrix()
{
	pArray = new Array(1,1);
}

RcMatrix::RcMatrix(unsigned int column)
{
	pArray = new Array(1,column);
}

RcMatrix::RcMatrix(unsigned int line, unsigned int column)
{
	pArray = new Array(line,column);
}

RcMatrix::RcMatrix(unsigned int line, unsigned int column, double *tab)
{
	pArray = new Array(line,column);
	write(tab);
}

RcMatrix::~RcMatrix()
{
	//delete pArray;
}

RcMatrix::operator=(const RcMatrix& Right)
{

	if(pArray->n == 1) 	// Jezeli n==1 to wiemy, ze mozemy ja zwolnic i zaalokowac nowe dane
	{
		Right.pArray->n++;	//Bedziemy wskazywac na Array po prawej stronie, wiec to tam zwiekszamy referencje
		pArray->array_free();
		pArray = Right.pArray;
	}
	else //Jezeli jest inaczej tablicy nie mozemy zwonlic, wiec tworzymy nowa tablice
	{
		this->detach();
		this->write(Right.pArray->m);
	}
}

RcMatrix RcMatrix::operator+(const RcMatrix& Right) const
{
	//check_range(*this,Right);
	RcMatrix result(pArray->line,pArray->column);
	for(int j = 0; j < pArray->line; j++)
	{
		for(int i = 0; i < pArray->column; i++)
		result.pArray->m[j][i] = pArray->m[j][i] + Right.pArray->m[j][i];
	}
	return result;
}

RcMatrix RcMatrix::operator+=(const RcMatrix& Right)
{
	if(pArray->n != 1)
		this->detach();

	for(int j = 0; j < pArray->line; j++)
	{
		for(int i = 0; i < pArray->column; i++)
			pArray->m[j][i] += Right.pArray->m[j][i];
	}
	return *this;
}

RcMatrix RcMatrix::operator-(const RcMatrix& Right) const
{
	RcMatrix result(pArray->line,pArray->column);
		for(int j = 0; j < pArray->line; j++)
		{
			for(int i = 0; i < pArray->column; i++)
				result.pArray->m[j][i] = pArray->m[j][i] - Right.pArray->m[j][i];
		}
	return result;
}

RcMatrix RcMatrix::operator-=(const RcMatrix& Right)
{
	if(pArray->n != 1)
		this->detach();

	for(int j = 0; j < pArray->line; j++)
	{
		for(int i = 0; i < pArray->column; i++)
			pArray->m[j][i] -= Right.pArray->m[j][i];
	}
	return *this;
}

RcMatrix RcMatrix::operator-() const
{
	RcMatrix result(pArray->line,pArray->column);
		for(int j = 0; j < pArray->line; j++)
		{
			for(int i = 0; i < pArray->column; i++)
				result.pArray->m[j][i] = - pArray->m[j][i];
		}
	return result;
}


RcMatrix RcMatrix::operator*(const RcMatrix& Right) const
{
	RcMatrix result(pArray->line,pArray->column);
		for(int j = 0; j < pArray->line; j++)
		{
			for(int i = 0; i < pArray->column; i++)
				result.pArray->m[j][i] = pArray->m[j][i] * Right.pArray->m[j][i];
		}
	return result;
}

RcMatrix RcMatrix::operator*=(const RcMatrix& Right)
{
	if(pArray->n != 1)
		this->detach();

	for(int j = 0; j < pArray->line; j++)
	{
		for(int i = 0; i < pArray->column; i++)
			pArray->m[j][i] *= Right.pArray->m[j][i];
	}
	return *this;
}

bool RcMatrix::operator== (const RcMatrix & Right)const
{
	for(int j = 0; j < pArray->line; j++)
	{
		for(int i = 0; i < pArray->column; i++)
		{
			if(pArray->m[j][i] != Right.pArray->m[j][i])
			return false;
		}
	}
	return true;
}
void RcMatrix::detach()
{
	Array *result = new Array(pArray->line,pArray->column);
	pArray->n = 1;
	pArray = result;
}

ostream & operator << (ostream & print, const RcMatrix & m)
{
    for(int j = 0; j < m.pArray->line; j++)
	{
		for(int i = 0; i < m.pArray->column; i++)
		{
			print << m.pArray->m[j][i] << "\t";
		}

		print << "\n";
	}

    return print;
}

double RcMatrix::operator()(unsigned int j, unsigned int i) const
{
	return pArray->m[j][i];
}

RcMatrix::Cref RcMatrix::operator()(unsigned int j, unsigned int i)
{
	return Cref(*this,j,i);
}

void RcMatrix::write(double **tab)
{
	pArray->write(tab);
}

void RcMatrix::write(double* tab)
{
	for(int j = 0; j < pArray->line; j++)
	{
		for(int i = 0; i < pArray->column; i++)
		{
			pArray->m[j][i] = tab[j*pArray->column+i];
		}
	}
}

inline double RcMatrix::read(unsigned int j, unsigned int i)
{
	return pArray->m[j][i];
}

unsigned int RcMatrix::getRef()
{
	return pArray->n;
};

void RcMatrix::check_range(const RcMatrix& a, const RcMatrix& b)
{
	if( (a.pArray->line != b.pArray->line) || (a.pArray->column != b.pArray->column) )
		throw Range();
}

RcMatrix::Array::Array(unsigned int line, unsigned int column):
	n(1), line(line), column(column)
{
	m = new double *[line];
	for(int j = 0; j < line; j++)
	{
		m[j] = new double [column];
		for(int i = 0; i < column; i++)
			m[j][i] = 0;
	}

}

RcMatrix::Array::~Array()
{
	for(int i = 0; i < line; i++)
		delete[] m[i];
	delete[] m;
}


void RcMatrix::Array::write(double **tab)
{
	for(int j = 0; j < line; j++)
		for(int i = 0; i < column; i++)
			m[j][i] = tab[j][i];
}

double RcMatrix::Array::read(unsigned int j, unsigned int i)
{
	return m[j][i];
}

void RcMatrix::Array::array_free()
{
	for(int i = 0; i < line; i++)
		delete[] m[i];
	delete[] m;
}

RcMatrix::Cref::operator double() const
{
    return m.pArray->read(j,i);
}

RcMatrix::Cref& RcMatrix::Cref::operator = (double value)
{
    m.pArray->m[j][i] = value;
    return *this;
}