matrix1.cpp

该软件是我读硕士的时候写的

// Matrix.cpp: implementation of the CMatrix1 class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Process.h"
#include "Matrix1.h"
#include <math.h>

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

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CMatrix1::CMatrix1()
{
	m_nNumColumns=1;
	m_nNumRows=1;
	m_pData=NULL;
	Init(m_nNumRows, m_nNumColumns);
}

CMatrix1::CMatrix1(int nRows,int nCols)
{
	m_nNumRows=nRows;
	m_nNumColumns=nCols;
	m_pData=NULL;
	Init(m_nNumRows, m_nNumColumns);
}

CMatrix1::CMatrix1(int nRows,int nCols,double value[])
{
	m_nNumColumns=nCols;
	m_nNumRows=nRows;
	m_pData=NULL;
	Init(m_nNumRows, m_nNumColumns);
	
	SetData(value);
}
/*
CMatrix1::CMatrix1(int nSize)
{
	m_nNumColumns=nSize;
	m_nNumRows=nSize;
	m_pData=NULL;
	Init(nSize,nSize);
}

CMatrix1::CMatrix1(int nSize,double value[])
{
	m_nNumColumns=nSize;
	m_nNumRows=nSize;
	m_pData=NULL;
	Init(nSize,nSize);
	
	SetData(value);
}
*/
CMatrix1::CMatrix1(const CMatrix1& other)
{
	m_nNumColumns=other.GetNumColumns();
	m_nNumRows=other.GetNumRows();
	m_pData=NULL;
	Init(m_nNumRows,m_nNumColumns);
	memcpy(m_pData,other.m_pData,sizeof(double)* m_nNumColumns* m_nNumRows );
}

CMatrix1::~CMatrix1( )
{
	if  (m_pData)
	{
		delete m_pData;
		m_pData=NULL;
	}
}

BOOL CMatrix1::Init(int nRows,int nCols)
{
	if(m_pData)
	{
		delete[] m_pData;
		m_pData=NULL;
	}
	
	m_nNumRows=nRows;
	m_nNumColumns=nCols;
	int nSize=nCols*nRows;
	if(nSize<0)
		return FALSE;
	
	m_pData=new double[nSize];
	
	if(m_pData==NULL)
		return FALSE;
	if(IsBadReadPtr(m_pData,sizeof(double)*nSize))
	    return FALSE;
	
	memset(m_pData,0,sizeof(double)*nSize);
	
	return TRUE;
}

BOOL CMatrix1::InvertGaussJordan( )
{
	int  *pnRow,*pnCol,i,j,k,l,u,v;
	double d=0, p=0;

	pnRow = new int[m_nNumColumns];
	pnCol = new int[m_nNumColumns];

	if(pnRow==NULL||pnCol==NULL)
		return FALSE;
	
	for(k=0;k<=m_nNumColumns-1;k++)
	{
		d=0.0;
		for(i=k;i<=m_nNumColumns-1;i++)
		{
			for(j=k;j<=m_nNumColumns-1;j++)
			{
				l=i*m_nNumColumns+j;p=fabs(m_pData[l]);
				if(p>d)
				{
					d=p;
				    pnRow[k]=i;
				    pnCol[k]=j;
				}
			}
		}
	
	
	
	if(d==0.0)
	{
		delete[]  pnRow;
		delete[]  pnCol;
		return FALSE;
	}
	
	
	if (pnRow[k]!=k)
	{
		for(j=0;j<=m_nNumColumns-1;j++)
		{
			u=k*m_nNumColumns+j;
			v=pnRow[k]*m_nNumColumns+j;
			p=m_pData[u];
			m_pData[u]=m_pData[v];
			m_pData[v]=p;
		}
	}
	
	if   (pnCol[k]!=k)
	{
		for  (i=0; i<=m_nNumColumns-1; i++)
		{
			u=i*m_nNumColumns+k;
			v=i*m_nNumColumns+pnCol[k];
			p=m_pData[u];
			m_pData[u]=m_pData[v];
			m_pData[v]=p;
		}
	}
	
	l=k*m_nNumColumns+k;
	m_pData[l]=1.0/m_pData[l];
	for(j=0;j<=m_nNumColumns-1;j++)
	{
		if(j!=k)
		{
			u= k*m_nNumColumns+j;
			m_pData[u] =m_pData[u]* m_pData[l];
		}
	}
	
	for(i=0;i<=m_nNumColumns-1;i++)
	{
		if(i!=k)
		{
			for(j=0;j<=m_nNumColumns-1;j++)
			{
				if(j!=k)
				{
					u= i*m_nNumColumns+j; 
					m_pData[u]=m_pData[u]-m_pData[i*m_nNumColumns+k]* m_pData[k*m_nNumColumns+j];
				}
			}
		}
	}
	
	
	for(i=0;i<=m_nNumColumns-1;i++)
	{
		if(i!=k)
		{
			u= i*m_nNumColumns+k;
			m_pData[u] =-m_pData[u]* m_pData[l];
		}
	}
}

for(k= m_nNumColumns-1;k>=0;k--)
{
	if(pnCol[k]!=k)
	{
		for(j=0;j<=m_nNumColumns-1;j++)
		{
			u= k*m_nNumColumns+j;
			v= pnCol[k]* m_nNumColumns+j;
			p=m_pData[u];
			m_pData[u]= m_pData[v];
			m_pData[v]=p;
        }
	}
	
	if(pnRow[k]!=k)
	{
		for  (i=0;i<=m_nNumColumns-1;i++)
		{
			u=i*m_nNumColumns+k;
			v=i*m_nNumColumns+pnRow[k];
			p=m_pData[u];
			m_pData[u]=m_pData[v];
			m_pData[v]=p;
		}
	}
}

delete[] pnRow;
delete[] pnCol;

return  TRUE;
}



