matrix.cpp

c

#include "stdafx.h"
#include "afx.h"
#include "math.h"
#include "memory.h"
#include "iostream.h" 
#include "matrix.h"

CMatrix::CMatrix()
{
	m_nRow=16;
	m_nCol=16;
	m_adValue = new double* [16];
	for(int loop=0;loop<16;loop++)
		m_adValue[loop]=new double  [16];
}

CMatrix::CMatrix(int nRow,int nCol)
{
	m_nRow=nRow;
	m_nCol=nCol;
	m_adValue = new double* [nRow];
	for(int loop=0;loop<nRow;loop++)
		m_adValue[loop]=new double  [nCol];
}

CMatrix::CMatrix(int nRow,int nCol,double dBuf)
{
	m_nRow=nRow;
	m_nCol=nCol;
	m_adValue = new double* [nRow];
	for(int loop=0;loop<nRow;loop++)
		m_adValue[loop]=new double [nCol];
	for(loop=0;loop<nRow;loop++)
	for(int loop1=0;loop1<nCol;loop1++)
		m_adValue[loop][loop1]=dBuf;
}

CMatrix::CMatrix(const CMatrix &m)
{
	m_nRow=m.m_nRow;
	m_nCol=m.m_nCol;
	m_adValue=new double* [m_nRow];
	for(int loop=0;loop<m_nRow;loop++)
	{
		m_adValue[loop]=new double[m_nCol];
		memcpy(m_adValue[loop],m.m_adValue[loop],m_nCol*sizeof(double));
	}
}

CMatrix::~CMatrix(void)
{
	for(int loop=0;loop<m_nRow;loop++)
		delete[] m_adValue[loop];
	delete[]	m_adValue;
}

CMatrix& CMatrix::operator*=(const CMatrix&m)
{		
	if(m_nCol!=m.m_nRow){
		CString sText;
		sText="The row of Matrix1 doesn't equal the col of Matrix2, while multiplying";
		AfxMessageBox( sText, MB_OK, 0 );
		//cout<<sText<<endl;
		return *this;
	}
		
	double *adBuf,dBuf;
	adBuf= new double [m_nCol];

	for(int loop=0;loop<m_nRow;loop++)
	{
		for(int loop1=0;loop1<m.m_nCol;loop1++)
		{
			dBuf=0.0;
			for(int loop2=0;loop2<m_nCol;loop2++)
				dBuf+=m_adValue[loop][loop2]*m.m_adValue[loop2][loop1];
			adBuf[loop1]=dBuf;
		}
		for(int loop2=0;loop2<m_nCol;loop2++)
			m_adValue[loop][loop2]=adBuf[loop2];
	}
	delete[] adBuf;
	return *this;
}

CMatrix CMatrix::operator*(const CMatrix&m)
{
	if(m_nCol!=m.m_nRow){
		CString sText;
		sText="The row of CMatrix 1 doesn't equal the col of CMatrix 2, while multiplying";
		AfxMessageBox( sText, MB_OK, 0 );
		//cout<<sText<<endl;
		CMatrix mTmp;
		return mTmp;
	}
	
	CMatrix mTmp(m_nRow,m.m_nCol);

	for(int loop=0;loop<m_nRow;loop++)
	{
		for(int loop1=0;loop1<m.m_nCol;loop1++)
		{
			mTmp.m_adValue[loop][loop1]=0.0;
			for(int loop2=0;loop2<m_nCol;loop2++)
				mTmp.m_adValue[loop][loop1]+=m_adValue[loop][loop2]*m.m_adValue[loop2][loop1];
		}
	}
	return mTmp;
}

CMatrix CMatrix::operator*(double dBuf)
{
	CMatrix mTmp(m_nRow,m_nCol);
	for(int loop=0;loop<m_nRow;loop++)
	{
		for(int loop1=0;loop1<m_nCol;loop1++)
			mTmp.m_adValue[loop][loop1]=m_adValue[loop][loop1]*dBuf;
	}
	return mTmp;
}

CMatrix& CMatrix::operator = (const CMatrix& m)
{
	if (m_nRow != m.m_nRow || m_nCol != m.m_nCol)
		Realloc( m.m_nRow,m.m_nCol);
	int nColByte = m.m_nCol * sizeof(double);
	for (int loop=0; loop < m.m_nRow; loop++)
		memcpy( m_adValue[loop], m.m_adValue[loop], nColByte);
	return *this;
}


void CMatrix::Realloc (int nRow, int nCol)
{
	for (int loop=0; loop< m_nRow; loop++)
		delete [] m_adValue[loop];
	delete [] m_adValue;

	m_nRow=nRow;
	m_nCol=nCol;
	m_adValue=new double *[m_nRow];
	for (loop=0; loop< m_nRow; loop++)
		m_adValue[loop]=new double [m_nCol];
	
  	return;
}


CMatrix& CMatrix::operator*=(double dBuf)
{
	for(int loop=0;loop<m_nRow;loop++){
		for(int loop1=0;loop1<m_nCol;loop1++){
			m_adValue[loop][loop1]*=dBuf;
		}
	}
	return *this;
}

CMatrix& CMatrix::Trans(const CMatrix&m)
{
	if (m_nRow != m.m_nCol || m_nCol != m.m_nRow)
		Realloc( m.m_nCol,m.m_nRow);	

	
	for(int loop=0;loop<m_nRow;loop++){
		for(int loop1=0;loop1<m_nCol;loop1++){
			m_adValue[loop][loop1]=m.m_adValue[loop1][loop];
		}
	}
	return *this;
}

