Лабораторная работа №7 / MATRIX

#ifndef            MATRIX
#define            MATRIX
#include           <iostream.h>

template<class TYPE>
class TMatrix
{
public:
   TMatrix                      ();                //конструктор по умолчанию
   TMatrix                      (TMatrix &);       //конструктор копирования
   TMatrix                      (int, int);        //конструктор с заданием размера
   ~TMatrix                     ();                //деструктор
   void            init         (TYPE c);          //инициализация числом
   void            setSize      (int, int);        //установка размера
   int             getSizeRow   ();                //кол-во строк
   int             getSizeCol   ();                //кол-во столбцов
   TYPE &          operator()   (int, int);        //элемент матрицы
   TYPE &          operator[]   (int);             //элемент матрицы-вектора
   TMatrix &       operator=    (TMatrix &);       //присваивание
   TMatrix         operator+    (TMatrix &);       //сложение матриц
   TMatrix         operator-    (TMatrix &);       //вычитание матриц
   TMatrix         operator*    (TMatrix &);       //умножение матриц
   TMatrix         getTranspose ();                //транспонирование
   TMatrix &       setSingle    (int n);           //сделать единичной
   TMatrix         operator*    (TYPE);            //работа со скалярами
   TMatrix         operator/    (TYPE);
   int             writeArray   ();					//вывод матрицы
private:
   TYPE **         array;                          //элементы матрицы
   int             sizeRow;                        //кол-во строк
   int             sizeCol;                        //кол-во столбцов
};

template<class TYPE>
TMatrix<TYPE>::TMatrix()
{
   array=NULL;
   sizeRow=0;
   sizeCol=0;
}


template<class TYPE>
TMatrix<TYPE>::TMatrix(TMatrix<TYPE> &m)
{
   array=NULL;
   sizeRow=0;
   sizeCol=0;

   if(m.sizeRow>0 && m.sizeCol>0)
   {
      sizeRow=m.sizeRow;
      sizeCol=m.sizeCol;

      array=new TYPE*[sizeRow];

      for(int i=0; i<sizeRow; i++)
      {
	 array[i]=new TYPE[sizeCol];
      }

      for(i=0; i<sizeRow; i++)
      {
	 for(int j=0; j<sizeCol; j++)
	 {
	    array[i][j]=m.array[i][j];
	 }
      }
   }
   
}

template<class TYPE>
TMatrix<TYPE>::TMatrix(int row, int col)
{
   array=NULL;
   sizeRow=0;
   sizeCol=0;

   if(row>0 && col>0)
   {
      sizeRow=row;
      sizeCol=col;

      array=new TYPE*[sizeRow];

      for(int i=0; i<sizeRow; i++)
      {
	 array[i]=new TYPE[sizeCol];
      }
   }
   
}

template<class TYPE>
TMatrix<TYPE>::~TMatrix()
{
   if(array!=NULL)
   {
      for(int i=0; i<sizeRow; i++)
      {
	 if(array[i]!=NULL)
	 {
	    delete [] array[i];
	 }
      }

      delete [] array;
   }
}


template<class TYPE>
TMatrix<TYPE> &TMatrix<TYPE>::operator=(TMatrix<TYPE> &m)
{
   if(sizeRow==0 && sizeCol==0)
      {
		sizeRow=m.sizeRow;
		sizeCol=m.sizeCol;

		array=new TYPE*[sizeRow];

		for(int i=0; i<sizeRow; i++)
		{
			array[i]=new TYPE[sizeCol];
		}
		}

		if(sizeRow==m.sizeRow && sizeCol==m.sizeCol)
		{
		for(int i=0; i<sizeRow; i++)
		{
			for(int j=0; j<sizeCol; j++)
			{
			array[i][j]=m.array[i][j];
			}
		}
      }   
   return *this;
}

template<class TYPE>
TYPE & TMatrix<TYPE>::operator()(int row, int col)
{
   if(row>0 && row<=sizeRow && col>0 && col<=sizeCol)
   {
      return array[row-1][col-1];
   }
   
}

template<class TYPE>
TYPE & TMatrix<TYPE>::operator[](int k)
{
   if(sizeRow==1 && k>0 && k<=sizeCol)
   {
      return array[0][k-1];
   }
   else
   {
      if(sizeCol==1 && k>0 && k<=sizeRow)
      {
	  return array[k-1][0];
      }     
   }
}


