Оптимизация в САПР / Malgin_kurs / Matrix

#include "stdafx.h"
#include "Malgin_kurs.h"
#include "Matrix.h"
#include "METODI.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Конструкторы/Деструкторы
//////////////////////////////////////////////////////////////////////

//--------------------------------------------------------------------
// Обычный констуктор по умолчанию
//--------------------------------------------------------------------
CMatrix::CMatrix()
{
   array=NULL;		// обнуляем массив
   sizeRow=0;		// количество строк = 0
   sizeCol=0;		// количество столбцов = 0
}

//--------------------------------------------------------------------
// Конструктор копирования
//--------------------------------------------------------------------
CMatrix::CMatrix(
	CMatrix &m)		// Копируемая матрица
{
   array=NULL;		// обнуляем массив
   sizeRow=0;		// количество строк = 0
   sizeCol=0;		// количество столбцов = 0

   if(m.sizeRow>0 && m.sizeCol>0)	// проверяем размерность копируемой матрицы
   {
      sizeRow=m.sizeRow;	// устанавливаем количество строк
      sizeCol=m.sizeCol;	// устанавливаем количество столбцов

      array=new double*[sizeRow];	// выделяем память под новый масив строк
      assert(array!=NULL);				// проверка

      for(int i=0; i<sizeRow; i++)	// создаём столбцы к строкам для
      {										// получения 2-х мерного массива
			array[i]=new double[sizeCol];		// выделяем память под столбцы
			assert(array[i]!=NULL);				// проверка
      }

      for(i=0; i<sizeRow; i++)		// копируем строки старого массива
      {
			for(int j=0; j<sizeCol; j++)	// копируем столбцы старого массива
			{
				array[i][j]=m.array[i][j];
			}
      }
   }
   else
   {
      error(1);
   }
}

//--------------------------------------------------------------------
// Конструктор с заданием размера
//--------------------------------------------------------------------
CMatrix::CMatrix(
	int row,		// количество строк
	int col)		// количество столбцов
{
   array=NULL;		// обнуляем массив
   sizeRow=0;		// количество строк = 0
   sizeCol=0;		// количество столбцов = 0

   if(row>0 && col>0)	// проверяем заданные размеры	
   {
      sizeRow=row;		// устанавливаем количество строк
      sizeCol=col;		// устанавливаем количество столбцов

      array=new double*[sizeRow];	// выделяем память под новый масив строк
      assert(array!=NULL);				// проверка

      for(int i=0; i<sizeRow; i++)	// создаём столбцы к строкам для
      {										// получения 2-х мерного массива
			array[i]=new double[sizeCol];		// выделяем память под столбцы
			assert(array[i]!=NULL);				// проверка
      }
   }
   else
   {
      error(2);
   }
}

//--------------------------------------------------------------------
// Деструктор
//--------------------------------------------------------------------
CMatrix::~CMatrix()
{
   if(array!=NULL)	// проверяем массив
   {
      for(int i=0; i<sizeRow; i++)
      {
			if(array[i]!=NULL)
			{
				delete [] array[i];	// удаляем солбцы
			}
      }
      delete [] array;				// удаляем строки
   }
}

//////////////////////////////////////////////////////////////////////
// Методы класса
//////////////////////////////////////////////////////////////////////

//--------------------------------------------------------------------
// Сообщение об ошибке
//--------------------------------------------------------------------
void CMatrix::error(
	int error_id)		// номер ошибки
{
   CString str; str="CMatrix error: ";	// формируем строку для вывода
	char buffer[777];							// об ошибке с указанием её номера
	sprintf(buffer,"%n",error_id);		// преобразуем число в строку
	str+=buffer;								// добавляем номер ошибки к строке
	AfxMessageBox(str);						// вызываем диалоговое окно
}

//--------------------------------------------------------------------
// Инициализация числом
//--------------------------------------------------------------------
void CMatrix::init(
	double c)		// число для инициализации
{
   for(int i=0; i<sizeRow; i++)	// заполняем весь массив
   {										// этим числом
      for(int j=0; j<sizeCol; j++)
      {
			array[i][j]=c;
      }
   }
}

