cmatrix.cpp

《VC++ 编程技巧与示例 .rar》各个示例代码绝对可用

// CMatrix.cpp: implementation of the CMatrix class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#include "stdlib.h"
#include "stdio.h"
#include "math.h"
#include "iostream.h"
#include "CMatrix.h"

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

///////////////////////////////////
//      CMatrix Ver 1999.12.9    //
//        Programmed by HuYu     //
///////////////////////////////////

CMatrix::CMatrix()
{
	rows =0;
	cols =0;
	size =0;
	elems=0;
}

CMatrix::CMatrix(unsigned rs,unsigned cs)
{
	unsigned size,i;
	rows=rs;
	cols=cs;
	size=rows*cols;
	elems=new double[rows*cols];
	for(i=0;i<size;i++)
	{
		elems[i]=0;
	}
}

CMatrix::CMatrix(unsigned r)
{
	unsigned i;
	rows=r;
	cols=r;
	size=rows*cols;
	elems=new double[rows*cols];
	for(i=0;i<size;i++)
	{
		elems[i]=0;
	}
}

CMatrix::CMatrix(const CMatrix & mtr)
{
	unsigned i,j;
	rows=mtr.rows;	
	cols=mtr.cols;
	elems=new double[rows*cols];
	for(i=0;i<rows;i++)
	{
		for(j=0;j<cols;j++)
		{
			elems[i*cols+j]=mtr.elems[i*cols+j];
		}
	}
}

CMatrix::CMatrix(unsigned rs, unsigned cs, double val [ ])
{
	unsigned size,i;
	rows=rs;
	cols=cs;
	size=rows*cols;
	elems=new double[rows*cols];
	for(i=0;i<size;i++)
	{
		elems[i]=val[i];
	}
}

CMatrix::~CMatrix()
{
	if(elems!=0)
	{
		delete [] elems;
	}
	elems=0;
}

//设置矩阵的某一项数据：
void CMatrix::setelem(unsigned row, unsigned col, double val)
{
	if(row>=0&&row<=rows&&col>=0&&col<=cols)
	{
		elems[row*cols+col]=val;
	}
}

//设置矩阵的数据：
void CMatrix::setvalue(double val[])
{
	unsigned i,j;
	for(i=0;i<rows;i++)
	{
		for(j=0;j<cols;j++)
		{
			elems[i*cols+j]=val[i*cols+j];
		}
	}
}

void CMatrix::setvalue(unsigned r,unsigned c)
{
	unsigned size,i;
	rows=r;
	cols=c;
	size=rows*cols;
	if(elems!=0)
	{
		delete elems;
	}
	elems=new double[rows*cols];
	for(i=0;i<size;i++)
	{
		elems[i]=0;
	}
}


void CMatrix::setvalue(unsigned r,unsigned c,double val[])
{
	unsigned size,i;
	rows=r;
	cols=c;
	size=rows*cols;
	if(elems!=0)
	{
		delete elems;
	}
	elems=new double[rows*cols];
	for(i=0;i<size;i++)
	{
		elems[i]=val[i];
	}
}

void CMatrix::setvalue(double var)
{
	UINT i;
	for(i=0;i<size;i++)
	{
		elems[i]=var;
	}
}

//对矩阵的(r,c)元素进行消元：
void CMatrix::delelem(unsigned r,unsigned c)
{
	unsigned i,j;
	double temp;
	if(r>rows||c>cols)
	{
		AfxMessageBox("delelem错误：行号或列号越界！");
		return;
	}
	temp=elems[r*cols+c];

	if(fabs(temp-0.00000)<0.000001)
	{
		AfxMessageBox("delelem错误：所选主元为0！");
	}
	for(j=0;j<cols;j++)
	{
		elems[r*cols+j]=elems[r*cols+j]/temp;
	}

	for(i=0;i<rows;i++)
	{
		if(i!=r)
		{
			temp=elems[i*cols+c];
			for(j=0;j<cols;j++)
			{
				elems[i*cols+j]=
				elems[i*cols+j]-
				elems[r*cols+j]*temp;
			}
		}
	}
}

