/////////////////////////////////////////////////////////////////
//                                                             //
//                         TENPLATE MATRICE                    //
//                                                             //
//               Serban Alexandru-Claudiu Grupa 1067           //
//                                                             //
/////////////////////////////////////////////////////////////////


#include<stdio.h>
#include<conio.h>
#include<malloc.h>
#include<stdlib.h>
#include<iostream.h>
#include<fstream.h>


template <class T>
class Matrice
{
public:
	int m, n;
	T **a;

	Matrice<T>(int,int);
	Matrice<T>();
	Matrice<T>(char*);
	~Matrice<T>();
	Matrice<T> unu();
	Matrice<T> zero();
	Matrice<T> transpusa();
	Matrice<T> operator+(Matrice<T> b);
	Matrice<T> operator-(Matrice<T> b);
	Matrice<float> operator*(float nr);
	Matrice<T> operator*(Matrice<T> b);
	Matrice<float> operator/(float nr);
	Matrice<float> operator/(Matrice<T> b);
	T * operator[](int);
	Matrice<float> inversa();
	operator double();
	float * sol_sistem(int *);
	void scrie_fis();


	Matrice<T>(Matrice<T> &b)
	{
		m=b.m;
		n=b.n;
		a=(T **)malloc(m*sizeof(T *));
			for(int i=0; i<m; i++)
				a[i]=(T *)malloc(n*sizeof(T));
		for(i=0; i<m; i++)
			for(int j=0; j<n; j++)
				a[i][j]=b.a[i][j];
	}

	
	friend ostream & operator<<(ostream &iesire, Matrice<T> b)
	{
		for(int i=0; i<b.m; i++)
		{
			iesire<<endl;
			for(int j=0; j<b.n; j++)
				iesire<<" "<<b.a[i][j];
		}
		iesire<<endl;
		return iesire;
	}

	
	friend istream & operator>>(istream &intrare, Matrice<T> &b)
	{
		cout<<"\n m="; intrare>>b.m;
		cout<<" n="; intrare>>b.n;
		cout<<"\n";
		for(int i=0; i<b.m; i++)
			for(int j=0; j<b.n; j++)
			{
				cout<<"elem"<<"["<<i<<"]["<<j<<"]= ";
				intrare>>b.a[i][j];
			}
		return intrare;
	}

};


///////////////////////////////////////////////////////////////////////////////////