//--------------------------------------------------------------------
// Инициализация статическим массивом
//--------------------------------------------------------------------
void CMatrix::initStat(
	double *p,		// указатель на число
	int size_r,		// количество строк
	int size_c)		// количество столбцов
{
   this->setSize(size_r,size_c);		// устанавливаем размер массива

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
			array[i][j]=p[i*size_c+j];	// заполняем массив
      }
   }
}

//--------------------------------------------------------------------
// Инициализация динамическим массивом
//--------------------------------------------------------------------
void CMatrix::initDynam(
	double **p,		// двойной указатель на число
	int size_r,		// количество строк
	int size_c)		// количество столбцов
{
   this->setSize(size_r,size_c);		// устанавливаем размер массива

   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
			array[i][j]=p[i][j];			// заполняем массив
      }
   }
}

//--------------------------------------------------------------------
// Получить количество строк
//--------------------------------------------------------------------
int CMatrix::getSizeRow()
{
   return sizeRow;	// возвращаем количество строк
}

//--------------------------------------------------------------------
// Получить количество столбцов
//--------------------------------------------------------------------
int CMatrix::getSizeCol()
{
   return sizeCol;	// возвращаем количество столбцов
}

//--------------------------------------------------------------------
// Установка размера массива
//--------------------------------------------------------------------
void CMatrix::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 double*[sizeRow];	// выделяем память под строки
      assert(array!=NULL);				// проверка

      for(int i=0; i<sizeRow; i++)	
      {
			array[i]=new double[sizeCol];	// выделяем память под столбцы
			assert(array[i]!=NULL);			// проверка
		}
   }
   else
   {
      error(6);
   }
}

//--------------------------------------------------------------------
// Добавление нового столбца
//--------------------------------------------------------------------
void CMatrix::insertCol(
	CMatrix &x)			// матрица-столбец
{
	CMatrix m(sizeRow,sizeCol);		// временная матрица - копия

	for(int i=0; i<sizeRow; i++)
	{
		for(int j=0; j<sizeCol; j++)
		{
			m.array[i][j]=array[i][j];	// копируем матрицы
		}
	}


   if(array!=NULL)						// удаляем масив старой матрицы
   {
		for(int i=0; i<sizeRow; i++)
		{
			if(array[i]!=NULL)
			{
				delete [] array[i];
			}
		}
		delete [] array;
   }

   sizeRow=m.sizeRow;		// устанавливаем значение строк новой матрицы
	sizeCol++;					// устанавливаем значение столбцов новой матрицы

   array=new double*[sizeRow];		// создаём массив новой матрицы
   assert(array!=NULL);

   for(i=0; i<sizeRow; i++)
   {
		array[i]=new double[sizeCol];
		assert(array[i]!=NULL);
	}


	for(i=0; i<sizeRow; i++)
	{
		for(int j=0; j<sizeCol-1; j++)
		{
			array[i][j]=m.array[i][j];		// заполняем новую матрицу значениями
		}
	}
 	

	for(int j=0; j<sizeRow; j++)			// заполняем новый столбец значениями
	{
		array[j][sizeCol-1]=x.array[j][0];
	}

}

//--------------------------------------------------------------------
// Перегрузка оператора присваивания
//--------------------------------------------------------------------
CMatrix &CMatrix::operator=(
	CMatrix &m)		// матрица-аргумент
{
   if(this!=&m)	// проверка равенства
   {
      if(sizeRow==0 && sizeCol==0)	// если количество строк и столбцов = 0
      {
			sizeRow=m.sizeRow;			// задаём новый размер строк
			sizeCol=m.sizeCol;			// задаём новый размер столбцов

			array=new double*[sizeRow];	// выделяем память под строки
			assert(array!=NULL);				// проверка

			for(int i=0; i<sizeRow; i++)
			{
				array[i]=new double[sizeCol];	// выделяем память под столбцы
				assert(array[i]!=NULL);			// проверка
			}
		}

      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];	// копируем элементы
				}
			}
      }
      else
      {
			error(3);
      }
   }

   return *this;
}

//--------------------------------------------------------------------
// Перегрузка оператора ()
//--------------------------------------------------------------------
double &CMatrix::operator()(
	int row,			// количество строк
	int col)			// количество стобцов
{
   if(row>0 && row<=sizeRow && col>0 && col<=sizeCol)	// проверка
   {
      return array[row-1][col-1];	// возвращаем элемент массива
   }
   else
   {
      error(4);							// ошибка
      return array[0][0];
   }
}