//将矩阵对角线元素单位化：
void CMatrix::unit()
{
	unsigned i;
	if(rows>cols)
	{
		AfxMessageBox("unit错误：对角元素初始化失败：rows>cols!");
		return;
	}

	for(i=0;i<rows;i++)
	{
		delelem(i,i);
	}
}

//求行列式值：
double CMatrix::det()
{   int i,j,k,is,js,l,u,v;
    double f,det,q,d;
	double * a;
	int    n;

	if(rows!=cols)
	{
		return 0;
	}
	
	a=elems;
	n=rows ;

    f=1.0; det=1.0;
    for (k=0; k<=n-2; k++)
      { q=0.0;
        for (i=k; i<=n-1; i++)
        for (j=k; j<=n-1; j++)
          { l=i*n+j; d=fabs(a[l]);
	    if (d>q) { q=d; is=i; js=j;}
          }
        if (q+1.0==1.0)
          { det=0.0; return(det);}
        if (is!=k)
          { f=-f;
            for (j=k; j<=n-1; j++)
              { u=k*n+j; v=is*n+j;
                d=a[u]; a[u]=a[v]; a[v]=d;
              }
          }
        if (js!=k)
          { f=-f;
            for (i=k; i<=n-1; i++)
              { u=i*n+js; v=i*n+k;
                d=a[u]; a[u]=a[v]; a[v]=d;
              }
          }
        l=k*n+k;
        det=det*a[l];
        for (i=k+1; i<=n-1; i++)
          { d=a[i*n+k]/a[l];
            for (j=k+1; j<=n-1; j++)
              { u=i*n+j;
                a[u]=a[u]-d*a[k*n+j];
              }
          }
      }
    det=f*det*a[n*n-1];
    return(det);
}

int CMatrix::cinv(double a[],int n)
  {
	int *is,*js,i,j,k,l,u,v;
    double d,p;
    is=(int*)malloc(n*sizeof(int));
    js=(int*)malloc(n*sizeof(int));
    for (k=0; k<=n-1; k++)
      { d=0.0;
        for (i=k; i<=n-1; i++)
        for (j=k; j<=n-1; j++)
          { l=i*n+j; p=fabs(a[l]);
            if (p>d) { d=p; is[k]=i; js[k]=j;}
          }
        if (d+1.0==1.0)
          { free(is); free(js); printf("err**not inv\n");
            return(0);
          }
        if (is[k]!=k)
          for (j=0; j<=n-1; j++)
            { u=k*n+j; v=is[k]*n+j;
              p=a[u]; a[u]=a[v]; a[v]=p;
            }
        if (js[k]!=k)
          for (i=0; i<=n-1; i++)
            { u=i*n+k; v=i*n+js[k];
              p=a[u]; a[u]=a[v]; a[v]=p;
            }
        l=k*n+k;
        a[l]=1.0/a[l];
        for (j=0; j<=n-1; j++)
          if (j!=k)
            { u=k*n+j; a[u]=a[u]*a[l];}
        for (i=0; i<=n-1; i++)
          if (i!=k)
            for (j=0; j<=n-1; j++)
              if (j!=k)
                { u=i*n+j;
                  a[u]=a[u]-a[i*n+k]*a[k*n+j];
                }
        for (i=0; i<=n-1; i++)
          if (i!=k)
            { u=i*n+k; a[u]=-a[u]*a[l];}
      }
    for (k=n-1; k>=0; k--)
      { if (js[k]!=k)
          for (j=0; j<=n-1; j++)
            { u=k*n+j; v=js[k]*n+j;
              p=a[u]; a[u]=a[v]; a[v]=p;
            }
        if (is[k]!=k)
          for (i=0; i<=n-1; i++)
            { u=i*n+k; v=i*n+is[k];
              p=a[u]; a[u]=a[v]; a[v]=p;
            }
      }
    free(is); free(js);
    return(1);
}

