#include<iostream>

class Matrix
{
	private:
		int Zeilen;
		int Spalten;
		double** Eintrag;

		void recycle()
		{
			for(int i=0;i<Zeilen;++i)
			{
				delete[] Eintrag[i];
			}
			delete[] Eintrag;
		}

		void groesse()
		{
			Eintrag = new double*[Zeilen];
			for(int i=0;i<Zeilen;++i)
			{
				Eintrag[i] = new double[Spalten];
			}
		}

	public:
		Matrix(int z,int s,bool u=0) : Zeilen(z),Spalten(s),Eintrag(0)
		{
			groesse();

			for(int i=0;i<Zeilen;++i)
			{
				for(int j=0;j<Spalten;++j)
				{
					Eintrag[i][j] = (i==j)&&u;
				}
			}
		}

		Matrix(const Matrix& m) : Zeilen(m.Zeilen),Spalten(m.Spalten),Eintrag(0)
		{
			groesse();

			for(int i=0;i<Zeilen;++i)
			{
				for(int j=0;j<Spalten;++j)
				{
					Eintrag[i][j] = m.Eintrag[i][j];
				}
			}			
		}

		Matrix& operator=(const Matrix& m)
		{
			recycle();
			Zeilen = m.Zeilen;
			Spalten = m.Spalten;
			groesse();

			for(int i=0;i<Zeilen;++i)
			{
				for(int j=0;j<Spalten;++j)
				{
					Eintrag[i][j] = m.Eintrag[i][j];
				}
			}			
		}

		~Matrix()
		{
			recycle();
		}

		double eintrag(int z,int s) const
		{
			return Eintrag[z][s];
		}

		void eintrag(int z,int s,double e)
		{
			Eintrag[z][s] = e;
		}

		void skaliere(double x)
		{
			for(int i=0;i<Zeilen;++i)
			{
				for(int j=0;j<Spalten;++j)
				{
					Eintrag[i][j] *= x;
				}
			}	
		}

		double skalarprodukt(const Matrix& m,int z=0,int s=0) const
		{
			double e = 0;

			for(int j=0;j<Spalten;++j)
			{
				e += Eintrag[z][j]*m.Eintrag[j][s];
			}

			return e;	
		}

		void transponiere()
		{
			Matrix temp(*this);

			recycle();
			Zeilen = temp.Spalten;
			Spalten = temp.Zeilen;
			groesse();
			
			for(int i=0;i<Zeilen;++i)
			{
				for(int j=0;j<Spalten;++j)
				{
					Eintrag[i][j] = temp.Eintrag[j][i];
				}
			}			
		}

		Matrix& operator+=(const Matrix& m)
		{
			for(int i=0;i<Zeilen;++i)
			{
				for(int j=0;j<Spalten;++j)
				{
					Eintrag[i][j] += m.Eintrag[i][j];
				}
			}

			return *this;
		}

		Matrix& operator*=(const Matrix& m)
		{
			Matrix temp(*this);

			recycle();
			Spalten = m.Spalten;
			groesse();

			for(int i=0;i<Zeilen;++i)
			{
				for(int j=0;j<Spalten;++j)
				{
					Eintrag[i][j] = temp.skalarprodukt(m,i,j);
				}
			}

			return *this;		
		}

		double spur() const
		{
			double e = 0;

			for(int j=0;j<Zeilen;++j)
			{
				e += Eintrag[j][j];
			}

			return e;
		}

		double spur(const Matrix& m) const
		{
			double e = 0;

			for(int i=0;i<Zeilen;++i)
			{
				for(int j=0;j<Spalten;++j)
				{
					e += Eintrag[i][j]*m.Eintrag[j][i];
				}
			}

			return e;			
		}

		void print() const
		{
			for(int i=0;i<Zeilen;++i)
			{
				for(int j=0;j<Spalten;++j)
				{
					std::cout << Eintrag[i][j] << " ";
				}
				std::cout << std::endl;
			}
			std::cout << std::endl;	
		}
}; 


int main()
{
	Matrix a(4,4,1);

	a.eintrag(0,0,1.0); a.eintrag(0,1,4.0); a.eintrag(0,2,7.0); a.eintrag(0,3,4.0);
	a.eintrag(1,0,2.0); a.eintrag(1,1,6.0); a.eintrag(1,2,7.0); a.eintrag(1,3,3.0);
	a.eintrag(2,0,8.0); a.eintrag(2,1,3.0); a.eintrag(2,2,5.0); a.eintrag(2,3,1.0);
	a.eintrag(3,0,4.0); a.eintrag(3,1,8.0); a.eintrag(3,2,7.0); a.eintrag(3,3,9.0);
	a.print();

	Matrix b(2,4);

	b.eintrag(0,0,3.0); b.eintrag(0,1,1.0); b.eintrag(0,2,7.0); b.eintrag(0,3,3.0);
	b.eintrag(1,0,8.0); b.eintrag(1,1,3.0); b.eintrag(1,2,4.0); b.eintrag(1,3,5.0);	
	b.print();

	Matrix c = a;
	std::cout << a.spur(c) << std::endl;
	std::cout << (c*=a).spur() << std::endl << std::endl;

	b.transponiere();
	a.skaliere(9.0);
	a *= b;
	a.print();

	return 0;
}