//--------------------------------------------------------------------
// Перегрузка оператора []
//--------------------------------------------------------------------
double & CMatrix::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];	// возвращаем элемент массива
      }
      else
      {
			error(5);					// при ошибке
			return array[0][0];
      }
   }
}

//--------------------------------------------------------------------
// Получить строку
//--------------------------------------------------------------------
CMatrix CMatrix::getRow(
	int row)			// номер строки
{
   CMatrix t_m(1, sizeCol);		// временная матрица-строка

   if(row>0 && row<=sizeRow)		// проверяем на наличие соотв. строки
   {
      for(int i=0; i<sizeCol; i++)
      {
			t_m.array[0][i]=array[row-1][i];	// присваиваем временной матрице
      }												// новые значения
   }
   else
   {
      error(18);
   }

   return t_m;							// возвращаем матрицу-строку
}

//--------------------------------------------------------------------
// Получить столбец
//--------------------------------------------------------------------
CMatrix CMatrix::getCol(
	int col)			// номер столбца
{
   CMatrix t_m(sizeRow, 1);		// временная матрица-столбец

   if(col>0 && col<=sizeCol)		// проверяем на наличие соотв. столбца
   {
      for(int i=0; i<sizeRow; i++)
      {
			t_m.array[i][0]=array[i][col-1];	// присваиваем временной матрице
      }												// новые значения
   }
   else
   {
      error(19);
   }

   return t_m;							// возвращаем матрицу-столбец
}

//--------------------------------------------------------------------
// Получить часть матрицы
//--------------------------------------------------------------------
CMatrix CMatrix::getPart(
	int i1,			// номер строки
	int j1,			// номер столбца
	int m,			// количество строк
	int n)			// количество столбцов
{
   CMatrix res(m,n);		// временная матрица для хранения части исходной

   if(i1>0 && i1<=sizeRow && j1>0 && j1<=sizeCol &&	// проверка всех условий
      m>0 && i1+m<=sizeRow+1 && n>0 && j1+n<=sizeCol+1)
   {
      for(int i=0, i2=i1-1; i<m; i++, i2++)
      {
			for(int j=0, j2=j1-1; j<n; j++, j2++)
			{
				res.array[i][j]=array[i2][j2];	// копируем соответствующие элементы
			}												// исходной матрицы во временную
      }
   }
   else
   {
      error(20);
   }

   return res;				// возвращаем временную матрицу
}

//--------------------------------------------------------------------
// Установить часть матрицы
//--------------------------------------------------------------------
void CMatrix::setPart(
	int i1,			// номер строки
	int j1,			// номер столбца
	CMatrix &t)		// матрица-источник
{
   int m=t.getSizeRow(),	// получаем количество строк
		 n=t.getSizeCol();	// получаем количество стлбцов

   if(i1>0 && i1<=sizeRow && j1>0 && j1<=sizeCol &&	// проверка всех условий
      m>0 && i1+m<=sizeRow+1 && n>0 && j1+n<=sizeCol+1)
   {
      for(int i=0, i2=i1-1; i<m; i++, i2++)
      {
			for(int j=0, j2=j1-1; j<n; j++, j2++)
			{
				array[i2][j2]=t.array[i][j];		// копируем соответствующие элементы
			}												// исходной матрицы во временную
      }
   }
   else
   {
      error(21);
   }
}

//--------------------------------------------------------------------
// Обменять строки
//--------------------------------------------------------------------
void CMatrix::swapRow(
	int i1,			// номер первой строки
	int i2)			// номер второй строки
{
   if(i1>0 && i1<=sizeRow && i2>0 && i2<=sizeRow)	// проверка условий
   {
      for(int j=0; j<sizeCol; j++)
      {
			double t=array[i1-1][j];			// временный массив
			array[i1-1][j]=array[i2-1][j];	// заполнение первой строки
			array[i2-1][j]=t;						// заполнение второй строки
      }
   }
   else
   {
      error(22);
   }
}

