📄 complexmatrix.cpp

📁 这是一个复数矩阵计算的源代码
💻 CPP
字号:
// SparseMatrix.cpp: implementation of the CComplexMatrix class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ComplexMatrix.h"
//#include <stddef.h>
#include "math.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CComplexMatrix::CComplexMatrix()
{
   pHead=NULL;
   pTail=NULL;
   pCurrent=NULL;
   pData=NULL;
}

void CComplexMatrix::Create(int row,int col)
{
	pHead=NULL;
	pTail=NULL;
	pCurrent=NULL;
	pData=NULL;

	if(row>0&&col>0)
	{
		pHead=new CNode;
		pHead->nRow=row;
		pHead->nCol=col;
		pHead->pNext=NULL;
		pHead->pPrev=NULL;
		int n=(row>col)?row:col;
		pCurrent=pHead;
		for(int i=1;i<=n;++i)
		{
			pCurrent->pNext=new CNode;
			pCurrent->pNext->pPrev=pCurrent;
			pCurrent=pCurrent->pNext;
			if(row>=i) pCurrent->nRow=i;
			else pCurrent->nRow=0;
			if(col>=i) pCurrent->nCol=i;
			else pCurrent->nCol=0;
			pCurrent->pNext=NULL;
			pCurrent->pRight=NULL;
			pCurrent->pDown=NULL;
		}

		pTail=new CNode;
		pTail->nRow=row;
		pTail->nCol=col;
		pTail->pNext=NULL;
		pTail->pPrev=pCurrent;
		pCurrent->pNext=pTail;

		pCurrent=pHead;
	}
}

CComplexMatrix::~CComplexMatrix()
{
	Empty();
}

void CComplexMatrix::Copy(const CComplexMatrix &src)
{
	pHead=NULL;
	pTail=NULL;
	pCurrent=NULL;
	pData=NULL;

    //copy head pointer
	CNode *psrcCurrent=src.pHead;
    while(psrcCurrent!=NULL)
	{
		if(pHead==NULL)
		{
			pCurrent=new CNode;
			pCurrent->pPrev=NULL;
			pHead=pCurrent;
		}
		else
		{
			pCurrent->pNext=new CNode;
			pCurrent->pNext->pPrev=pCurrent;
			pCurrent=pCurrent->pNext;
		}
		pCurrent->nRow=psrcCurrent->nRow;
		pCurrent->nCol=psrcCurrent->nCol;
		pCurrent->pRight=NULL;
		pCurrent->pDown=NULL;
		pCurrent->pNext=NULL;
		pTail=pCurrent;

		psrcCurrent=psrcCurrent->pNext;
	}
	
	//copy node of data
	psrcCurrent=src.pHead;
	if(psrcCurrent!=NULL)
	{
		pCurrent=pHead;
		psrcCurrent=psrcCurrent->pNext;
		while(psrcCurrent!=NULL)
		{
			pCurrent=pCurrent->pNext;
			CNode *psrcData=psrcCurrent->pRight;
			pData=pCurrent;
			while(psrcData!=NULL)
			{
				//row table
				pData->pRight=new CNode;
				pData=pData->pRight;
				pData->nRow=psrcData->nRow;
				pData->nCol=psrcData->nCol;
				pData->pRight=NULL;
				pData->pDown=NULL;
				pData->data=psrcData->data;
				
				//col table
				CNode *pTemp=pHead;
				for(int i=0;i<pData->nCol;++i)
					pTemp=pTemp->pNext;
				while(pTemp->pDown!=NULL)
					pTemp=pTemp->pDown;
				pTemp->pDown=pData;

				psrcData=psrcData->pRight;
			}
		psrcCurrent=psrcCurrent->pNext;
		}
	}
	pCurrent=pHead;
}

///////////////////////////////////////////
//Function
//////////////////////////////////////////

void CComplexMatrix::operator =(const CComplexMatrix &src)
{
	Empty();
	Copy(src);
}

