matrix.cpp

用c++的一个矩阵类

// 参数：无
//
// 返回值：CMatrix型，指定矩阵转置矩阵
//////////////////////////////////////////////////////////////////////
CMatrix CMatrix::Transpose() const
{
 // 构造目标矩阵
 CMatrix 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;
}
///////////////////////////////////////////////////////////
////求逆
inline void swap(double &a,double &b){double c=a;a=b;b=c;};
CMatrix CMatrix::DinV()
{
	 CMatrix result(m_nNumColumns, m_nNumRows);
 int i,j,k;
 double d , value;
 double c[10][10]={0};
 int JS[10],IS[10];
 if(result.GetNumRows()!=result.GetNumColumns())
 {cout<<"不能求逆"<<endl;
   return 0;}

 for(i=0;i<result.GetNumRows();i++)
	for(j=0;j<result.GetNumRows();j++)
	{
		c[i][j]= GetElement(i, j);
	}
 for (k=0;k<result.GetNumRows();k++)
 {
  d=0;
  for (i=k;i<result.GetNumRows();i++)
   for (j=k;j<result.GetNumRows();j++)
  {
   if (fabs(c[i][j])>d)
   {
    d=fabs(c[i][j]);
    IS[k]=i;
    JS[k]=j;
   }
  }
   if (d+1.0==1.0) {cout<<"不能求逆"<<endl;
   return 0;}
  if (IS[k]!=k)
   for (j=0;j<result.GetNumRows();j++)
    swap(c[k][j],c[IS[k]][j]);
  if (JS[k]!=k)
   for (i=0;i<result.GetNumRows();i++)
    swap(c[i][k],c[i][JS[k]]);
  c[k][k]=1/c[k][k];
  for (j=0;j<result.GetNumRows();j++)
   if (j!=k) c[k][j]=c[k][j]*c[k][k];
  for (i=0;i<result.GetNumRows();i++)
   if (i!=k)
    for (j=0;j<result.GetNumRows();j++)
     if (j!=k) c[i][j]=c[i][j]-c[i][k]*c[k][j];
  for (i=0;i<result.GetNumRows();i++)
   if (i!=k) c[i][k]=-c[i][k]*c[k][k];
 }
 for (k=result.GetNumRows()-1;k>=0;k--)
 {
  for (j=0;j<result.GetNumRows();j++)
   if (JS[k]!=k) swap(c[k][j],c[JS[k]][j]);
  for (i=0;i<result.GetNumRows();i++)
   if (IS[k]!=k) swap(c[i][k],c[i][IS[k]]);
 }
 
 for(i=0;i<result.GetNumRows();i++)
		  for(j=0;j<result.GetNumRows();j++)
		  {
			  value=c[i][j];
			   result.SetElement(i, j, value) ;
		  }

		  return result;
}