//--------------------------------------------------------------------
// Обменять столбцы
//--------------------------------------------------------------------
void CMatrix::swapCol(
	int j1,			// номер первого столбца
	int j2)			// номер второго столбца
{
   if(j1>0 && j1<=sizeCol && j2>0 && j2<=sizeCol)	// проверк условий
   {
      for(int i=0; i<sizeRow; i++)
      {
			double t=array[i][j1-1];			// временный массив
			array[i][j1-1]=array[i][j2-1];	// заполнение первого столбца
			array[i][j2-1]=t;						// заполнение второго столбца
      }
   }
   else
   {
      error(23);
   }
}

//--------------------------------------------------------------------
// Установить строку
//--------------------------------------------------------------------
void CMatrix::setRow(
	int row_index,	// номер строки
	CMatrix &m)		// матрица-строка (источник данных)
{

   if(m.sizeRow==1 && sizeCol==m.sizeCol &&		// проверка условий
      row_index>0 && row_index<=sizeRow)
   {
      for(int i=0; i<sizeCol; i++)
      {
			array[row_index-1][i]=m.array[0][i];	// заполняем строку данными
      }														// из матрцы-аргумента
   }
   else
   {
      error(24);
   }
}

//--------------------------------------------------------------------
// Установить столбец
//--------------------------------------------------------------------
void CMatrix::setCol(
	int col_index,	// номер столбца
	CMatrix &m)		// матрица-столбец (источник данных)
{
   if(sizeRow==m.sizeRow && m.sizeCol==1 &&		// проверка условий
      col_index>0 && col_index<=sizeCol)
   {
      for(int i=0; i<sizeRow; i++)
      {
			array[i][col_index-1]=m.array[i][0];	// заполняем столбец данными
      }														// из матрицы-аргумента
   }
   else
   {
      error(25);
   }
}


//////////////////////////////////////////////////////////////////////
// Перегрузка операторов
//////////////////////////////////////////////////////////////////////

//--------------------------------------------------------------------
// Перегрузка оператора +
//--------------------------------------------------------------------
CMatrix CMatrix::operator+(
	CMatrix &m)			// матрица-операнд
{
   CMatrix 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];	// складываем 
			}													// соответствующие элементы
      }														// двух матриц
   }
   else
   {
      error(7);
   }

   return t_m;									// возвращаем матрицу-результат
}

//--------------------------------------------------------------------
// Перегрузка оператора -
//--------------------------------------------------------------------
CMatrix CMatrix::operator-(
	CMatrix &m)			// матрица-операнд
{
   CMatrix 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];	// вычитаем
			}													// соответствующие элементы
      }														// двух матриц
   }
   else
   {
      error(8);
   }

   return t_m;									// возвращаем матрицу-результат
}

//--------------------------------------------------------------------
// Перегрузка оператора *
//--------------------------------------------------------------------
CMatrix CMatrix::operator*(
	CMatrix &m)			// матрица-операнд
{
   CMatrix 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++)
			{
				double sum=0;					// сумма соответствующи элементов

				for(int k=0; k<sizeCol; k++)
				{
					sum+=array[i][k]*m.array[k][j];	// умножаем матрицы в соответствии
				}												// с метематическими правилами
				t_m.array[i][j]=sum;			// присваиваем элементу значение 
			}										// суммы произведений строк и столбцов матриц
      }
   }
   else
   {
      error(9);
   }

   return t_m;									// возвращаем матрицу-результат
}

//--------------------------------------------------------------------
// Перегрузка оператора /
//--------------------------------------------------------------------
CMatrix CMatrix::operator/(
	CMatrix &m)			// матрица-операнд
{
   CMatrix t_m(sizeRow, sizeCol);		// временная матрица-результат

	if(m.sizeCol==1 && m.sizeRow==1)		// проверяем, является ли матрица числом
		for(int i=0; i<sizeRow; i++)
			for(int j=0; j<sizeCol; j++)
				t_m.array[i][j]=array[i][j]/m.array[0][0];	// делим элементы матрицы на это число
	else
		error(14);

   return t_m;									// возвращаем матрицу-результат
}

//--------------------------------------------------------------------
// Перегрузка оператора ^ (перемножение соответствующих элементов)
//--------------------------------------------------------------------
CMatrix CMatrix::operator^(
	CMatrix &m)			// матрица-операнд
{
   CMatrix 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];	// умножение соответствующих
			}																// элементов матриц
      }
   }
   else
   {
      error(10);
   }

   return t_m;									// возвращаем матрицу-результат
}

