#include "Matrix.h"

void CMatrix::Add(const CMatrix & m) throw(invalid_argument)
{
	uint32_t rows2, columns2;
	this->GetSize(rows2, columns2);
	m.GetSize(rows, columns);

	if (rows != rows2 || columns != columns2) throw invalid_argument("invalid argument");
	else {
		CMatrix mat = CMatrix(m);
		for (unsigned int i = 0; i < rows; i++)
		{
			for (unsigned int j = 0; j < columns; j++)
			{

				this->matrix[i][j] = matrix[i][j] + mat.GetElement(i, j);
			}

		}
	}
}

void CMatrix::Sub(const CMatrix & m) throw(invalid_argument)
{
	uint32_t rows2, columns2;
	this->GetSize(rows2, columns2);
	m.GetSize(rows, columns);
	CMatrix mat = m;
	if (rows != rows2 || columns != columns2) throw invalid_argument("invalid argument");
	for (unsigned int i = 0; i < rows; i++)
	{
		for (unsigned int j = 0; j < columns; j++)
		{

			this->matrix[i][j] = matrix[i][j] - mat.GetElement(i, j);
		}

	}
}

CMatrix CMatrix::Mul(const CMatrix & m) const throw(invalid_argument)
{

	uint32_t rows, columns, rows2, columns2;
	m.GetSize(rows, columns);
	this->GetSize(rows2, columns2);
	if (columns2 != rows) throw invalid_argument("incalid argument");
	for (unsigned int i = 0; i < rows2; i++)
	{
		for (unsigned int j = 0; j < columns; j++)
		{
			double s = 0;

			for (unsigned int k = 0; k < columns2; k++)
			{
				s = s + this->matrix[i][k] * m.matrix[k][j];
			}

		}
	}
}
void CMatrix::Mul(const double & scalar) throw(invalid_argument)
{

	for (unsigned int i = 0; i < rows; i++)
	{
		for (unsigned int j = 0; j < columns; j++)
		{
			matrix[i][j] = matrix[i][j] * scalar;

		}

	}
}

void CMatrix::Div(const double & scalar) throw(invalid_argument)
{
	for (unsigned int i = 0; i < rows; i++)
	{
		for (unsigned int j = 0; j < columns; j++)
		{
			matrix[i][j] = matrix[i][j] / scalar;

		}

	}
}

CMatrix::CMatrix(uint32_t rows, uint32_t columns)
{
	this->rows = rows;
	this->columns = columns;
	matrix = new double*[rows];
	for (unsigned int i = 0; i < rows; i++) {
		matrix[i] = new double[columns];
	}

	for (unsigned int n = 0; n < rows; n++)
	{
		for (unsigned int m = 0; m < columns; m++)
		{
			matrix[n][m] = 0;
		}
	}
}

CMatrix::CMatrix(uint32_t rows, uint32_t columns, double ** mat)
{


	matrix = new double*[rows];
	for (unsigned int i = 0; i < rows; i++) {
		matrix[i] = new double[columns];
	}

		for (uint32_t a = 0; a < rows; a++) {
			for (uint32_t b = 0; b < columns; b++) {
				matrix[a][b] = mat[a][b];
			}

		}

	this->rows = rows;
	this->columns = columns;
}

CMatrix::CMatrix(uint32_t rows, uint32_t columns, double * mat)
{


	matrix = new double*[rows];
	for (unsigned int i = 0; i < rows; i++) {
		matrix[i] = new double[columns];
	}
	for (unsigned int i = 0; i < rows; i++)
	{
		for (uint32_t a = 0; a < rows; a++) {
			for (uint32_t b = 0; b < columns; b++) {
				matrix[a][b] = *(mat + a*columns) + b;
			}

		}
		this->rows = rows;
		this->columns = columns;
	}
}

CMatrix::CMatrix(const CMatrix & M)
{

	uint32_t rows2, columns2;
	this->GetSize(rows2, columns2);
	M.GetSize(rows, columns);
	CMatrix new_macierz(rows, columns);

	for (uint32_t a = 0; a < rows; a++) {
		for (uint32_t b = 0; b < columns; b++) {
			new_macierz[a][b]=M.matrix[a][b];
		}
	}


}