/////////////////////////////////////////////////////////////////////



                                               
//////////////////////////////////////////////////////////////////////
// 求行列式值的全选主元高斯消去法
//
// 参数：无
//
// 返回值：double型，行列式的值
//////////////////////////////////////////////////////////////////////
double CMatrix::Det()
{ 
 int i,j,k,is,js,l,u,v;
    double f,det,q,d;
   double a[100] ;
	//   assert (m_nNumColumns,m_nNumRows);
   if(m_nNumColumns!=m_nNumRows)
   {
	   cout<<"不能求行列式的值"<<endl;
	   return NULL;
   }
   for(int m=0;m<m_nNumColumns*m_nNumRows;m++)
   {
	   a[m]=m_pData[m];
   }
 // 初值
 f=1.0; 
 det=1.0;
    
 // 消元
 for (k=0; k<=m_nNumColumns-2; k++)
    { 
  q=0.0;
        for (i=k; i<=m_nNumColumns-1; i++)
  {
   for (j=k; j<=m_nNumColumns-1; j++)
   { 
    l=i*m_nNumColumns+j; 
    d=fabs(a[l]);
    if (d>q) 
    { 
     q=d; 
     is=i; 
     js=j;
    }
   }
  }
        if (q == 0.0)
        { 
   det=0.0; 
   return(det);
  }
        
  if (is!=k)
        { 
   f=-f;
            for (j=k; j<=m_nNumColumns-1; j++)
            { 
    u=k*m_nNumColumns+j; 
    v=is*m_nNumColumns+j;
                d=a[u]; 
    a[u]=a[v]; 
    a[v]=d;
            }
        }
        
  if (js!=k)
        { 
   f=-f;
            for (i=k; i<=m_nNumColumns-1; i++)
            {
    u=i*m_nNumColumns+js; 
    v=i*m_nNumColumns+k;
                d=a[u]; 
    a[u]=a[v]; 
    a[v]=d;
            }
        }
        l=k*m_nNumColumns+k;
        det=det*a[l];
        for (i=k+1; i<=m_nNumColumns-1; i++)
        { 
   d=a[i*m_nNumColumns+k]/a[l];
            for (j=k+1; j<=m_nNumColumns-1; j++)
            { 
    u=i*m_nNumColumns+j;
                a[u]=a[u]-d*a[k*m_nNumColumns+j];
            }
        }
    }
    
 // 求值
 det=f*det*a[m_nNumColumns*m_nNumColumns-1];
 	cout<<"行列式的值是"<<det<<endl;
    return(det);
}



//////////////////////////////////////////////////////////////////////
// 求矩阵秩的高斯消去法
//
// 参数：无
//
// 返回值：int型，矩阵的秩
//////////////////////////////////////////////////////////////////////
int CMatrix::Rank()
{ 
 int i,j,k,nn,is,js,l,ll,u,v;
    double q,d;
    double a[100];
	for(int m=0;m<m_nNumColumns*m_nNumRows;m++)
   {
	   a[m]=m_pData[m];
   }

 // 秩小于等于行列数
 nn = m_nNumRows;
    if (m_nNumRows >= m_nNumColumns) 
  nn = m_nNumColumns;
    k=0;
 // 消元求解
    for (l=0; l<=nn-1; l++)
    { 
  q=0.0;
        for (i=l; i<=m_nNumRows-1; i++)
  {
   for (j=l; j<=m_nNumColumns-1; j++)
   { 
    ll=i*m_nNumColumns+j; 
    d=fabs(a[ll]);
    if (d>q) 
    { 
     q=d; 
     is=i; 
     js=j;
    }
   }
  }
        if (q == 0.0) 
   return(k);
        k=k+1;
        if (is!=l)
        { 
   for (j=l; j<=m_nNumColumns-1; j++)
            { 
    u=l*m_nNumColumns+j; 
    v=is*m_nNumColumns+j;
                d=a[u]; 
    a[u]=a[v]; 
   a[v]=d;
            }
        }
        if (js!=l)
        { 
   for (i=l; i<=m_nNumRows-1; i++)
            { 
    u=i*m_nNumColumns+js; 
    v=i*m_nNumColumns+l;
                d=a[u]; 
    a[u]=a[v]; 
   a[v]=d;
            }
        }
        
  ll=l*m_nNumColumns+l;
        for (i=l+1; i<=m_nNumColumns-1; i++)
        { 
   d=a[i*m_nNumColumns+l]/a[ll];
            for (j=l+1; j<=m_nNumColumns-1; j++)
            { 
    u=i*m_nNumColumns+j;
                a[u]=a[u]-d*a[l*m_nNumColumns+j];
            }
        }
    }
    
 return(k);
}

void CMatrix ::Print()
{
	 for(int c=0;c<m_nNumRows ;c++)  //获取源矩阵数据
	{
		for(int b=0;b<m_nNumColumns;b++)
		{
			printf("%.4lf  ",m_pData[m_nNumColumns*c+b]); 
		}

		printf("\n");
	}
}



