/*
============================================================================
Name : 矩阵实现
Author : Swair Fang
Version : 1.1
Copyright : by Swair Fang
Description : 堆内矩阵实现, Ansi-style
功能:
1.取反
2.赋值
3.加法
4。减法
5.点乘
6.点除
7.矩阵相乘
8.打印
9.随机数
============================================================================
*/
#ifndef _Matrix_H
#define _Matrix_H
#include
#include
#include
#include
using namespace std;
template
class CMatrix
{
typedef struct Mnode
{
T Elt;
struct Mnode *Right;
struct Mnode *Down;
} *Position;
private:
Position **Px;
int m_M;
int m_N;
public:
CMatrix();
CMatrix(int m,int n);
~CMatrix();
void Empty();
CMatrix(const CMatrix &SrcMatrix);
void operator~();
CMatrix& operator=(const CMatrix &SrcMatrix);
CMatrix& operator+(const CMatrix &SrcMatrix);
CMatrix& operator-(const CMatrix &SrcMatrix);
CMatrix& operator*(const CMatrix &SrcMatrix);
CMatrix& operator/(const CMatrix &SrcMatrix);
void MxMul(CMatrix &SrcMatrix);
void Print();
double MRand();
};
template
double CMatrix::MRand()
{
return (double)rand()/1000;
}
template
CMatrix::CMatrix(int m,int n)
{
m_M=m;
m_N=n;
Px=new Position*[m]; //开了一个"指针矩阵"空间
int t=0;
for(t=0;tRight=NULL;
P->Down=NULL;
Position Pbf=P;
Position Tmp=NULL;
int i=0; //矩阵第一行
int j;
for(j=0;jElt=MRand();
Tmp->Right=NULL;
Tmp->Down=NULL;
Px[i][j]=Tmp;
P->Right=Tmp;
P=P->Right;
}
for(i=1;iElt=MRand();
Tmp->Right=NULL;
Tmp->Down=NULL;
Px[i][j]=Tmp;
Px[i-1][j]->Down=Tmp;
P->Right=Tmp;
P=P->Right;
}
}
delete Pbf;
}
template
CMatrix::~CMatrix()
{
Position P=Px[0][0];
Position PbfDown;
Position Tmp;
while(P!=NULL)
{
PbfDown=P->Down;
while(P!=NULL)
{
Tmp=P;
P=P->Right;
delete Tmp;
}
P=PbfDown;
}
for(int t=0;t
void CMatrix::Empty()
{
Position P=Px[0][0];
Position PbfDown;
Position Tmp;
while(P!=NULL)
{
PbfDown=P->Down;
while(P!=NULL)
{
Tmp=P;
P=P->Right;
delete Tmp;
}
P=PbfDown;
}
for(int t=0;t
CMatrix::CMatrix(const CMatrix &SrcMatrix)
{
Position pMnode=Px[0][0];
Position pScrMnode=SrcMatrix.Px[0][0];
Position pMnodeTmp,pScrMnodeTmp;
while(pMnode!=NULL)
{
pMnodeTmp=pMnode;
pScrMnodeTmp=pScrMnode;
while(pMnode!=NULL)
{
pMnode->Elt=pScrMnode->Elt;
pMnode=pMnode->Right;
pScrMnode=pScrMnode->Right;
}
pMnode=pMnodeTmp->Down;
pScrMnode=pScrMnodeTmp->Down;
}
}
template
CMatrix& CMatrix::operator=(const CMatrix &SrcMatrix)
{
if(this==&SrcMatrix)
return *this;
if(&SrcMatrix!=NULL)
Empty();
m_M=SrcMatrix.m_M;
m_N=SrcMatrix.m_N;
CMatrix *DstMatrix=new CMatrix(m_M,m_N);
Position pMnode=DstMatrix->Px[0][0];
Position pScrMnode=SrcMatrix.Px[0][0];
Position pMnodeTmp,pScrMnodeTmp;
while(pMnode!=NULL)
{
pMnodeTmp=pMnode;
pScrMnodeTmp=pScrMnode;
while(pMnode!=NULL)
{
pMnode->Elt=pScrMnode->Elt;
pMnode=pMnode->Right;
pScrMnode=pScrMnode->Right;
}
pMnode=pMnodeTmp->Down;
pScrMnode=pScrMnodeTmp->Down;
}
Px=DstMatrix->Px;
return *this;
}
template
CMatrix& CMatrix::operator+(const CMatrix &SrcMatrix)
{
if(m_M!=SrcMatrix.m_M||m_N!=SrcMatrix.m_N)
{
printf("Matrix is not accordencd\n");
exit(1);
}
else
{
CMatrix *DstMatrix=new CMatrix(m_M,m_N);
Position pDstMnode=DstMatrix->Px[0][0];
Position pMnode=Px[0][0];
Position pScrMnode=SrcMatrix.Px[0][0];
Position pDstMnodeTmp,pMnodeTmp,pScrMnodeTmp;
while(pMnode!=NULL)
{
pDstMnodeTmp=pDstMnode;
pMnodeTmp=pMnode;
pScrMnodeTmp=pScrMnode;
while(pMnode!=NULL)
{
pDstMnode->Elt=pMnode->Elt+pScrMnode->Elt;
pDstMnode=pDstMnode->Right;
pMnode=pMnode->Right;
pScrMnode=pScrMnode->Right;
}
pDstMnode=pDstMnodeTmp->Down;
pMnode=pMnodeTmp->Down;
pScrMnode=pScrMnodeTmp->Down;
}
return *DstMatrix;
}
}
template
void CMatrix::operator~()
{
Position pMnode=Px[0][0];
Position pMnodeTmp;
while(pMnode!=NULL)
{
pMnodeTmp=pMnode;
while(pMnode!=NULL)
{
pMnode->Elt=~pMnode->Elt;
pMnode=pMnode->Right;
}
pMnode=pMnodeTmp->Down;
}
}
template
CMatrix& CMatrix::operator-(const CMatrix &SrcMatrix)
{
if(m_M!=SrcMatrix.m_M||m_N!=SrcMatrix.m_N)
{
printf("Matrix is not accordencd\n");
exit(1);
}
else
{
CMatrix *DstMatrix=new CMatrix(m_M,m_N);
Position pDstMnode=DstMatrix->Px[0][0];
Position pMnode=Px[0][0];
Position pScrMnode=SrcMatrix.Px[0][0];
Position pDstMnodeTmp,pMnodeTmp,pScrMnodeTmp;
while(pMnode!=NULL)
{
pDstMnodeTmp=pDstMnode;
pMnodeTmp=pMnode;
pScrMnodeTmp=pScrMnode;
while(pMnode!=NULL)
{
pDstMnode->Elt=pMnode->Elt-pScrMnode->Elt;
pDstMnode=pDstMnode->Right;
pMnode=pMnode->Right;
pScrMnode=pScrMnode->Right;
}
pDstMnode=pDstMnodeTmp->Down;
pMnode=pMnodeTmp->Down;
pScrMnode=pScrMnodeTmp->Down;
}
return *DstMatrix;
}
}
template
CMatrix& CMatrix::operator*(const CMatrix &SrcMatrix)
{
if(m_M!=SrcMatrix.m_M||m_N!=SrcMatrix.m_N)
{
printf("Matrix is not accordencd\n");
exit(1);
}
else
{
CMatrix *DstMatrix=new CMatrix(m_M,m_N);
Position pDstMnode=DstMatrix->Px[0][0];
Position pMnode=Px[0][0];
Position pScrMnode=SrcMatrix.Px[0][0];
Position pDstMnodeTmp,pMnodeTmp,pScrMnodeTmp;
while(pMnode!=NULL)
{
pDstMnodeTmp=pDstMnode;
pMnodeTmp=pMnode;
pScrMnodeTmp=pScrMnode;
while(pMnode!=NULL)
{
pDstMnode->Elt=pMnode->Elt*pScrMnode->Elt;
pDstMnode=pDstMnode->Right;
pMnode=pMnode->Right;
pScrMnode=pScrMnode->Right;
}
pDstMnode=pDstMnodeTmp->Down;
pMnode=pMnodeTmp->Down;
pScrMnode=pScrMnodeTmp->Down;
}
return *DstMatrix;
}
}
template
CMatrix& CMatrix::operator/(const CMatrix &SrcMatrix)
{
if(m_M!=SrcMatrix.m_M||m_N!=SrcMatrix.m_N)
{
printf("Matrix is not accordencd\n");
exit(1);
}
else
{
CMatrix *DstMatrix=new CMatrix(m_M,m_N);
Position pDstMnode=DstMatrix->Px[0][0];
Position pMnode=Px[0][0];
Position pScrMnode=SrcMatrix.Px[0][0];
Position pDstMnodeTmp,pMnodeTmp,pScrMnodeTmp;
while(pMnode!=NULL)
{
pDstMnodeTmp=pDstMnode;
pMnodeTmp=pMnode;
pScrMnodeTmp=pScrMnode;
while(pMnode!=NULL)
{
pDstMnode->Elt=pMnode->Elt/pScrMnode->Elt;
pDstMnode=pDstMnode->Right;
pMnode=pMnode->Right;
pScrMnode=pScrMnode->Right;
}
pDstMnode=pDstMnodeTmp->Down;
pMnode=pMnodeTmp->Down;
pScrMnode=pScrMnodeTmp->Down;
}
return *DstMatrix;
}
}
template
void CMatrix::MxMul(CMatrix &SrcMatrix)
{
if(m_N!=SrcMatrix.m)
{
printf("Matrix can not be Multiplied\n");
exit(1);
}
else
{
int i,j,k;
for(i=0;iElt=0;
for(k=0;kElt+=(Px[i][k]->Elt)*(SrcMatrix.Px[k][j]->Elt);
}
}
}
}
template
void CMatrix::Print()
{
Position pMnode=Px[0][0];
Position pMnodeTmp;
while(pMnode!=NULL)
{
pMnodeTmp=pMnode;
while(pMnode!=NULL)
{
char *cp=(char*)pMnode;
// printf("0x%x: %10f ",cp,pMnode->Elt);
printf("%10f ",pMnode->Elt);
pMnode=pMnode->Right;
}
printf("\n");
pMnode=pMnodeTmp->Down;
}
printf("\n");
}
#endif/*_Matrix_H*/
int main(void)
{
printf("===============初始化矩阵===============\n");
printf("M1,M2,M3\n");
CMatrix M1(3,2);
CMatrix M2(3,2);
CMatrix M3(3,2);
M1.Print();
M2.Print();
M3.Print();
cout<<"------M3=M1---------"<