//读写矩阵类：
int CMatrix::savematrix(char *fn)
{
	FILE *fp;
	unsigned i,j;
	fp=fopen(fn,"wt");
	if(fp==NULL)
	{
		printf("存储矩阵失败！");
		return 0;
	}
	fprintf(fp,"\r\n矩阵大小：\r\n");
	fprintf(fp,"%d行,  %d列\r\n",rows,cols);

	fprintf(fp,"\r\n矩阵各个元素为：\r\n");
	for(i=0;i<rows;i++)
	{
		for(j=0;j<cols;j++)
		{
			fprintf(fp,"%15.6f ",elems[i*cols+j]);
		}
		fprintf(fp,"\n");
	}
	fclose(fp);
	return 1;
}

/****************************************************************/
//					Overloading functions:						//
/****************************************************************/

//获取矩阵的某一项的值：
double CMatrix::operator() (unsigned row, unsigned col)
{
	return (row>=0&&row<=rows&&col>=0&&col<=cols)?
			 elems[row*cols+col]:0.0;
}

//两个矩阵相等：
CMatrix & CMatrix::operator = (const CMatrix & mtx)
{
	unsigned i;
	unsigned size;

	if(this==&mtx) return * this;
	delete [] elems;
	rows=mtx.rows;
	cols=mtx.cols;
	size=mtx.rows*mtx.cols;
	elems=new double[size];
	for(i=0;i<size;i++)
	{
		elems[i]=mtx.elems[i];
	}
	return * this;
}

/****************************************************************************/
//						Friend overloading functions:						//
/****************************************************************************/

//加法：
CMatrix operator + (CMatrix p,CMatrix q)
{
	unsigned r,c;
	double val;
	CMatrix m(p.rows,p.cols);
	if(p.rows!=q.rows||p.cols!=q.cols)
	{
		return m;
	}
	for(r=0;r<p.rows;r++)
	{
		for(c=0;c<p.cols;++c)
		{
			val=p(r,c)+q(r,c);
			m.setelem(r,c,val);
		}
	}
	return m;
}

//减法：
CMatrix operator - (CMatrix p,CMatrix q)
{
	unsigned r,c;
	CMatrix m(p.rows,p.cols);
	if(p.rows!=q.rows||p.cols!=q.cols)
	{
		return m;
	}

	for(r=0;r<p.rows;r++)
	{
		for(c=0;c<p.cols;c++)
		{
			m.setelem(r,c,p(r,c)-q(r,c));
		}
	}
	return m;
}

//乘法：
CMatrix operator * (CMatrix p,CMatrix q)
{
	unsigned r,c,i;
	double sum;
	CMatrix m(p.rows,q.cols);
	if(p.cols!=q.rows)
	{
		AfxMessageBox("乘法错误：p.cols!=q.rows");
		return m;
	}

	for(r=0;r<p.rows;r++)
	{
		for(c=0;c<q.cols;c++)
		{
			sum=0;
			for(i=0;i<p.cols;i++)
			{
				sum=sum+p(r,i)*q(i,c);
			}
		m.setelem(r,c,sum);
		}
	}

	return m;
}

//乘法：
CMatrix operator * (double p,CMatrix q)
{
	unsigned i,j,r,c;
	double t;
	r=q.rows;
	c=q.cols;
	for(i=0;i<r;i++)
	{
		for(j=0;j<c;j++)
		{
			t=p*q(i,j);
			q.setelem(i,j,t);
		}
	}
	return q;
}

//将p矩阵与q矩阵左右合并为一新的矩阵（i.e. P'={p,q}）：
CMatrix operator | (CMatrix p,CMatrix q)
{
	unsigned i,j,r,c,cp,cq;
	CMatrix pp;
	if(q.getrows()!=p.getrows())
	{
		AfxMessageBox("|运算错误：行数不同，无法合并两个矩阵！");
		return pp;
	}
	r =q.getrows();
	cp=p.getcols();
	cq=q.getcols();
	c =cp+cq;
	pp.setvalue(r,c);

	for(i=0;i<r;i++)
	{
		for(j=0;j<cp;j++)