template<class TYPE>
int TMatrix<TYPE>::getSizeRow()
{
   return sizeRow;
}


template<class TYPE>
int TMatrix<TYPE>::getSizeCol()
{
   return sizeCol;
}


template<class TYPE>
void TMatrix<TYPE>::setSize(int row, int col)
{
   if(row==0 && col==0)
   {
      if(array!=NULL)
      {
		for(int i=0; i<sizeRow; i++)
		{
			if(array[i]!=NULL)
			{
			delete [] array[i];
			}
		}

	 delete [] array;
	 array=NULL;
      }

      sizeRow=0;
      sizeCol=0;

      return;
   }

   if(row>0 && col>0)
   {
      if(array!=NULL)  //удаление старого массива
      {
		for(int i=0; i<sizeRow; i++)
		{
			if(array[i]!=NULL)
			{
			delete [] array[i];
			}
		}

	 delete [] array;
      }

      sizeRow=row;
      sizeCol=col;

      array=new TYPE*[sizeRow];    //создание нового массива

      for(int i=0; i<sizeRow; i++)
      {
		 array[i]=new TYPE[sizeCol];
      }
   }
   
}

template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator+(TMatrix<TYPE> &m)
{
   TMatrix t_m(sizeRow, sizeCol);

   if(sizeRow==m.sizeRow&&sizeCol==m.sizeCol)  //проверка размерности матриц
   {
      for(int i=0; i<sizeRow; i++)
      {
		for(int j=0; j<sizeCol; j++)
		{
			t_m.array[i][j]=array[i][j]+m.array[i][j];
		}
      }
   }
   return t_m;
}

template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator-(TMatrix<TYPE> &m)
{
   TMatrix t_m(sizeRow, sizeCol);

   if(sizeRow==m.sizeRow&&sizeCol==m.sizeCol)  //проверка размерности матриц
   {
      for(int i=0; i<sizeRow; i++)
      {
		for(int j=0; j<sizeCol; j++)
		{
			t_m.array[i][j]=array[i][j]-m.array[i][j];
		}
      }
   }
   return t_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator*(TMatrix<TYPE> &m)
{
   TMatrix t_m(sizeRow, m.sizeCol);

   if(sizeCol==m.sizeRow)           //проверка размерности
   {
      for(int i=0; i<t_m.sizeRow; i++)
      {
		for(int j=0; j<t_m.sizeCol; j++)
		{
			TYPE sum=0;

			for(int k=0; k<sizeCol; k++)
			{
				sum+=array[i][k]*m.array[k][j];
			}

			t_m.array[i][j]=sum;
		}
      }
   }
   return t_m;
}

template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::getTranspose()
{
   TMatrix<TYPE> new_m(sizeCol, sizeRow);

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
		new_m.array[j][i]=array[i][j];
      }
   }

   return new_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator*(TYPE c)
{
   TMatrix<TYPE> t_m(sizeRow, sizeCol);

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
		t_m.array[i][j]=array[i][j]*c;
      }
   }

   return t_m;
}


template<class TYPE>
TMatrix<TYPE> TMatrix<TYPE>::operator/(TYPE c)
{
   TMatrix<TYPE> t_m(sizeRow, sizeCol);

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
		t_m.array[i][j]=array[i][j]/c;
      }
   }

   return t_m;
}

template<class TYPE>                                      
TMatrix<TYPE> operator*(TYPE c, TMatrix<TYPE> &m)		//умножение числа на матрицу слева
{
   return m*c;
}

template<class TYPE>
TMatrix<TYPE> & TMatrix<TYPE>::setSingle(int n)
{
   if(n>0)
   {
      setSize(n,n);
      init(0);
      for(int i=0; i<n; i++)
      {
		array[i][i]=1;
      }
   }
   
   return *this;
}

template<class TYPE>
void TMatrix<TYPE>::init(TYPE c)
{
   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
		array[i][j]=c;
      }
   }
}

template<class TYPE>
int TMatrix<TYPE>::writeArray()
{
   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
		cout.width(14);
		cout<<array[i][j];
      }
      cout<<endl;
   }

   return 1;
}

#endif