CMatrix & CMatrix::operator=(const CMatrix & m)
{

	double ** n_mat = new double*[m.rows];
	for (unsigned int i = 0; i < m.rows; i++)
	{
		n_mat[i] = new double[m.columns];
	}



	for (unsigned int i = 0; i < m.rows; i++)
	{
		memcpy(n_mat[i], m.matrix[i], sizeof(double)*m.columns);
	}



	for (unsigned int i = 0; i < rows; i++)
	{
		delete[] matrix[i];
	}
	delete[] matrix;




	matrix = n_mat;

	rows = m.rows;
	columns = m.columns;


	return *this;

}

CMatrix::~CMatrix()
{
	for (unsigned int i = 0; i < rows; i++)
	{
		delete[] matrix[i];
	}
	delete[] matrix;
}

void CMatrix::GetSize(uint32_t & rows, uint32_t & columns) const
{
	columns = this->columns;
	rows = this->rows;


}

double & CMatrix::GetElement(uint32_t row, uint32_t column) throw(invalid_argument)
{
	if (rows < 0 || columns < 0) throw invalid_argument("invalid argument");
	return matrix[row][column];
	// TODOreturn;: tu wstawić instrukcję return
}

double * CMatrix::operator[](uint32_t row) throw(invalid_argument)
{
	return this->matrix[row];
}

CMatrix CMatrix::operator+(const CMatrix & m) const
{
	CMatrix matrix = CMatrix(this->rows, this->columns, this->matrix);
	matrix.Add(m);
	return matrix;
}

CMatrix & CMatrix::operator+=(const CMatrix & m)
{
	CMatrix matrix = *this;
	matrix.Add(m);
	return matrix;
}

CMatrix CMatrix::operator-(const CMatrix & m) const
{
	CMatrix matrix = CMatrix(this->rows, this->columns, this->matrix);
	matrix.Sub(m);
	return matrix;

}

CMatrix & CMatrix::operator-=(const CMatrix & m)
{
	CMatrix matrix = *this;
	matrix.Sub(m);
	return matrix;

}

CMatrix CMatrix::operator*(const CMatrix & m) const
{
	CMatrix matrix = CMatrix(this->rows, this->columns, this->matrix);
	matrix.Mul(m);
	return matrix;
}

CMatrix & CMatrix::operator*=(const CMatrix & m)
{
	CMatrix matrix = *this;
	matrix.Mul(m);
	return matrix;
}

CMatrix CMatrix::operator*(const double & scalar) const
{
	CMatrix matrix = CMatrix(this->rows, this->columns, this->matrix);
	matrix.Mul(scalar);
	return matrix;



}

CMatrix & CMatrix::operator*=(const double & scalar)
{
	CMatrix *mac = this;
	mac->Mul(scalar);
	return *mac;
}

CMatrix CMatrix::operator/(const double & scalar) const
{
	CMatrix mac = CMatrix(this->rows, this->columns, this->matrix);
	mac.Div(scalar);
	return mac;
}

CMatrix & CMatrix::operator/=(const double & scalar)
{
	CMatrix *mac = this;
	mac->Div(scalar);
	return *mac;
}

CMatrix CMatrix::operator-() const
{
	CMatrix mac = CMatrix(this->rows, this->columns, this->matrix);
	mac.Mul(-1);
	return mac;
}

CMatrix CMatrix::T() const
{
	CMatrix mac = CMatrix(this->rows, this->columns, this->matrix);
	for (unsigned int i = 0; i < rows; i++) {
		for (unsigned int j = 0; j < rows; j++)
			mac[j][i] = matrix[i][j];
		return mac;
	}
}

ostream & operator<<(ostream & stream, const CMatrix & m)
{
	return  stream;
}

CVector::CVector(uint32_t columns): CMatrix(columns,1)
{

}

CVector::CVector(uint32_t columns, double * mat):CMatrix(columns,1,matrix)
{

}

CVector & CVector::operator=(const CMatrix & m)
{
	return *this;
}