// marMatrix.cpp: implementation of the marMatrix class.
//
//////////////////////////////////////////////////////////////////////

#include "marMatrix.h"
#include <assert.h>

//////////////////////////////////////////////////////////////////////
// Construction
//////////////////////////////////////////////////////////////////////
marMatrix::marMatrix(size_t size1, size_t size2)
	:shallowCopy(false)
{
	_size1=size1;
	_size2=size2;
	_data=new double[_size1*_size2];
}

marMatrix::marMatrix(double *data, size_t size1, size_t size2)
	:shallowCopy(true)
{
	if (size1==0 || size2==0)
	{
		assert(false);
	}
	else
	{
		_size1=size1;
		_size2=size2;
		_data=data;

// PS -> 		size_t iMax=_size1*_size2;
// PS -> 		_data=new double[iMax];
// PS -> 
// PS -> 		for (int i=0;i<iMax;i++)
// PS -> 		{
// PS -> 			_data[i]=data[i];
// PS -> 		}

	}
}


marMatrix::marMatrix(const marMatrix &m)
	:shallowCopy(false)
{
	if (m._size1==0 || m._size2==0)
	{
		assert(false);
	}
	else
	{
		_size1=m._size1;
		_size2=m._size2;

		size_t iMax=_size1*_size2;
		_data=new double[iMax];

		int i;
		for (i=0;i<iMax;i++)
		{
			_data[i]=m._data[i];
		}
	}
}

//////////////////////////////////////////////////////////////////////
// Destruction
//////////////////////////////////////////////////////////////////////
marMatrix::~marMatrix()
{
	if (!shallowCopy) 
	{
		delete _data;
	}
	else
	{
		_data=NULL;
	}
}

//////////////////////////////////////////////////////////////////////
// Opérateurs
//////////////////////////////////////////////////////////////////////
// ---------------------------------------------------------------------
/*Affichage*/
std::ostream& operator<<(std::ostream& os,const marMatrix& m)
{
	int i,j;
	for (i =0;i<m._size1;i++)
	{
		for (j =0;j<m._size2;j++)
		{
			os << " " << m._data[i*m._size2+j];
		}
		os << "\n";
	}
    return(os);
}

// ---------------------------------------------------------------------
/*Casting*/
marMatrix::operator double*() const 
{ 
	return(_data);
}

// ---------------------------------------------------------------------
/*Indexation*/
double& marMatrix::operator()(size_t i, size_t j) 
{ 
	return(_data[i*_size2+j]);
}

const double& marMatrix::operator()(size_t i, size_t j) const
{
	return(_data[i*_size2+j]);
}

// ---------------------------------------------------------------------
/*Affectation*/
marMatrix& marMatrix::operator=(const marMatrix& o)
{
	_size1=o._size1;
	_size2=o._size2;
	if (!(_data==NULL)&&(!shallowCopy))
	{
		delete _data;
	}
	shallowCopy=false;
	size_t iMax=_size1*_size2;
	_data=new double[iMax];

	int i;
	for (i=0;i<iMax;i++)
	{
		_data[i]=o._data[i];
	}
	return (*this);
}

marMatrix& marMatrix::operator=(double o)
{
	if (_size1!=0 && _size2!=0)
	{
		if (!(_data==NULL)&&(!shallowCopy))
		{
			delete _data;
		}
		shallowCopy=false;
		size_t iMax=_size1*_size2;
		_data=new double[iMax];
		for (int i=0;i<iMax;i++)
		{
			_data[i]=o;
		}
	}
	else
	{
		assert(false);
	}
	return (*this);
}

marMatrix& marMatrix::operator=(double*o)
{
	if (_size1!=0 && _size2!=0)
	{
		if (!(_data==NULL)&&(!shallowCopy))
		{
			delete _data;
		}
		shallowCopy=false;
		size_t iMax=_size1*_size2;
		_data=new double[iMax];
		for (int i=0;i<iMax;i++)
		{
			_data[i]=o[i];
		}
	}
	else
	{
		assert(false);
	}
	return (*this);
}

// ---------------------------------------------------------------------
/*Comparaison*/
bool marMatrix::operator==(const marMatrix& o) const
{
    bool equal=true;
	
    if(_size1!=o._size1 || _size2!=o._size2)
	{
		return(false);
	}
	size_t iMax=_size1*_size2;

	for (int i=0;i<iMax && equal;i++)
	{
		equal=equal && (_data[i]==o._data[i]); 
	}
    return(equal);
}