//--------------------------------------------------------------------
// Перегрузка оператора +=
//--------------------------------------------------------------------
CMatrix &CMatrix::operator+=(
	CMatrix &m)			// матрица-операнд
{
   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];			// складываем соответствующие элементы
			}
      }
   }
   else
   {
      error(11);
   }

   return *this;								// возвращаем результат
}

//--------------------------------------------------------------------
// Перегрузка оператора -=
//--------------------------------------------------------------------
CMatrix &CMatrix::operator-=(
	CMatrix &m)			// матрица-операнд
{
   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];			// вычитаем соответствующие элементы
			}
      }
   }
   else
   {
      error(12);
   }

   return *this;								// возвращаем результат
}

//--------------------------------------------------------------------
// Перегрузка оператора *=
//--------------------------------------------------------------------
CMatrix & CMatrix::operator*=(
	CMatrix &m)			// матрица-операнд
{
   CMatrix 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++)
			{
				double sum=0;					// сумма соответствующи элементов

				for(int k=0; k<sizeCol; k++)
				{
					sum+=array[i][k]*m.array[k][j];	// умножаем матрицы в соответствии
				}												// с метематическими правилами
				t_m.array[i][j]=sum;			// присваиваем элементу значение
			}										// суммы произведений строк и столбцов матриц
      }

      *this=t_m;								// присваиваем указателю на объект
   }												// значение результата
   else
   {
      error(29);
   }

   return *this;								// возвращаем результат
}

//--------------------------------------------------------------------
// Перегрузка оператора ^=
//--------------------------------------------------------------------
CMatrix &CMatrix::operator^=(
	CMatrix &m)			// матрица-операнд
{
   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];		// умножение соответствующих
			}												// элементов матриц
      }
   }
   else
   {
      error(13);
   }

   return *this;								// возвращаем результат
}

//--------------------------------------------------------------------
// Получение транспонированной матрицы
//--------------------------------------------------------------------
CMatrix CMatrix::getTranspose()
{
   CMatrix 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;								// возвращаем результат
}

//--------------------------------------------------------------------
// Сделать матрицу нулевой
//--------------------------------------------------------------------
void CMatrix::setNull()
{
   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
			array[i][j]=0;				// обнуляем все элементы матрицы
      }
   }
}

//--------------------------------------------------------------------
// Сделать матрицу единичной
//--------------------------------------------------------------------
CMatrix & CMatrix::setSingle(
	int n)			// количество строк/столбцов (размерность)
{
   if(n>0)			// проверка
   {
      setSize(n,n);				// устанавливаем новый размер
      init(0);						// инициализация нулём
      for(int i=0; i<n; i++)
      {
			array[i][i]=1;			// присваиваем диагональным элементам 1
      }
   }
   else
   {
      error(28);
   }

   return *this;					// возвращаем результат
}


//////////////////////////////////////////////////////////////////////
// Операции со скалярами
//////////////////////////////////////////////////////////////////////

//--------------------------------------------------------------------
// Перегрузка оператора +
//--------------------------------------------------------------------
CMatrix CMatrix::operator+(
	double c)			// значение-операнд
{
   CMatrix t_m(*this);			// временная матрица-результат

   if(sizeRow==sizeCol)			// если матрица квадратная
   {
      for(int i=0; i<sizeRow; i++)
      {								// прибавляем к диагональным
			t_m.array[i][i]+=c;	// элементам соответствующий операнд
      }
   }
   else
   {
      error(14);
   }

   return t_m;						// возвращаем результат
}

//--------------------------------------------------------------------
// Перегрузка оператора -
//--------------------------------------------------------------------
CMatrix CMatrix::operator-(
	double c)			// значение-операнд
{
   CMatrix t_m(*this);			// временная матрица-результат

   if(sizeRow==sizeCol)			// если матрица квадратная
   {
      for(int i=0; i<sizeRow; i++)
      {								// вычитаем из диагональных
			t_m.array[i][i]-=c;	// элементов соответствующий операнд
      }
   }
   else
   {
      error(15);
   }

   return t_m;						// возвращаем результат
}

//--------------------------------------------------------------------
// Перегрузка оператора *
//--------------------------------------------------------------------
CMatrix CMatrix::operator*(
	double c)			// значение-операнд
{
   CMatrix 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;						// возвращаем результат
}

