inline matrix::matrix()
{
	 pArray= new Array(0,0);


}

inline matrix::matrix( unsigned int k)
{
 pArray= new Array(0,k);

}
inline matrix::matrix(unsigned int w,unsigned int k)
{
	pArray=new Array(w,k);

}

 inline matrix::matrix(const matrix &pm)
{
	pm.pArray->n++;
	for(int i=0;i<pArray->w;i++)
	{
		for(int j=0;j<pArray->k;j++)
		{
			pArray->m[i][j]=pm.pArray->m[i][j];
		}
	}
}


inline matrix::~matrix()
{
	if(--pArray->n==0)
	delete pArray;
}


  /*---------------------------------------------------------------------*/
  matrix  matrix:: operator+(const matrix &pm) const
  {

  	if(pArray->k!=pm.pArray->k || pArray->w!=pm.pArray->w)
  	{
  	cout<<"Macierzy nie sa rowne!"<< endl;
  	exit(1);
	}
  	 matrix plus(pArray->w,pArray->k);
  	 for( int i=0;i<pArray->w;i++)
    {
    	for(int j=0;j<pArray->k;j++)
    	{
    		plus.pArray->m[i][j]=pArray->m[i][j]+pm.pArray->m[i][j];
    	}
    }
    return plus;
  }



  /*---------------------------------------------------------------------*/

  matrix  matrix::operator-(const matrix &pm) const
  {

  	if(pArray->k!=pm.pArray->k || pArray->w!=pm.pArray->w)
  	{
  	cout<<"Macierzy nie sa rowne!"<< endl;
  	exit(1);
	}
  	matrix minus (pArray->w,pArray->k);
  	 for( int i=0;i<pArray->w;i++)
    {
    	for(int j=0;j<pArray->k;j++)
    	{
    		minus.pArray->m[i][j]=pArray->m[i][j]-pm.pArray->m[i][j];
    	}
    }
    return minus;
  }

 matrix & matrix::operator=(const matrix & pm)
{
  if(--pArray->n == 1)//mozemy zwolnic i zaalokowac nowa pamiec
  {
  pm.pArray->n++;
  for(int i=0;i<pArray->w;i++)
  delete pArray->m[i];
    delete pArray->m;
	pArray=pm.pArray;
  }
  else // po prostu tworzymy nowa tablice
  {
  	Array * t=new Array(pArray->w,pArray->k);
  	pArray->n=1;
  }
  return *this;

}



  /* matrix  matrix::operator*(const matrix &pm) const
  {

    if(pArray->k != pm.pArray->w )
    {
        cout << "Blad: Nie da sie pomnozyc tych macierzy" <<endl;
        return 0;
    }

    matrix Multiplication(pm.pArray->w, pArray->k);
    double sum=0;
    for(int j = 0; j < pm.pArray->w; j++)
    {
        for(int i = 0; i < pArray->k; i++)
        {
            for(int a=0; ;a++)
            {
                if(a== pm.pArray->w || a == pArray->k )
                    break;

                 sum+= pm.pArray->m[a][i] * pArray->m[j][a];
                Multiplication.pArray->m[j][i] = sum;
            }
                sum = 0;
        }
    }

    return Multiplication;

  }
  */
  matrix & matrix :: operator +=( const matrix &m)
  {
   if(pArray->k!=m.pArray->k || pArray->w!=m.pArray->w)
   {
   	{
  	cout<<"Macierzy nie sa rowne!"<< endl;
  	exit(1);
	}
	if(pArray->n=0) // n=0 -> zwalniamy pamiec
	{
		for( int i=0;i<pArray->w;i++)
		delete [] pArray->m[i];
		delete [] pArray->m;
	}
   if else(pArray->n==1)
	{
	for( int i=0;i<pArray->w;i++)
    {
    	for(int j=0;j<pArray->k;j++)
    	{
    		pArray->m[i][j]=pArray->m[i][j]+m.pArray->m[i][j];
    	}

	}
	}
	else
	{
	Array * t= new Array(pArray->w, pArray->k);
	for( int i=0;i<pArray->w;i++)
    {
    	for(int j=0;j<pArray->k;j++)
    	{
    		t->m[i][j]=t->m[i][j]+m.pArray->m[i][j];
    		pArray->n=1;
    		pArray=t;
    	}
   }

  	return 	*this;
  }


  matrix & matrix :: operator -=( const matrix *pm)
  {
    if(pArray->k!=m.pArray->k || pArray->w!=m.pArray->w)
   {
   	{
  	cout<<"Macierzy nie sa rowne!"<< endl;
  	exit(1);
	}
	if(pArray->n=0) // n=0 -> zwalniamy pamiec
	{
		for( int i=0;i<pArray->w;i++)
		delete [] pArray->m[i];
		delete [] pArray->m;
	}
   if else(pArray->n==1)
	{
	for( int i=0;i<pArray->w;i++)
    {
    	for(int j=0;j<pArray->k;j++)
    	{
    		pArray->m[i][j]=pArray->m[i][j]-m.pArray->m[i][j];
    	}

	}
	}
	else
	{
	Array * t= new Array(pArray->w, pArray->k);
	for( int i=0;i<pArray->w;i++)
    {
    	for(int j=0;j<pArray->k;j++)
    	{
    		t->m[i][j]=t->m[i][j]-m.pArray->m[i][j];
    		pArray->n=1;
    		pArray=t;
    	}
   }
  	return 	*this;
  }


  /*---------------------------------------------------------------------*/





  /*---------------------------------------------------------------------*/


 ostream& operator<<(ostream& Out, const matrix& pm)
{
	 for( int i=0;i<pm.pArray->w;i++)
    {
    	for(int j=0;j<pm.pArray->k;j++)
    	{
    		Out<< pm.pArray->m[i][j]<<"\t";
			Out<<"\n";
		}
	}
	return Out;
}

istream & operator >> (istream & in, const matrix & pm)
{
	for( int i=0;i<pm.pArray->w;i++)
    {
    	for(int j=0;j<pm.pArray->k;j++)
    	{
    		in>> pm.pArray->m[i][j];
		}
	}
	return in;

}
  bool matrix::operator ==(const matrix & pm) const
{
    for(int j = 0; j < pm.pArray->k; j++)
    {
        for(int i = 0; i <pm.pArray-> w; i++)
        {
            if(pArray->m[j][i] != pm.pArray->m[j][i])
                return false;
        }
    }

    return true;
}
/* inline void matrix :: read (unsigned  int i, unsigned int j)
{

}


*/








/*matrix& matrix::operator=(const double *)*/

/*matrix::matrix(const  double * )*/


double matrix::operator()(unsigned int i,unsigned int j) const
{
  return pArray->m[i][j];
}

matrix::Dref matrix::operator()(unsigned int i, unsigned int j)
{
  return Dref(*this,i,j);
}