template<class T> T * Matrice<T>::operator[](int i)
{
	T *v;
	v=a[i];
	return v;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T>::Matrice<T>(int n1, int n2)
{
	m=n1; n=n2;
	a=(T **)malloc(m*sizeof(T *));
	for(int i=0; i<m; i++)
		a[i]=(T *)malloc(n*sizeof(T));
	for(i=0; i<m; i++)
		for(int j=0; j<n; j++)
			a[i][j]=0;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T>::Matrice<T>()
{
	printf("\n m="); scanf("%d",&m);
	printf(" n="); scanf("%d",&n);
	a=(T **)malloc(m*sizeof(T *));
	for(int i=0; i<m; i++)
		a[i]=(T *)malloc(n*sizeof(T));
	for(i=0; i<m; i++)
		for(int j=0; j<n; j++)
		{
			//printf(" a[%d][%d]=",i,j);
			//scanf("%T",&a[i][j]);
			cout<<"a["<<i<<"]["<<j<<"]= ";
			cin>>a[i][j];
		}
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T>::Matrice<T>(char *c)
{
	int nr_elem,i,j;
	FILE *f;
	T aux;
	
	f=fopen(c,"rb");
	fseek(f,0,SEEK_END);
	nr_elem=(ftell(f)-sizeof(int))/sizeof(T);
	fseek(f,0,SEEK_SET);
	fread(&m,sizeof(int),1,f);
	n=nr_elem/m;
	a=(T **)malloc(m*sizeof(T *));
   	for(i=0;i<m;i++)
   		a[i]=(T *)malloc(m*sizeof(T));
    for(i=0;i<m;i++)
		for(j=0;j<n;j++)
         {
			fread(&aux,sizeof(T),1,f);
			 a[i][j]=aux;
         }
   fclose(f);
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> void Matrice<T>::scrie_fis()
{
	FILE *f;
	int i,j;
		
	f=fopen("mat.cla","w+");
	fwrite(&m,sizeof(int),1,f);
	T k;
	for(i=0;i<m;i++)
		for(j=0;j<n;j++)
   		{
			k=a[i][j];
   			fwrite(&k,sizeof(T),1,f);
		}
	fclose(f);
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T>::~Matrice<T>()
{
	for(int i=0; i<m; i++)
		free(a[i]);
	free(a);
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::unu()
{
	int i,j;

	if(m!=n)
	{
		cout<<"\n Matricea nu este patratica!";
	}
	else	
	{
		for(i=0; i<m; i++)
			for(j=0; j<n; j++)
				if(i==j) a[i][i]=1;
				else a[i][j]=0;
	}
	return *this;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::zero()
{
	int i,j;
	for(i=0; i<m; i++)
		for(j=0; j<n; j++)
			a[i][j]=0;
	return *this;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::transpusa()
{
	Matrice<T> b(n,m);
	b.m=n;
	b.n=m;
	for(int i=0; i<n; i++)
		for(int j=0; j<m; j++)
			b.a[i][j]=a[j][i];
	return b;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::operator*(Matrice<T> b)
{
	int i,j,k;
	T atemp,btemp,ctemp;
	
	if(n!=b.m)
	{
		cout<<"\n Dimensiunile matricelor sunt incorecte!!";
		cout<<"\n Matricele nu se pot inmulti!!";
		Matrice<T> d(1,0);
		return d;
	}
	else
	{
		Matrice<T> c(m,b.n);
		for(i=0; i<c.m; i++)
			for(j=0; j<c.n; j++)
			{
				ctemp=0;
				for(k=0; k<b.m; k++)
				{
					atemp=a[i][k];
					btemp=b.a[k][j];
					ctemp=ctemp+atemp*btemp;
				}
				c.a[i][j]=ctemp;
			}
		return c;
	}
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<float> Matrice<T>::operator*(float nr)
{
	Matrice<float> c(m,n);
	c.m=m;
	c.n=n;
	for(int i=0; i<m; i++)
		for(int j=0; j<n; j++)
			c.a[i][j]=a[i][j]*nr;
	return c;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::operator+(Matrice<T> b)
{
	int i,j;
	if((m!=b.m)||(n!=b.n))
	{
		printf("\n Matricile au dimensiuni diferite!!");
		printf("\n Adunarea nu se poate efectua!!");
		Matrice<T> d(1,0);
		return d;
	}
	else
	{
		Matrice<T> c(m,n);
		c.m=m;
		c.n=n;
		for(i=0; i<m; i++)
			for(j=0; j<n; j++)
				c.a[i][j]=a[i][j]+b.a[i][j];
		return c;
	}
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::operator-(Matrice<T> b)
{
	int i,j;
	if((m!=b.m)||(n!=b.n))
	{
		printf("\n Matricile au dimensiuni diferite!!");
		printf("\n Scaderea nu se poate efectua!");
		Matrice<T> d(1,0);
		return d;
	}
	else
	{
		Matrice<T> c(m,n);
		c.m=m;
		c.n=n;
		for(i=0; i<m; i++)
			for(j=0; j<n; j++)
				c.a[i][j]=a[i][j]-b.a[i][j];
		return c;
	}
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<float> Matrice<T>::operator/(float nr)
{
	int i,j;
	Matrice<float> c(m,n);
	c.m=m;
	c.n=n;
	for(i=0; i<m; i++)
		for(j=0; j<n; j++)
			c.a[i][j]=(float)a[i][j]/nr;
	return c;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<float> Matrice<T>::operator/(Matrice<T> b)
{
	int i,j,k;
	float atemp,btemp,ctemp;
	if((m!=b.m)||(n!=b.n))
	{
		printf("\n Matricele nu au aceleasi dimensiuni!!");
		printf("\n Impartirea nu se poate efectua!!");
		Matrice<float> d(1,0);
		return d;
	}
	else
	{
		int m_inv=b.inversa().m;
		int n_inv=b.inversa().n;
		Matrice<float> inv(m_inv,n_inv);
		if((inv.m==1)&&(inv.n==0))
		{
			printf("\n Impartirea nu se poate efectua!!");
			Matrice<float> e(1,0);
			return e;
		}
		else
		{
			Matrice<float> c(b.m,b.n);
//			cout<<"\n INV B\n"<<b.inversa();
//			getch();
			for(i=0; i<m; i++)
				for(j=0; j<n; j++)
					inv.a[i][j]=b.inversa().a[i][j];
//			cout<<"\n INV \n"<<inv;
//			getch();
		
			for(i=0; i<m; i++)
			{
				for(j=0; j<n; j++)
				{
					ctemp=0;
					for(k=0; k<n; k++)
					{
						atemp=(float)a[i][k];
						btemp=inv.a[k][j];
						ctemp=ctemp+atemp*btemp;
					}
					c.a[i][j]=ctemp;
//					printf("\n a[%d][%d]=%.3f",i,j,c.a[i][j]);
				}
			}
			return c;
		}
	}
}


///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<float> Matrice<T>::inversa()
{

//cod=1 - exista inversa
//cod=2 - nu exista inversa
	
	float eps, btemp, atemp, amax, mod, c;
	int i,j,k,imax,vb=0,cod=1;

	Matrice<float> b(m,m);
	b.unu();
	Matrice<float> ca(m,m);
	for(i=0; i<m; i++)
		for(j=0; j<m; j++)
			ca.a[i][j]=(float)a[i][j];

	if(m!=n)
	{
		printf("\n Matricea nu este patratica!!");
		cod=2;
	}
	else
	{
		eps=float(0.00001);
		k=0; i=0; vb=0;
		do
		{
			if(k!=n-1)
			{
				amax=ca.a[k][k];
				if(amax<0) amax=-amax;
				imax=k;
				for(i=k+1; i<m; i++)
				{
					if(ca.a[i][k]<0) mod=-ca.a[i][k];
					else mod=ca.a[i][k];
					if(mod>amax)
					{
						amax=mod;
						imax=i;
					}

				}
				if(imax!=k)
					for(j=0; j<n; j++)
					{
						atemp=ca.a[imax][j];
						ca.a[imax][j]=ca.a[k][j];
						ca.a[k][j]=atemp;
						btemp=b.a[imax][j];
						b.a[imax][j]=b.a[k][j];
						b.a[k][j]=btemp;
					}
			}


			if(ca.a[k][k]<0) mod=-ca.a[k][k];
			else mod=ca.a[k][k];
			
			if(mod<=eps)
			{
				cod=2;
				vb=1;
			}
			else
			{
				c=ca.a[k][k];
				for(j=0; j<n; j++)
				{
					ca.a[k][j]=ca.a[k][j]/c;
					b.a[k][j]=b.a[k][j]/c;
				}
				for(i=0; i<n; i++)
					if(i!=k)
					{
						c=-ca.a[i][k];
						for(j=0; j<n; j++)
						{
							ca.a[i][j]=ca.a[i][j]+c*ca.a[k][j];
							b.a[i][j]=b.a[i][j]+c*b.a[k][j];
						}
					}
				
				k=k+1;
				if(k>n-1)
				{
					cod=1;
					vb=1;
				}
			}
		}
		while(vb==0);
	}

	if (cod==2)
	{
		printf("\n Nu exista inversa!");
		Matrice<float> d(1,0);
		return d;
	}
	else return b;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T>::operator double()
{
	float eps;
	double det;
	float amax, atemp, c;
	int i,j,k,imax,vb=0,cod=1;

	if(m!=n)
	{
		printf("\n Matricea nu este patratica!!");
		printf("\n Nu exista determinantul!!");
		return 0xfffffff;
	}
	else
	{
		Matrice<float> ca(m,n);
		for(i=0; i<m; i++)
			for(j=0; j<m; j++)
				ca.a[i][j]=(float)a[i][j];

		eps=float(0.00001);
		k=0; i=0; vb=0; det=1;
		
		do
		{
			if(k!=n-1)
			{
				amax=ca.a[k][k];
				if(amax<0) amax=-amax;
				imax=k;
				for(i=k+1; i<m; i++)
				{
					if(ca.a[i][k]<0) c=-ca.a[i][k];
					else c=ca.a[i][k];
					if(c>amax)
					{
						amax=c;
						imax=i;
					}

				}
				if(imax!=k)
				{
					det=-det;
					for(j=0; j<n; j++)
					{
						atemp=ca.a[imax][j];
						ca.a[imax][j]=ca.a[k][j];
						ca.a[k][j]=atemp;
					}
				}
			}


			if(ca.a[k][k]<0) c=-ca.a[k][k];
			else c=ca.a[k][k];
			
			if(c<=eps)
			{
				cod=2;
				vb=1;
			}
			else
			{
				c=ca.a[k][k];
				det=det*c;
				for(j=0; j<n; j++) ca.a[k][j]=ca.a[k][j]/c;
				for(i=0; i<n; i++)
					if(i!=k)
					{
						c=-ca.a[i][k];
						for(j=0; j<n; j++) ca.a[i][j]=ca.a[i][j]+c*ca.a[k][j];
					}
				
				k=k+1;
				if(k>n-1)
				{
					cod=1;
					vb=1;
				}
			}
		}
		while(vb==0);
	}

	if(cod==2) 
	{
		printf("\n Det se aprox nul!!"); 
		return det=0;
	}
	if(cod==1) return det;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> float * Matrice<T>::sol_sistem(int * cod)
{

// cod=1: s-a obtinut solutia
// cod=2: solutia nu este unica
// cod=3: matricea nu este patratica

	float eps, atemp, amax, c;
	float *x;
	int i, j, k, imax, vb;
	Matrice<float> a1(m,n+1);
	x=(float *)malloc(m*sizeof(float));
	printf("\n Introduceti termenii liberi:\n");
	for(i=0; i<m; i++)
	{
		//printf(" b[%d]=",i);
		//scanf("%f",&x[i]);
		cout<<" b["<<i<<"]=";
		cin>>x[i];
	}

	eps=float(0.00001);
	
	if(m!=n) *cod=3;
	else
	{
		for(i=0; i<m; i++)
		{
			for(j=0; j<n; j++)
				a1.a[i][j]=(float)a[i][j];
			a1.a[i][n]=x[i];
		}

		k=0; vb=0;

		do
		{
			if(k!=n-1)
			{
				amax=a1.a[k][k];
				if(amax<0) amax=-amax;
				imax=k;
				for(i=k+1; i<m; i++)
				{
					if(a1.a[i][k]<0) c=-a1.a[i][k];
					else c=a1.a[i][k];
					if(c>amax)
					{
						amax=c;
						imax=i;
					}
				}
				if(imax!=k)
				{
					for(j=k; j<n+1; j++)
					{
						atemp=a1.a[imax][j];
						a1.a[imax][j]=a1.a[k][j];
						a1.a[k][j]=atemp;
					}
				}				
			}

			if(a1.a[k][k]<0) c=-a1.a[k][k];
			else c=a1.a[k][k];
			
			if(c<=eps)
			{
				vb=1; 
				*cod=2;
			}
			else
			{
				c=a1.a[k][k];
				for(j=k; j<n+1; j++)
					a1.a[k][j]=a1.a[k][j]/c;
				for(i=0; i<n; i++)
					if(i!=k)
					{
						c=-a1.a[i][k];
						for(j=k; j<n+1; j++)
							a1.a[i][j]=a1.a[i][j]+c*a1.a[k][j];
					}

				k=k+1;
				if(k>n-1)
				{
					for(i=0; i<n; i++)
						x[i]=a1.a[i][n];
					vb=1; *cod=1;
				}
			}
		}
		while(vb==0);
	}
	if(*cod==1) return x;
	if(*cod!=1) return NULL;

}

///////////////////////////////////////////////////////////////////////////////////


void main()
{
	float nr_int, nr_float;
	float *sol_int, *sol_float;
	double deta_int, deta_float;

	ios::sync_with_stdio();

	cout<<"\n--------------------------------------------------------------------------------\n";
	cout<<"                             MATRICE CU ELEMENTE INTREGI\n\n";

	printf("\n Introduceti prima matrice:");
	Matrice<int> a;
	printf("\n Introduceti a doua matrice:");
	Matrice<int> b;


	
	cout<<"\n Elementul a[0][0] din prima matrice este: "<<a[0][0]<<"\n";
	getch();
	
	printf("\n Suma matricelor:\n");
	cout<<a+b;
	getch();


	printf("\n Diferenta matricelor:\n");
	cout<<a-b;
	getch();

	printf("\n Produsul matricelor:\n");
	cout<<a*b;
	getch();

	printf("\n Impartirea matricelor: \n");
	cout<<a/b;
	getch();

	cout<<"\n Introduceti un numar: ";
	cin>>nr_int;
	cout<<"\n Produsul primei matrice cu numarul "<<nr_int<<" este:\n";
	cout<<a*nr_int;
	getch();

	cout<<"\n Rezultatul impartirii primei matrice la numarul "<<nr_int<<" este:\n";
	cout<<a/nr_int;
	getch();

	printf("\n Calculul determinantului primei matrice:\n");
	deta_int=double(a);
	if(deta_int!=0xfffffff) printf("\n Determinantul este: %lf\n",deta_int);
	getch();

	printf("\n\n Transpusa primei matrice:\n");
	cout<<a.transpusa();
	getch();

	printf("\n Inversa primei matrice:\n");
	cout<<a.inversa();
	getch();
	
	printf("\n Calculul solutiilor sistemului dat de prima matrice:\n");
	int cod=1;
	sol_int=a.sol_sistem(&cod);
	
	if(cod==1)
	{
		printf("\n Solutiile sistemului sunt:\n");
		for(int i=0; i<a.m; i++)
		{
			printf("\n x%d=",i+1);
			printf(" %.3f",sol_int[i]);
		}
	}
	if(cod==2) printf("\n Solutia nu este unica!!");
	if(cod==3) printf("\n Matricea nu este patratica!!");
	printf("\n");
	getch();

	printf("\n Scriu matricea a in fisierul mat.cla.\n");
	a.scrie_fis();
	getch();

	printf("\n Citesc matricea c din fisier (constructor din fisier).\n");
	Matrice<int> c("mat.cla");
	getch();
	
	printf("\n Afisez matricea c citita din fisier:\n");
	cout<<c;
	getch();

	system("cls");
	cout<<"\n--------------------------------------------------------------------------------\n";
	cout<<"                             MATRICE CU ELEMENTE REALE\n\n";

	printf("\n Introduceti prima matrice:");
	Matrice<float> a1;
	printf("\n Introduceti a doua matrice:");
	Matrice<float> b1;


	
	cout<<"\n Elementul a[0][0] din prima matrice este: "<<a1[0][0]<<"\n";
	getch();
	
	printf("\n Suma matricelor:\n");
	cout<<a1+b1;
	getch();


	printf("\n Diferenta matricelor:\n");
	cout<<a1-b1;
	getch();

	printf("\n Produsul matricelor:\n");
	cout<<a1*b1;
	getch();

	printf("\n Impartirea matricelor: \n");
	cout<<a1/b1;
	getch();

	cout<<"\n Introduceti un numar: ";
	cin>>nr_float;
	cout<<"\n Produsul primei matrice cu numarul "<<nr_float<<" este:\n";
	cout<<a1*nr_float;
	getch();

	cout<<"\n Rezultatul impartirii primei matrice la numarul "<<nr_float<<" este:\n";
	cout<<a1/nr_float;
	getch();

	printf("\n Calculul determinantului primei matrice:\n");
	deta_float=double(a1);
	if(deta_float!=0xfffffff) printf("\n Determinantul este: %lf\n",deta_float);
	getch();

	printf("\n\n Transpusa primei matrice:\n");
	cout<<a1.transpusa();
	getch();

	printf("\n Inversa primei matrice:\n");
	cout<<a1.inversa();
	getch();
	
	printf("\n Calculul solutiilor sistemului dat de prima matrice:\n");
	cod=1;
	sol_float=a1.sol_sistem(&cod);
	
	if(cod==1)
	{
		printf("\n Solutiile sistemului sunt:\n");
		for(int i=0; i<a1.m; i++)
		{
			printf("\n x%d=",i+1);
			printf(" %.3f",sol_float[i]);
		}
	}
	if(cod==2) printf("\n Solutia nu este unica!!");
	if(cod==3) printf("\n Matricea nu este patratica!!");
	printf("\n");
	getch();

	printf("\n Scriu matricea a in fisierul mat.cla.\n");
	a1.scrie_fis();
	getch();

	printf("\n Citesc matricea c din fisier (constructor din fisier).\n");
	Matrice<float> c1("mat.cla");
	getch();
	
	printf("\n Afisez matricea c citita din fisier:\n");
	cout<<c1;

	getch();
}