BOOL CMatrix1::MakeUnitMatrix(int nSize)
{
	if(!Init(nSize,nSize))
		return  FALSE;

	for  (int  i=0; i<nSize;++i)
		for(int  j=0;j<nSize;++j)
			if  (i == j)
				SetElement(i,j,1);

			return TRUE;
}


void CMatrix1::SetData(double value[])
{
	//empty the memory
	memset(m_pData,0,sizeof(double) * m_nNumColumns*m_nNumRows);
	//copy data
	memcpy(m_pData,value,sizeof(double)*m_nNumColumns*m_nNumRows);
}

BOOL CMatrix1::SetElement(int nRow,int nCol,double value)
{
	if  (nCol<0||nCol>=m_nNumColumns||nRow<0||nRow>=m_nNumRows)
		return FALSE;                        //array bounds error
	if(m_pData == NULL)
		return  FALSE;                       //bad pointer error

	m_pData[nCol + nRow*m_nNumColumns] = value;
	
	return  TRUE;
}

double* CMatrix1::GetData() const
{
	return m_pData;
}

double CMatrix1::GetElement(int nRow, int nCol)  const
{
	ASSERT(nCol>=0 && nCol<m_nNumColumns && nRow>=0 && nRow>=0 && nRow<m_nNumRows);
	ASSERT(m_pData);
	return m_pData[nCol + nRow*m_nNumColumns];
}

int CMatrix1::GetNumColumns()  const
{
	return m_nNumColumns;
}

int CMatrix1::GetNumRows()  const
{
	return m_nNumRows;
}

CMatrix1& CMatrix1::operator=(const CMatrix1& other)
{
	if(&other!=this)
	{
		m_nNumColumns=other.GetNumColumns();
		m_nNumRows=other.GetNumRows();
		
		Init(m_nNumRows, m_nNumColumns);
		
		memcpy(m_pData,other.m_pData,sizeof(double)* m_nNumColumns* m_nNumRows);
		
	}
		return *this;
}
	
CMatrix1 CMatrix1::operator+(const CMatrix1& other) const
{
		ASSERT(m_nNumColumns==other.GetNumColumns() && m_nNumRows==other.GetNumRows());
        CMatrix1 result(*this);

		for(int i=0;i<m_nNumRows;++i)
		{
			for(int j=0;j<m_nNumColumns;++j)
				result.SetElement(i,j,result.GetElement(i,j)+other.GetElement(i,j));
		}

		return result;
}
	
CMatrix1 CMatrix1::operator-(const CMatrix1& other) const
{
		ASSERT(m_nNumColumns==other.GetNumColumns() && m_nNumRows==other.GetNumRows());

        CMatrix1 result(*this);

		for(int i=0;i<m_nNumRows;++i)
		{
			for(int j=0;j<m_nNumColumns;++j)
				result.SetElement(i,j,result.GetElement(i,j)-other.GetElement(i,j));
		}

		return result;
}
	
    
CMatrix1 CMatrix1::operator*(double value) const
{
        CMatrix1 result(*this);

		for(int i=0;i<m_nNumRows;++i)
		{
			for(int j=0;j<m_nNumColumns;++j)
				result.SetElement(i,j,result.GetElement(i,j)*value);
		}

		return result;
}
	
CMatrix1 CMatrix1::operator*(const CMatrix1& other)const
{
		ASSERT(m_nNumColumns==other.GetNumRows());
        CMatrix1 result(m_nNumRows,other.GetNumColumns());
		double value;

		for(int i=0;i<result.GetNumRows();i++)
		{
			for(int j=0;j<other.GetNumColumns();j++)
			{
				value=0.0;
				for(int k=0;k<m_nNumColumns;k++)
				{
					value+= GetElement(i,k)*other.GetElement(k,j);//???
				}

				result.SetElement(i,j,value);
			}
		}

		return result;
}
	
CMatrix1 CMatrix1::Transpose() const
{
	CMatrix1 Trans(m_nNumColumns,m_nNumRows);
	
	for(int i=0;i<m_nNumRows;++i)
	{
		for(int j=0; j<m_nNumColumns; ++j)
		{
			Trans.SetElement(j,i,GetElement(i,j));
		}
		
		
	}
    return Trans;
}