//////////////////////////////////////////////////////////////
//  一个测试函数main()
//////////////////////////////////////////////////////////////
void main()  
{
	cout<<"                            欢迎使用矩阵计算软件："<<endl;
	cout<<"                     制作者 ：梁爽,叶茜,褚盈,赵龙舫"<<endl;
	cout<<endl;
	
	int col,row,all,co,ro;
	cout<<"请输入矩阵1的行数"<<endl;
	cin>>row;
	cout<<"请输入矩阵1的行数"<<endl;
	cin>>col;
	all=row*col;
	double a[100],b[100];
	cout<<"请输入矩阵1的元素"<<endl;
	for(ro=0;ro<row;ro++)
	{for(co=0;co<col;co++)
		{
			cout<<"请输入"<<'a'<<'['<<ro+1<<']'<<'['<<co+1<<']'<<endl;
            cin>>a[ro*col+co];
	}
	}
	

	CMatrix m1(row,col,a);
	cout<<"请输入矩阵2的行数"<<endl;
	cin>>row;
	cout<<"请输入矩阵2的行数"<<endl;
	cin>>col;
	all=row*col;
	cout<<"请输入矩阵2的元素"<<endl;
	for(ro=0;ro<row;ro++)
	{for(co=0;co<col;co++)
		{
			cout<<"请输入"<<'a'<<'['<<ro+1<<']'<<'['<<co+1<<']'<<endl;
            cin>>b[ro*col+co];
	}
	}
	CMatrix m2(row,col,b);
   
	
	cout<<"你输入的矩阵如下"<<endl;
	
	cout<<"矩阵1"<<endl;   
	m1.Print();
	cout<<"矩阵2"<<endl;   
	m2.Print();

//	double e[3]={1,2,3};

		  
	char choose ;
	//cin>>choose;
	cout<<"请选择分析模式  1 求1的逆矩阵  2 求1的行列式的值  3 求1矩阵的秩  4 计算两者之和"<<endl;
	cout<<"5 计算两者之积  6计算两者之差"<<endl;
	while((choose=getchar())!='d'){
	switch (choose)
 {
	case '1': {
		CMatrix m3=m1.DinV();
		m3.Print();
			  }
		cout<<"请选择分析模式  1 求逆矩阵  2 求行列式的值  3 求1矩阵的秩  4 计算两者之和"<<endl;
			cout<<"5 计算两者之积  6计算两者之差"<<endl; break;
	case '2': {
		double det=m1.Det();
	
	
			  }cout<<"请选择分析模式  1 求逆矩阵  2 求行列式的值  3 求1矩阵的秩  4 计算两者之和"<<endl;
			cout<<"5 计算两者之积  6计算两者之差"<<endl; break;
	case '3': {
 		double rank=m1.Rank();
		cout<<"矩阵的秩是"<<rank<<endl;
	
			  }cout<<"请选择分析模式  1 求逆矩阵  2 求行列式的值  3 求1矩阵的秩  4 计算两者之和"<<endl;
			cout<<"5 计算两者之积  6计算两者之差"<<endl; break;
	case '4':{
		CMatrix m4=m1+m2;
		cout<<"和矩阵为"<<endl;
		m4.Print();
			 }cout<<"请选择分析模式  1 求逆矩阵  2 求行列式的值  3 求1矩阵的秩  4 计算两者之和"<<endl;
			cout<<"5 计算两者之积  6计算两者之差"<<endl; break;
	case '5':{
		CMatrix m5=m1*m2;
		cout<<"积矩阵为"<<endl;
		m5.Print();
			 }cout<<"请选择分析模式  1 求逆矩阵  2 求行列式的值  3 求1矩阵的秩  4 计算两者之和"<<endl;
			cout<<"5 计算两者之积  6计算两者之差"<<endl; break;
	case '6':{
		CMatrix m6=m1-m2;
		cout<<"差矩阵为"<<endl;
		m6.Print();
			 }cout<<"请选择分析模式  1 求逆矩阵  2 求行列式的值  3 求1矩阵的秩  4 计算两者之和"<<endl;
			cout<<"5 计算两者之积  6计算两者之差"<<endl; break;

	case '7': {
		cout<<"感谢您的使用^_^"<<endl;
		exit(0);} break;
	}
	}



	
}