void CComplexMatrix::Empty()
{
	if(pHead!=NULL)
	{
		pCurrent=pHead->pNext;
		delete pHead;
		pHead=NULL;
		while(pCurrent!=pTail)
		{
			pData=pCurrent;
			pCurrent=pCurrent->pNext;
			while(pData!=NULL)
			{
				CNode *pTemp=pData->pRight;
				delete pData;
				pData=pTemp;
			}
		}
	delete pTail;
	pTail=NULL;
	}
}

void CComplexMatrix::Store(int row,int col,const Complex newElement)
{
	if(pHead!=NULL&&row>0&&row<=pHead->nRow&&col>0&&col<=pHead->nCol)
	{
		pData=pHead;
		for(int i=0;i<row;++i)
			pData=pData->pNext;
		while(pData->pRight!=NULL&&pData->pRight->nCol<col)
			pData=pData->pRight;
		if(pData->pRight!=NULL&&pData->pRight->nCol==col)
		{
			//replace an item
			pData=pData->pRight;
			pData->data=newElement;
		}
		else
		{
			CNode *pNewNode=new CNode;
			pNewNode->nRow=row;
			pNewNode->nCol=col;
			pNewNode->data=newElement;

			//row add an item
			pNewNode->pRight=pData->pRight;
			pData->pRight=pNewNode;

			//col add an item
			pData=pHead;
			for(i=0;i<col;++i)
				pData=pData->pNext;
			while(pData->pDown!=NULL&&pData->pDown->nRow<row)
				pData=pData->pDown;
			pNewNode->pDown=pData->pDown;
			pData->pDown=pNewNode;

			pData=pNewNode;
		}
	}
}

void CComplexMatrix::Add(int row, int col, const Complex newElement)
{
	if(pHead!=NULL&&row>0&&row<=pHead->nRow&&col>0&&col<=pHead->nCol)
	{
		pData=pHead;
		for(int i=0;i<row;++i)
			pData=pData->pNext;
		while(pData->pRight!=NULL&&pData->pRight->nCol<col)
			pData=pData->pRight;
		if(pData->pRight!=NULL&&pData->pRight->nCol==col)
		{
			//add newElement 
			pData=pData->pRight;
			pData->data+=newElement;
		}
		else
		{
			//store newElement
			CNode *pNewNode=new CNode;
			pNewNode->nRow=row;
			pNewNode->nCol=col;
			pNewNode->data=newElement;

			//row add an item
			pNewNode->pRight=pData->pRight;
			pData->pRight=pNewNode;

			//col add an item
			pData=pHead;
			for(i=0;i<col;++i)
				pData=pData->pNext;
			while(pData->pDown!=NULL&&pData->pDown->nRow<row)
				pData=pData->pDown;
			pNewNode->pDown=pData->pDown;
			pData->pDown=pNewNode;

			pData=pNewNode;
		}
	}
}

void CComplexMatrix::GetData(int &row,int &col,Complex &data)
{
	if(pData!=NULL)
	{
		row=pData->nRow;
		col=pData->nCol;
		data=pData->data;
	}
	else
	{
		row=0;
		col=0;
	}
}

void CComplexMatrix::GoToHead()
{
	pCurrent=pHead;
}

void CComplexMatrix::GoToTail()
{
	pCurrent=pTail;
}

void CComplexMatrix::GoNext()
{
	if(pCurrent->pNext!=pTail)
	{
		pCurrent=pCurrent->pNext;
		pData=pCurrent;
	}
}

void CComplexMatrix::GoPrev()
{
	if(pCurrent->pPrev!=pHead)
	{
		pCurrent=pCurrent->pPrev;
		pData=pCurrent;
	}
}

void CComplexMatrix::GoRight()
{
	if(pData!=NULL)
		pData=pData->pRight;
}

void CComplexMatrix::GoDown()
{
	if(pData!=NULL)
		pData=pData->pDown;
}

