#include <iostream>
#include<math.h>
#include<assert.h>

class Matrica;

class Matrica {
private:
	int dx,dy;
	float** mat;

	//alokacija potrebne memorije
	void Alokacija() {
		mat = new float*[dx];
		for( int i = 0; i < dx; i++ )
			mat[i] = new float[dy];
	}

	//rekurzivna funkcija koja racuna determinantu matrice
	float Det( Matrica m, int n ) {
		float det = 0.0f;
		
		if( n < 1 ) { /*Greska!*/}
		else if( n == 1 ) det = m(0,0);
		else if ( n == 2 ) det = m(0,0) * m(1,1) - m(1,0) * m(0,1);
		else {		
			for( int k = 0; k < n; k++ ) {
				Matrica temp( n-1, n-1 );
				for( int i = 1; i < n; i++ ) {
					for( int j = 0, l = 0; j < n; j++ ) {
						if( j != k ) {
							temp(i-1,l) = m(i,j);
							l++;
						}
					}
				}
				det += pow(-1.0, k )*m(0,k)*Det( temp, n-1 );
			}
		}
		return det;
	}
public:
	//konstruktori
	Matrica( int dX, int dY ) : dx( dX ), dy( dY ) {
		Alokacija();
		for( int i = 0; i < dx; i++ ) {
			for( int j = 0; j < dy; j++ )  
				mat[i][j] = 0;
		}
	}
	Matrica() {
		Matrica( 1, 1 );
	}
	Matrica( const Matrica& m ) : dx( m.dx ), dy( m.dy ) {
		Alokacija();
		for( int i = 0; i < dx; i++ ) {
			for( int j = 0; j < dy; j++ )  
				mat[i][j] = m.mat[i][j];
		}	
	}
	~Matrica() {
		for( int i = 0; i < dx; i++ ) 
			delete [] mat[i];
		delete [] mat;
	}

	//operator dodele
	Matrica& operator=( const Matrica m ) {
		if( &m != this ) {
			if( dx != m.dx || dy != m.dy ) {
				this->~Matrica();
				dx = m.dx;
				dy = m.dy;
				Alokacija();
			}
			for( int i = 0; i < dx; i++ ) {
				for( int j = 0; j < dy; j++ )
					mat[i][j] = m.mat[i][j];
			}
		}
		return *this;
	}

	//sabiranje matrica
	Matrica& operator+=( const Matrica m ) {
		assert( dx == m.dx && dy == m.dy );
		for( int i = 0; i < dx; i++ ) {
			for( int j = 0; j < dy; j++ )
				mat[i][j] += m.mat[i][j];
		}
		return *this;
	}
	Matrica operator+( const Matrica m ) {
		Matrica temp( *this );
		return( temp += m );
	}

	//pristup elementu matrice
	float& operator()( int x, int y ) {
		assert( x >= 0 && x < dx );
		assert( y >= 0 && y < dy );
		return mat[x][y];
	}

	//mnozenje matrica
	friend Matrica operator*( const Matrica& m1, const Matrica& m2 ) {
		assert( m1.dy == m2.dx );

		Matrica proizvod( m1.dx, m2.dy );

		for( int i = 0; i < proizvod.dx; i++ ) {
			for( int j = 0; j < proizvod.dy; j++ ) {
				for( int k = 0; k < m1.dy; k++ )
					proizvod.mat[i][j] += m1.mat[i][k]*m2.mat[k][j];
			}
		}
		return proizvod;
	}
	//mnozenje matrice skalarom
	friend Matrica operator*( const Matrica& m1, float c ) {
		Matrica proizvod( m1 );

		for( int i = 0; i < proizvod.dx; i++ ) {
			for( int j = 0; j < proizvod.dy; j++ ) 
				proizvod.mat[i][j] = m1.mat[i][j]*c;
		}
		return proizvod;
	}
	friend Matrica operator*( float c, const Matrica& m2 ) {
		return m2*c;
	}

    //transponovana matrica
	Matrica Transponat() {
		Matrica temp( dy, dx );

		for( int i = 0; i < dx; i++ ) {
			for( int j = 0; j < dy; j++ )
				temp.mat[j][i] = mat[i][j];
		}

		return temp;
	}
	//determinanta matrice
	float Determinanta() {
		assert( dx == dy );
		return Det( *this, dx );
	}
	//inverz matrice
	Matrica Inverz() {
		assert( dx == dy );
		Matrica inverz( dx, dx );
		float det = Determinanta();

		//racunamo matricu kofaktora
		for( int i = 0; i < dx; i++ ) {
			for( int j = 0; j < dx; j++ ) {
				Matrica temp( dx-1, dx-1 );
				
				int m = 0;
				for( int k = 0; k < dx; k++ ) {
					if( k == i ) continue;
					int n = 0;
					for( int l = 0; l < dx; l++ ) {
						if( l == j ) continue;
						temp(m,n) = mat[k][l];
						n++;
					}
					m++;
				}
				inverz(i,j) = pow( -1.0, i+j )*temp.Determinanta();
			}
		}
		//adjungovana matrica
		inverz = inverz.Transponat();

		return (1/det)*inverz;
	}

	//ispisujemo matricu
	void StampajMatricu() {
		for( int i = 0; i < dx; i++ ) {
			for( int j = 0; j < dy; j++ )
				cout<<mat[i][j]<<" ";
			cout<<endl;
		}
	}
};