//--------------------------------------------------------------------
// Перегрузка оператора /
//--------------------------------------------------------------------
CMatrix CMatrix::operator/(
	double c)			// значение-операнд
{
   CMatrix 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;						// возвращаем результат
}

//--------------------------------------------------------------------
// Перегрузка оператора +=
//--------------------------------------------------------------------
CMatrix &CMatrix::operator+=(
	double c)			// значение-операнд
{
   if(sizeRow==sizeCol)			// если матрица квадратная
   {
      for(int i=0; i<sizeRow; i++)
      {
			array[i][i]+=c;		// прибавляем к диагональным
      }								// элементам значение операнда
   }
   else
   {
      error(16);
   }

   return *this;					// возвращаем результат
}

//--------------------------------------------------------------------
// Перегрузка оператора -=
//--------------------------------------------------------------------
CMatrix &CMatrix::operator-=(
	double c)			// значение-операнд
{
   if(sizeRow==sizeCol)			// если матрица квадратная
   {
      for(int i=0; i<sizeRow; i++)
      {
			array[i][i]-=c;		// вычитаем из диагональных
      }								// элементов значение операнда
   }
   else
   {
      error(17);
   }

   return *this;					// возвращаем результат
}

//--------------------------------------------------------------------
// Перегрузка оператора *=
//--------------------------------------------------------------------
CMatrix &CMatrix::operator*=(
	double c)			// значение-операнд
{
   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
			array[i][j]*=c;		// умножаем все элементы
      }								// матрицы на значение операнда
   }

   return *this;					// возвращаем результат
}

//--------------------------------------------------------------------
// Перегрузка оператора /=
//--------------------------------------------------------------------
CMatrix &CMatrix::operator/=(
	double c)			// значение-операнд
{
   for(int i=0; i<sizeRow; i++)
   {
      for(int j=0; j<sizeCol; j++)
      {
			array[i][j]/=c;		// делим все элементы
      }								// матрицы на значение операнда
   }

   return *this;					// возвращаем результат
}

//--------------------------------------------------------------------
// Перегрузка оператора - (отрицательное значение матрицы)
//--------------------------------------------------------------------
CMatrix CMatrix::operator-()
{
   return (*this)*(-1);		// возвращаем значение матрицы,
}									// умноженной на (-1)

//--------------------------------------------------------------------
// Перегрузка оператора % (скалярное умножение для матриц-векторов)
//--------------------------------------------------------------------
double CMatrix::operator%(
	CMatrix &m)			// матрица-операнд
{
   double sum=0;		// значение суммы произведения строк и столбцов

   if(sizeRow==m.sizeRow && sizeCol==m.sizeCol)		// если матрицы равны
   {
      if(sizeRow==1)											// если количество строк равно 1
      {
			for(int i=0; i<sizeCol; i++)
			{
				sum+=array[0][i]*m.array[0][i];			// умножаем значения столбцов
			}
      }
      else
      {
			if(sizeCol==1)										// если количество столбцов равно 1 
			{
				for(int i=0; i<sizeRow; i++)
				{
					sum+=array[i][0]*m.array[i][0];		// умножаем значения строк
				}
			}
			else
			{
				error(26);
			}
      }
   }
   else
   {
      if(sizeRow==m.sizeCol && sizeCol==m.sizeRow)	// если количество строк одной матрицы равно
      {															// количеству столбцов другой матрицы и наоборот
			if(sizeRow==1)										// если количество строк равно 1
			{
				for(int i=0; i<sizeCol; i++)
				{
					sum+=array[0][i]*m.array[i][0];		// умножаем значения столбцов
				}													// на значения строк
			}
			else
			{
				if(sizeCol==1)									// если количество столбцов равно 1
				{
					for(int i=0; i<sizeRow; i++)
					{
						sum+=array[i][0]*m.array[0][i];	// умножаем значения строк
					}												// на значения столбцов
				}
				else
				{
					error(27);
				}
			}
      }
   }

   return sum;						// возвращаем результат
}


//////////////////////////////////////////////////////////////////////
// Ввод/вывод
//////////////////////////////////////////////////////////////////////