CComplexMatrix CComplexMatrix::operator +(const CComplexMatrix &src)
{
	CComplexMatrix newMatrix;
	if(pHead!=NULL&&src.pHead!=NULL&&pHead->nRow==src.pHead->nRow&&pHead->nCol==src.pHead->nCol)
	{
		newMatrix.Create(pHead->nRow,pHead->nCol);
		pCurrent=pHead;
		CNode *psrcCurrent=src.pHead;
		for(int i=1;i<=pHead->nRow;++i)
		{
			pCurrent=pCurrent->pNext;
			psrcCurrent=psrcCurrent->pNext;
			pData=pCurrent->pRight;
			CNode *psrcData=psrcCurrent->pRight;
			while(pData!=NULL&&psrcData!=NULL)
				{
 					if(pData->nCol<psrcData->nCol)
					{
						newMatrix.Store(i,pData->nCol,pData->data);
						pData=pData->pRight;
					}
					else if(pData->nCol>psrcData->nCol)
					{
						newMatrix.Store(i,psrcData->nCol,psrcData->data);
						psrcData=psrcData->pRight;
					}
					else
					{
						Complex data=pData->data+psrcData->data;
						if(data!=Complex(0,0))
							newMatrix.Store(i,pData->nCol,data);
						pData=pData->pRight;
						psrcData=psrcData->pRight;
					}
				}
			while(pData!=NULL)
			{
				newMatrix.Store(i,pData->nCol,pData->data);
				pData=pData->pRight;
			}
			while(psrcData!=NULL)
			{
				newMatrix.Store(i,psrcData->nCol,psrcData->data);
				psrcData=psrcData->pRight;
			}
		}
	}
	return(newMatrix);
}

CComplexMatrix CComplexMatrix::operator -(const CComplexMatrix &src)
{
	CComplexMatrix newMatrix;
	if(pHead!=NULL&&src.pHead!=NULL&&pHead->nRow==src.pHead->nRow&&pHead->nCol==src.pHead->nCol)
	{
		newMatrix.Create(pHead->nRow,pHead->nCol);
		pCurrent=pHead;
		CNode *psrcCurrent=src.pHead;
		for(int i=1;i<=pHead->nRow;++i)
		{
			pCurrent=pCurrent->pNext;
			psrcCurrent=psrcCurrent->pNext;
			pData=pCurrent->pRight;
			CNode *psrcData=psrcCurrent->pRight;
			while(pData!=NULL&&psrcData!=NULL)
				{
 					if(pData->nCol<psrcData->nCol)
					{
						newMatrix.Store(i,pData->nCol,pData->data);
						pData=pData->pRight;
					}
					else if(pData->nCol>psrcData->nCol)
					{
						newMatrix.Store(i,psrcData->nCol,-psrcData->data);
						psrcData=psrcData->pRight;
					}
					else
					{
						Complex data=pData->data-psrcData->data;
						if(data!=Complex(0,0))
							newMatrix.Store(i,pData->nCol,data);
						pData=pData->pRight;
						psrcData=psrcData->pRight;
					}
				}
			while(pData!=NULL)
			{
				newMatrix.Store(i,pData->nCol,pData->data);
				pData=pData->pRight;
			}
			while(psrcData!=NULL)
			{
				newMatrix.Store(i,psrcData->nCol,-psrcData->data);
				psrcData=psrcData->pRight;
			}
		}
	}
	return(newMatrix);
}

CComplexMatrix CComplexMatrix::operator *(const CComplexMatrix &src)
{
	CComplexMatrix newMatrix;
	if(pHead!=NULL&&src.pHead!=NULL&&pHead->nCol==src.pHead->nRow)
	{
		newMatrix.Create(pHead->nRow,src.pHead->nCol);
		pCurrent=pHead;
		for(int i=1;i<=pHead->nRow;++i)
		{
			pCurrent=pCurrent->pNext;
			CNode *psrcCurrent=src.pHead;
			for(int j=1;j<=src.pHead->nCol;++j)
			{
				psrcCurrent=psrcCurrent->pNext;
				pData=pCurrent->pRight;
				CNode *psrcData=psrcCurrent->pDown;
				Complex data=0;
				while(pData!=NULL&&psrcData!=NULL)
				{
 					if(pData->nCol<psrcData->nRow)
						pData=pData->pRight;
					else if(pData->nCol>psrcData->nRow)
						psrcData=psrcData->pDown;
					else
					{
						data+=pData->data*psrcData->data;  
						pData=pData->pRight;
						psrcData=psrcData->pDown;
					}
				}
				if(data!=Complex(0,0)) newMatrix.Store(i,j,data);
			}
		}
	}
	return(newMatrix);
}