CMatrix CMatrix::operator+(const CMatrix& m)
{
	if(m_nRow!=m.m_nRow){
		CString sText;
		sText="The row of matrix1 doesn't equal the row of matrix2, while adding";
		AfxMessageBox( sText, MB_OK, 0 );
		//cout<<sText<<endl;
		return *this;
	}
	if(m_nCol!=m.m_nCol){
		CString sText;
		sText="The col of matrix1 doesn't equal the col of matrix2, while adding";
		AfxMessageBox( sText, MB_OK, 0 );
		//cout<<sText<<endl;
		return *this;
	}
	CMatrix mTmp(m_nRow,m_nCol);
	for(int loop=0;loop<m_nRow;loop++){
		for(int loop1=0;loop1<m_nCol;loop1++){
			mTmp.m_adValue[loop][loop1]=m_adValue[loop][loop1]+m.m_adValue[loop][loop1];
		}
	}
	return mTmp;
}


CMatrix& CMatrix::operator+=(const CMatrix& m)
{
	if(m_nRow!=m.m_nRow){
		CString sText;
		sText="The row of matrix1 doesn't equal the row of matrix2, while adding";
		AfxMessageBox( sText, MB_OK, 0 );
		//cout<<sText<<endl;
		return *this;
	}

	if(m_nCol!=m.m_nCol){
		CString sText;
		sText="The col of matrix1 doesn't equal the col of matrix2, while adding";
		AfxMessageBox( sText, MB_OK, 0 );
		//cout<<sText<<endl;
		return *this;
	}
	for(int loop=0;loop<m_nRow;loop++)
	for(int loop1=0;loop1<m_nCol;loop1++)
		m_adValue[loop][loop1]+=m.m_adValue[loop][loop1];
	return *this;
}

bool CMatrix::MatInv(){
	int loop,loop1,loop2,iRow;
	CString sText;
	
	if(m_nRow!=m_nCol){
		sText="Row doesn't equal col, while inversing";
		AfxMessageBox( sText, MB_OK, 0 );
		//cout<<sText<<endl;
		return false;
	}

	double **adInvValue,dBuf;  
	adInvValue = new double* [m_nCol];
	for(loop=0;loop<m_nCol;loop++)
		adInvValue[loop]=new double  [m_nCol];
	
	for(loop=0;loop<m_nCol;loop++)
	for(loop1=0;loop1<m_nCol;loop1++)
		adInvValue[loop][loop1]=0.0;

	for(loop=0;loop<m_nCol;loop++)
		adInvValue[loop][loop]=1.0;

	for(loop=0;loop<m_nRow;loop++){
		iRow=loop;
		dBuf=fabs(m_adValue[loop][loop]);
		for(loop1=loop+1;loop1<m_nRow;loop1++){
			if(dBuf<fabs(m_adValue[loop1][loop])){
				dBuf=fabs(m_adValue[loop1][loop]);
				iRow=loop1;
			}
		}
		if(dBuf==0.0){
			sText="Main elment equals zero, while inversing";
			AfxMessageBox( sText, MB_OK, 0 );
			//cout<<sText<<endl;
			for(loop=0;loop<m_nRow;loop++)
				delete[] adInvValue[loop];
			delete[]	adInvValue;
			return false;
		}

		for(loop1=loop;loop1<m_nRow;loop1++){
			dBuf=m_adValue[loop][loop1];
			m_adValue[loop][loop1]=m_adValue[iRow][loop1];
			m_adValue[iRow][loop1]=dBuf;
		}
		for(loop1=0;loop1<m_nRow;loop1++){
			dBuf=adInvValue[loop][loop1];
			adInvValue[loop][loop1]=adInvValue[iRow][loop1];
			adInvValue[iRow][loop1]=dBuf;
		}
		for(loop1=loop+1;loop1<m_nCol;loop1++){
			m_adValue[loop][loop1]/=m_adValue[loop][loop];
		}
		for(loop1=0;loop1<m_nCol;loop1++){
			adInvValue[loop][loop1]/=m_adValue[loop][loop];
		}

		for(loop1=loop+1;loop1<m_nRow;loop1++){
			for(loop2=loop+1;loop2<m_nCol;loop2++)
				m_adValue[loop1][loop2]-=m_adValue[loop1][loop]*m_adValue[loop][loop2];
			for(loop2=0;loop2<m_nCol;loop2++)
				adInvValue[loop1][loop2]-=m_adValue[loop1][loop]*adInvValue[loop][loop2];
		}
	}

	for(loop=m_nRow-1;loop>=0;loop--){
		for(loop1=loop-1;loop1>=0;loop1--){
			for(loop2=0;loop2<m_nCol;loop2++)
				adInvValue[loop1][loop2]-=m_adValue[loop1][loop]*adInvValue[loop][loop2];
		}
	}

	for(loop=0;loop<m_nRow;loop++)
	for(loop1=0;loop1<m_nCol;loop1++)
		m_adValue[loop][loop1]=adInvValue[loop][loop1];

	for(loop=0;loop<m_nRow;loop++)
		delete[] adInvValue[loop];
	delete[]	adInvValue;

	return true;
}

CMatrix& CMatrix::operator =(double dBuf)
{
	for (int loop=0; loop < m_nRow; loop++)
	for (int loop1=0; loop1 < m_nCol; loop1++)
		 m_adValue[loop][loop1]=dBuf;
   return *this;
}