//--------------------------------------------------------------------
// Вывод вектора (представление его в форме строки)
//--------------------------------------------------------------------
CString CMatrix::Write()
{
	CString tmp;					// временная строка-результат

	tmp="(";							// открывающиеся скобки для наглядности
	for(int i=0; i<sizeRow; i++)
	{	
		for(int j=0; j<sizeCol; j++)
		{
			tmp+=Double_To_String(array[i][j]);						// прибавляем значение элемента
			if(j<sizeCol-1) tmp+="\r\n"; //"   "	// "отлавливаем" последнее значение
		}														// чтобы не ставить в конце разделитель
		if(i<sizeRow-1)tmp+="; ";				// разделитель между элементами
	}
	tmp+=")";						// закрывающаяся скобка
	return tmp;						// возвращаем результат
}

//--------------------------------------------------------------------
// Вывод матрицы (представление её в форме строки)
//--------------------------------------------------------------------
CString CMatrix::WriteMatrix()
{
	CString tmp;					// временная строка-результат

	for(int i=0; i<sizeRow; i++)
	{	
		tmp+="(";					// открывающиеся скобки для наглядности
		for(int j=0; j<sizeCol; j++)
		{
			tmp+=Double_To_String(array[i][j]);			// прибавляем значение элемента
			if(j<sizeCol-1) tmp+="; ";		// "отлавливаем" последнее значение
		}											// чтобы не ставить в конце разделитель
		tmp+=")";								// закрывающаяся скобка
		if(i<sizeRow-1)tmp+="\r\n";		// "отлавливаем" последнее значение
	}												// чтобы не ставить в конце разделитель
	return tmp;						// возвращаем результат
}

//--------------------------------------------------------------------
// Ввод вектора (конвертирование строки в элемент класса)
//--------------------------------------------------------------------
CMatrix CMatrix::Read(
	CString str)		// строка со значениями вектора
{
	CString s;		// строка для хранения элемента вектора
	int nSize,		// размер вектора (определяется количеством разделителей)
		nPos=1;		//	счётчик позиции
		
	// в качестве разделителей могут использоваться символы ";" и ","
	// допускается ввод пробелов для наглядности

	str.TrimRight();			// удаляем пробелы справа
	str.Replace(" ", "");	// удаляем пробелы внутри строки
	str.Replace(";",",");	// заменяем ";" на ","
	
	nSize=str.Replace(",",",")+1;		// определяем размерность вектора

	CMatrix xs(nSize,1);		// создаём этот вектор	
	xs.setNull();			// заполняем его нулями
	
	for (int i=0; i<str.GetLength(); i++)	// "пробегаем" по строке
	{
		if (str[i]!=',')		// если не нашли разделитель, то
			s+=str[i];			// прибавляем символ к значению элемента
		else
		{
			xs(nPos,1)=atof(s);	// устанавливаем элемент вектора
			nPos++;					// увеличиваем счётчик позиции
			s.Empty();				// "обнуляем" строку для хранения элемента вектора
		}
	}
	xs(nSize,1)=atof(s);			//заполняем последний элемент вектора

	return xs;						// возвращаем результат
}


//////////////////////////////////////////////////////////////////////
// Функции-друзья
//////////////////////////////////////////////////////////////////////

//--------------------------------------------------------------------
// Перегрузка оператора +
//--------------------------------------------------------------------
CMatrix operator+(double c, CMatrix &m)
{
   return m+c;
}

//--------------------------------------------------------------------
// Перегрузка оператора -
//--------------------------------------------------------------------
CMatrix operator-(double c, CMatrix &m)
{
   return m*(-1)+c;
}

//--------------------------------------------------------------------
// Перегрузка оператора *
//--------------------------------------------------------------------
CMatrix operator*(double c, CMatrix &m)
{
   return m*c;
}

//--------------------------------------------------------------------
// Функция преобразования целого в строку
//--------------------------------------------------------------------
CString Int_To_String (
	int value)			// целое
{
	char buffer[255];					// буфер для хранения целого
	sprintf(buffer, "%d", value);	// преобразование
	return buffer;						// возвращение результата преобразования
}

//--------------------------------------------------------------------
// Функция преобразования double`a в строку
//--------------------------------------------------------------------
CString Double_To_String (
	double value)		// аргумент типа double
{
	char buffer[777];						// буфер для хранения числа
	sprintf(buffer, "%.9f", value);	// преобразование
	return buffer;							// возвращение результата преобразования
}