void CComplexMatrix::operator +=(const CComplexMatrix &src)
{
	CComplexMatrix newMatrix;
	if(pHead!=NULL&&src.pHead!=NULL&&pHead->nRow==src.pHead->nRow&&pHead->nCol==src.pHead->nCol)
	{
		newMatrix.Create(pHead->nRow,pHead->nCol);
		pCurrent=pHead;
		CNode *psrcCurrent=src.pHead;
		for(int i=1;i<=pHead->nRow;++i)
		{
			pCurrent=pCurrent->pNext;
			psrcCurrent=psrcCurrent->pNext;
			pData=pCurrent->pRight;
			CNode *psrcData=psrcCurrent->pRight;
			while(pData!=NULL&&psrcData!=NULL)
				{
 					if(pData->nCol<psrcData->nCol)
					{
						newMatrix.Store(i,pData->nCol,pData->data);
						pData=pData->pRight;
					}
					else if(pData->nCol>psrcData->nCol)
					{
						newMatrix.Store(i,psrcData->nCol,psrcData->data);
						psrcData=psrcData->pRight;
					}
					else
					{
						Complex data=pData->data+psrcData->data;
						if(data!=Complex(0,0))
							newMatrix.Store(i,pData->nCol,data);
						pData=pData->pRight;
						psrcData=psrcData->pRight;
					}
				}
			while(pData!=NULL)
			{
				newMatrix.Store(i,pData->nCol,pData->data);
				pData=pData->pRight;
			}
			while(psrcData!=NULL)
			{
				newMatrix.Store(i,psrcData->nCol,psrcData->data);
				psrcData=psrcData->pRight;
			}
		}
	}
	Empty();
	Copy(newMatrix);
}

void CComplexMatrix::operator -=(const CComplexMatrix &src)
{
	CComplexMatrix newMatrix;
	if(pHead!=NULL&&src.pHead!=NULL&&pHead->nRow==src.pHead->nRow&&pHead->nCol==src.pHead->nCol)
	{
		newMatrix.Create(pHead->nRow,pHead->nCol);
		pCurrent=pHead;
		CNode *psrcCurrent=src.pHead;
		for(int i=1;i<=pHead->nRow;++i)
		{
			pCurrent=pCurrent->pNext;
			psrcCurrent=psrcCurrent->pNext;
			pData=pCurrent->pRight;
			CNode *psrcData=psrcCurrent->pRight;
			while(pData!=NULL&&psrcData!=NULL)
				{
 					if(pData->nCol<psrcData->nCol)
					{
						newMatrix.Store(i,pData->nCol,pData->data);
						pData=pData->pRight;
					}
					else if(pData->nCol>psrcData->nCol)
					{
						newMatrix.Store(i,psrcData->nCol,-psrcData->data);
						psrcData=psrcData->pRight;
					}
					else
					{
						Complex data=pData->data-psrcData->data;
						if(data!=Complex(0,0))
							newMatrix.Store(i,pData->nCol,data);
						pData=pData->pRight;
						psrcData=psrcData->pRight;
					}
				}
			while(pData!=NULL)
			{
				newMatrix.Store(i,pData->nCol,pData->data);
				pData=pData->pRight;
			}
			while(psrcData!=NULL)
			{
				newMatrix.Store(i,psrcData->nCol,-psrcData->data);
				psrcData=psrcData->pRight;
			}
		}
	}
	Empty();
	Copy(newMatrix);
}