bool marMatrix::operator!=(const marMatrix& o) const
{
	return(!((*this)==o));
}

// ---------------------------------------------------------------------
/*Addition*/
marMatrix marMatrix::operator+(const marMatrix& o)
{
	marMatrix result(*this);
	
	if ((o._size1!=result._size1) 
		|| (result._size1==0) 
		|| (o._size2!=result._size2) 
		|| (result._size2==0))
	{
		assert(false);
	}
	else 
	{
		size_t iMax=result._size1*result._size2;
		int i;
		for (i=0 ; i < iMax ; i++)
		{
			result._data[i]+=o._data[i];
		}
	}
	return result;
}

marMatrix marMatrix::operator+(double o)
{
	marMatrix result(*this);
	
	if ((result._size1==0) || (result._size2==0))
	{
		assert(false);
	}
	else 
	{
		size_t iMax=result._size1*result._size2;
		int i;
		for (i=0;i < iMax;i++)
		{
			result._data[i]+=o;
		}
	}
	return result;
}

marMatrix marMatrix::operator+(double*o)
{
	marMatrix result(*this);
	
	if ((result._size1==0) || (result._size2==0))
	{
		assert(false);
	}
	else 
	{
		size_t iMax=result._size1*result._size2;
		int i;
		for (i=0;i < iMax;i++)
		{
			result._data[i]+=o[i];
		}
	}
	return result;
}

// ---------------------------------------------------------------------
/*Soustraction*/
marMatrix marMatrix::operator-(const marMatrix& o)
{
	marMatrix result(*this);
	
	if ((o._size1!=result._size1) 
		|| (result._size1==0) 
		|| (o._size2!=result._size2) 
		|| (result._size2==0))
	{
		assert(false);
	}
	else 
	{
		size_t iMax=result._size1*result._size2;
		int i;
		for (i=0;i < iMax;i++)
		{
			result._data[i]-=o._data[i];
		}
	}
	return result;
}

marMatrix marMatrix::operator-(double o)
{
	marMatrix result(*this);
	
	if ((result._size1==0) || (result._size2==0))
	{
		assert(false);
	}
	else 
	{
		size_t iMax=result._size1*result._size2;
		int i;
		for (i=0;i < iMax;i++)
		{
			result._data[i]-=o;
		}
	}
	return result;
}

marMatrix marMatrix::operator-(double*o)
{
	marMatrix result(*this);
	
	if ((result._size1==0) || (result._size2==0))
	{
		assert(false);
	}
	else 
	{
		size_t iMax=result._size1*result._size2;
		int i;
		for (i=0;i < iMax;i++)
		{
			result._data[i]-=o[i];
		}
	}
	return result;
}

// ---------------------------------------------------------------------
/*Multiplication (produit scalaire)*/
marMatrix marMatrix::operator*(double o)
{
	marMatrix result(*this);
	
	if ((result._size1==0) || (result._size2==0))
	{
		assert(false);
	}
	else 
	{
		size_t iMax=result._size1*result._size2;
		int i;
		for (i=0;i < iMax;i++)
		{
			result._data[i]*=o;
		}
	}
	return result;
}

marMatrix marMatrix::operator*(const marMatrix &o)
{
	size_t mA=_size1;
	size_t nA=_size2;
	size_t mB=o._size1;
	size_t nB=o._size2;
	size_t mR=mA;
	size_t nR=nB;

	marMatrix result(mR,nR);
	result=0.0;

	int k,i,j;
	if (nA==mB)
	{
		for (k=0;k<nA;k++)
		{
			for (i=0;i<mR;i++)
			{
				for (j=0;j<nR;j++)
				{
					result(i,j)+=(*this)(i,k)*o(k,j);
				}
			}
		}
	}
	else
	{
		assert(false);
	}
	return result;
}

marVector marMatrix::operator*(const marVector &o)
{
	marVector result(_size1);
	if (o.size()!=_size2)
	{
		assert(false);
	}
	else
	{
		marMatrix resultM(_size1,1);
		marMatrix B((double*)o,o.size(),1);
		resultM=(*this)*B;
		result=(double*)resultM;
	}
	return result;
}

//////////////////////////////////////////////////////////////////////
// Méthodes
//////////////////////////////////////////////////////////////////////
size_t marMatrix::rows() const
{
    return _size1; 
}

size_t marMatrix::columns() const
{
	return _size2;
}