Курсовая по ООП3 / MATRIX / Unit2

//---------------------------------------------------------------------------

#pragma hdrstop
#include "Unit2.h"
#include "Unit1.h"

//*****************************************************
//********************* Constructors ******************
//*****************************************************
TMatrix :: TMatrix(void)
{
    _NNUM1 = 3;
    _NNUM2 = 3;

    _mat = new int *[_NNUM1];
    for (int i = 0; i < _NNUM1; i++)
        _mat[i] = new int[_NNUM2];

    for (int i = 0; i < _NNUM1; i++)
        for (int j = 0; j < _NNUM2; j++)
            _mat[i][j] = 0;
}
//*****************************************************************************
TMatrix :: TMatrix(const int InitNum)
{
    _NNUM1 = 3;
    _NNUM2 = 3;
    _mat = new int *[_NNUM1];
	for (int i = 0; i < _NNUM1; i++)
            _mat[i] = new int[_NNUM2];

    for (int i = 0; i < _NNUM1; i++)
        for (int j = 0; j < _NNUM2; j++)
            _mat[i][j] = InitNum;
}
//*****************************************************************************
TMatrix :: TMatrix(const TMatrix &Mat)
{
    _NNUM1 = Mat._NNUM1;
    _NNUM2 = Mat._NNUM2;
    _mat = new int *[_NNUM1];
    for (int i = 0; i < _NNUM1; i++)
        _mat[i] = new int[_NNUM2];

    for (int i = 0; i < _NNUM1; i++)
        for (int j = 0; j < _NNUM2; j++)
            _mat[i][j] = Mat._mat[i][j];
}
//*****************************************************
//********************* Destructors *******************
//*****************************************************
TMatrix :: ~TMatrix()
{
    for (int i = 0; i < _NNUM1; i++)
	  delete _mat[i];
}

//*****************************************************************************
//***************************** CLASS FUNCTIONS *******************************
//*****************************************************************************

//***************************** INITNEWMATRIX
void TMatrix :: InitNewMatrix1()
{
    DeleteOldMatrix();

    _NNUM1 = 3;
    _NNUM2 = 3;

    _mat = new int *[_NNUM1];
    for (int i = 0; i < _NNUM1; i++)
        _mat[i] = new int[_NNUM2];

	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < _NNUM2; j++)
			_mat[i][j] = rand()%100-50;
}

//***************************** INITNEWMATRIX
void TMatrix :: InitNewMatrix1(int m, int n)
{
    _NNUM1 = m;
    _NNUM2 = n;

    _mat = new int *[_NNUM1];
    for (int i = 0; i < _NNUM1; i++)
        _mat[i] = new int[_NNUM2];

	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < _NNUM2; j++)
		        _mat[i][j] = rand()%100-50;
}

//***************************** DELETEOLDMATRIX
void TMatrix :: DeleteOldMatrix()
{
    for (int i = 0; i < _NNUM1; i++)
	  delete _mat[i];

    _NNUM1 = 0;
    _NNUM2 = 0;
}

//***************************** INITRANDOM
void TMatrix :: InitRandom()
{
	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < _NNUM2; j++)
			_mat[i][j] = rand()%100-50;
}

//***************************** INITZERO
void TMatrix :: InitZero()
{
	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < _NNUM2; j++)
			_mat[i][j] = 0;
}

//***************************** INITE
void TMatrix :: InitE()
{
    if (_NNUM1 != _NNUM2)
	throw 1;

	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < _NNUM2; j++)
			if (i == j)
				_mat[i][j] = 1;
			else
				_mat[i][j] = 0;
}

//***************************** INITINT
void TMatrix :: InitInt(int in)
{
	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < _NNUM2; j++)
			_mat[i][j] = in;
}

//***************************** INITELEM
void TMatrix :: InitElem(int i, int j, int in)
{
	if ((i >= 0) && (j >= 0) && (i < _NNUM1) && (j < _NNUM2))
		_mat[i][j] = in;
	else
		throw 10;
}

//***************************** GETELEM
int TMatrix :: GetElem(int i, int j)
{
	if ((i >= 0) && (j >= 0) && (i < _NNUM1) && (j < _NNUM2))
		return _mat[i][j];
	else
		throw 10;
}

//***************************** GETN1
int TMatrix :: GetN1()
{
        return _NNUM1;
}

//***************************** GETN2
int TMatrix :: GetN2()
{
        return _NNUM2;
}

//***************************** MSCALMULT
void TMatrix :: MScalMult(int Scal)
{
	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < _NNUM2; j++)
			_mat[i][j] *= Scal;
}

//***************************** MSUMM
void TMatrix :: MSumm(TMatrix & A, TMatrix & B)
{
	if ((A._NNUM1 != B._NNUM1) || (A._NNUM2 != B._NNUM2))
		throw 2;

	InitNewMatrix1(A._NNUM1, A._NNUM2);

	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < _NNUM2; j++)
			_mat[i][j] = A._mat[i][j] + B._mat[i][j];
}

//***************************** MDIFF
void TMatrix :: MDiff(TMatrix & A, TMatrix & B)
{
	if ((A._NNUM1 != B._NNUM1) || (A._NNUM2 != B._NNUM2))
		throw 2;

	InitNewMatrix1(A._NNUM1, A._NNUM2);

	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < _NNUM2; j++)
			_mat[i][j] =  A._mat[i][j] - B._mat[i][j];
}

//***************************** MMULT
void TMatrix :: MMult(TMatrix & A, TMatrix & B)
{
	if (A._NNUM2 != B._NNUM1)
		throw 5;

	InitNewMatrix1(A._NNUM1, B._NNUM2);

	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < _NNUM2; j++)
		{
			_mat[i][j] = 0;
			for (int k = 0; k < A._NNUM2; k++)
				_mat[i][j] +=  A._mat[i][k] * B._mat[k][j];
		}
}

//***************************** MTRANS
void TMatrix :: MTrans()
{
        if (_NNUM1 != _NNUM2)
	        throw 1;

	int buf;
	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < i; j++)
		{
			buf = _mat[i][j];
			_mat[i][j] = _mat[j][i];
			_mat[j][i] = buf;
		}
}

//***************************** MNEGATIVE
void TMatrix :: MNegative()
{
	for (int i = 0; i < _NNUM1; i++)
		for (int j = 0; j < _NNUM2; j++)
                        _mat[i][j] = -_mat[i][j];

}

//***************************** MMOD
int TMatrix :: MMod()
{
        if (_NNUM1 != _NNUM2)
                throw 1;
	int *mas;
        mas = new int[_NNUM1];
        if (_NNUM1 > 2)
                return Recurse(mas, 0);
        else
                return -Recurse(mas, 0);
}

//***************************** RECURSE
int TMatrix :: Recurse(int *mas, int status)
{
        int a = _NNUM1;
	int bufresult, result = 0, count = 0, search;
	for (int i = 0; i < a; i ++)
	{
		search = 0;
		for (int k = 0; k < status; k++)
			if (mas[k] == i)
				search = 1;
		if (!search)
		{
			if (status == a - 1)
				bufresult = _mat[a - 1][i];
			else
			{
				mas[status] = i;
				bufresult =	_mat[status][i] * Recurse(mas, status + 1);
				if ((status + count) % 2 == 0)
					bufresult = -bufresult;
			}
			result += bufresult;
			count ++;
		}
	}
	return -result;
}

//---------------------------------------------------------------------------
#pragma package(smart_init)