void CComplexMatrix::operator *=(const CComplexMatrix &src)
{
	CComplexMatrix newMatrix;
	if(pHead!=NULL&&src.pHead!=NULL&&pHead->nCol==src.pHead->nRow)
	{
		newMatrix.Create(pHead->nRow,src.pHead->nCol);
		pCurrent=pHead;
		for(int i=1;i<=pHead->nRow;++i)
		{
			pCurrent=pCurrent->pNext;
			CNode *psrcCurrent=src.pHead;
			for(int j=1;j<=src.pHead->nCol;++j)
			{
				psrcCurrent=psrcCurrent->pNext;
				pData=pCurrent->pRight;
				CNode *psrcData=psrcCurrent->pDown;
				Complex data=0;
				while(pData!=NULL&&psrcData!=NULL)
				{
 					if(pData->nCol<psrcData->nRow)
						pData=pData->pRight;
					else if(pData->nCol>psrcData->nRow)
						psrcData=psrcData->pDown;
					else
					{
						data+=pData->data*psrcData->data;  
						pData=pData->pRight;
						psrcData=psrcData->pDown;
					}
				}
				if(data!=Complex(0,0)) newMatrix.Store(i,j,data);
			}
		}
	}
	Empty();
	Copy(newMatrix);
}

CComplexMatrix CComplexMatrix::operator -()
{
	CComplexMatrix newMatrix;
    
    if(pHead!=NULL)
	{
		newMatrix.Create(pHead->nRow,pHead->nCol);
		pCurrent=pHead;
		newMatrix.pCurrent=newMatrix.pHead;
		pCurrent=pCurrent->pNext;
		while(pCurrent!=NULL)
		{
			newMatrix.pCurrent=newMatrix.pCurrent->pNext;
			pData=pCurrent->pRight;
			newMatrix.pData=newMatrix.pCurrent;
			while(pData!=NULL)
			{
				//row table
				newMatrix.pData->pRight=new CNode;
				newMatrix.pData=newMatrix.pData->pRight;
				newMatrix.pData->nRow=pData->nRow;
				newMatrix.pData->nCol=pData->nCol;
				newMatrix.pData->pRight=NULL;
				newMatrix.pData->pDown=NULL;
				newMatrix.pData->data=-pData->data;
				
				//col table
				CNode *pTemp=newMatrix.pHead;
				for(int i=0;i<newMatrix.pData->nCol;++i)
					pTemp=pTemp->pNext;
				while(pTemp->pDown!=NULL)
					pTemp=pTemp->pDown;
				pTemp->pDown=newMatrix.pData;

				pData=pData->pRight;
			}
		pCurrent=pCurrent->pNext;
		}
	}
	return(newMatrix);
}

CComplexMatrix CComplexMatrix::Transpose()
{
	CComplexMatrix newMatrix;
	if(pHead!=NULL)
	{
		newMatrix.Create(pHead->nCol,pHead->nRow);
		pCurrent=pHead;
		newMatrix.pCurrent=newMatrix.pHead;
		pCurrent=pCurrent->pNext;
		while(pCurrent!=NULL)
		{
			newMatrix.pCurrent=newMatrix.pCurrent->pNext;
			pData=pCurrent->pRight;
			newMatrix.pData=newMatrix.pCurrent;
			while(pData!=NULL)
			{
				//row transpose to col 
				newMatrix.pData->pDown=new CNode;
				newMatrix.pData=newMatrix.pData->pDown;
				newMatrix.pData->nRow=pData->nCol;
				newMatrix.pData->nCol=pData->nRow;
				newMatrix.pData->pRight=NULL;
				newMatrix.pData->pDown=NULL;
				newMatrix.pData->data=pData->data;
				
				//col transpose to row
				CNode *pTemp=newMatrix.pHead;
				for(int i=0;i<newMatrix.pData->nRow;++i)
					pTemp=pTemp->pNext;
				while(pTemp->pRight!=NULL)
					pTemp=pTemp->pRight;
				pTemp->pRight=newMatrix.pData;

				pData=pData->pRight;
			}
		pCurrent=pCurrent->pNext;
		}
	}
	return(newMatrix);
}
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -