矩阵运算

 

//==============================================================================

//

// 05软件 jacklam

// 矩阵运算

// matrix.cpp

//==============================================================================

#include "iostream.h"

#include "stdlib.h"

#define maxsize 12500

//--------------------三元组行逻辑存储结构--------------------------------------

typedef struct

{

int i,j;

int e;

}triple;

typedef struct

{

triple data[maxsize];

int mu,nu,tu;

int rpos[maxsize];

}rlsmatrix;

//--------------------三元组行逻辑计算------------------------------------------

rls(rlsmatrix &m)

{

int num[maxsize];

for(int k=1;k<=m.tu;++k)          //计算行非0值个数；

  num[k]=0;

for(k=1;k<=m.mu;++k)

  ++num[m.data[k].i];

m.rpos[1]=1;            //计算行逻辑；

for(k=2;k<=m.mu;k++)

  m.rpos[k]=m.rpos[k-1]+num[k-1];

return 1;

}//-----------------------------------------------------------------------------

//--------------------三元组行逻辑创建------------------------------------------

creatematrix(rlsmatrix &m)

{

cout<<"please input the row and col:";

cin>>m.mu>>m.nu;

cout<<"please input the none zero number:";

cin>>m.tu;

cout<<"please input the value of matrix:eg(1 2 3)"<<endl;

for(int k=1;k<=m.tu;++k)

cin>>m.data[k].i>>m.data[k].j>>m.data[k].e;

rls(m);

return 1;

}//-----------------------------------------------------------------------------

//-------------------三元组行逻辑输出-------------------------------------------

print(rlsmatrix m)

{

cout<<"the matrix value:"<<endl;

for(int k=1;k<=m.tu;++k)         //输出三元组；

  cout<<m.data[k].i<<"   "<<m.data[k].j<<"   "<<m.data[k].e<<endl;

/*cout<<"this is its rls:"<<endl;

for(k=1;k<=m.mu;++k)          //输出行逻辑；

  cout<<m.rpos[k]<<"  ";

cout<<endl;*/

return 1;

}//-----------------------------------------------------------------------------

//-------------------矩阵相加---------------------------------------------------

add(rlsmatrix m,rlsmatrix t,rlsmatrix &l)

{

int p=1,q=1,k=1;

if(m.mu!=t.mu||m.nu!=t.nu)      //行不相等，列不相等

{

  cout<<"can"t add!"<<endl;     //不能进行相加

  return 0;

}

else

{

  l.mu=m.mu;

  l.nu=t.nu;

  l.tu=0;

  while(p<=m.tu&&q<=t.tu)

  {

  

   if(m.data[p].i<t.data[q].i || m.data[p].i==t.data[q].i&&m.data[p].j<t.data[q].j)

   {

    l.data[k].i=m.data[p].i;

    l.data[k].j=m.data[p].j;

    l.data[k].e=m.data[p].e;

    k++;p++;

   }

   else if((m.data[p].i==t.data[q].i)&&(m.data[p].j==t.data[q].j))

   {

    l.data[k].i=m.data[p].i;

    l.data[k].j=m.data[p].j;

    l.data[k].e=m.data[p].e+t.data[q].e;

    ++p;++q;++k;

   }

   else

   {

    l.data[k].i=t.data[q].i;

    l.data[k].j=t.data[q].j;

    l.data[k].e=t.data[q].e;

    k++;q++;

   }

  }

   while(p<=m.tu)

   {

    l.data[k].i=m.data[p].i;

    l.data[k].j=m.data[p].j;

    l.data[k].e=m.data[p].e;

    ++k;++p;

   }

   while(q<=t.tu)

   {

    l.data[k].i=t.data[q].i;

    l.data[k].j=t.data[q].j;

    l.data[k].e=t.data[q].e;

    ++k;++q;

   }

}

    l.tu=k-1;

//rls(l);

return 1;

}//-----------------------------------------------------------------------------

//-------------------矩阵相减---------------------------------------------------

sub(rlsmatrix m,rlsmatrix t,rlsmatrix &l)

{

int p=1,q=1,k=1;

if(m.mu!=t.mu||m.nu!=t.nu)      //行不相等，列不相等

{

  cout<<"can"t sub!"<<endl;     //不能进行相减

  return 0;

}

else

{

  l.mu=m.mu;

  l.nu=t.nu;

  l.tu=0;

  while(p<=m.tu&&q<=t.tu)

  {

  

   if(m.data[p].i<t.data[q].i || m.data[p].i==t.data[q].i&&m.data[p].j<t.data[q].j)

   {

    l.data[k].i=m.data[p].i;

    l.data[k].j=m.data[p].j;

    l.data[k].e=m.data[p].e;

    k++;p++;

   }

   else if((m.data[p].i==t.data[q].i)&&(m.data[p].j==t.data[q].j))

   {

    l.data[k].i=m.data[p].i;

    l.data[k].j=m.data[p].j;

    l.data[k].e=m.data[p].e-t.data[q].e;

    ++p;++q;++k;

   }

   else

   {

    l.data[k].i=t.data[q].i;

    l.data[k].j=t.data[q].j;

    l.data[k].e=-t.data[q].e;

    k++;q++;

   }

  }

   while(p<=m.tu)

   {

    l.data[k].i=m.data[p].i;

    l.data[k].j=m.data[p].j;

    l.data[k].e=m.data[p].e;

    ++k;++p;

   }

   while(q<=t.tu)

   {

    l.data[k].i=t.data[q].i;

    l.data[k].j=t.data[q].j;

    l.data[k].e=-t.data[q].e;

    ++k;++q;

   }

}

    l.tu=k-1;

//rls(l);

return 1;

}//-----------------------------------------------------------------------------

//-------------------矩阵相乘---------------------------------------------------

multsmatrix(rlsmatrix matrix,rlsmatrix t,rlsmatrix &m)

{

int ctemp[maxsize];

int arow,tp,ccol,brow,tq;

if(t.mu!=matrix.nu)

{

  cout<<"can"t mulitify!"<<endl;

  return 0;

}

m.mu=matrix.mu;m.nu=t.nu;m.tu=0;

if(matrix.tu*t.tu!=0)

{

  for(arow=1;arow<=matrix.mu;++arow)

  {

   for(int i=0;i<maxsize;++i)

    ctemp[i]=0;

   m.rpos[arow]=m.tu+1;

   if(arow<matrix.mu)

    tp=matrix.rpos[arow+1];

   else

    tp=matrix.tu+1;

   for(int p=matrix.rpos[arow];p<tp;++p)

   {

    brow=matrix.data[p].j;

    if(brow<t.mu)

     tq=t.rpos[brow+1];

    else

     tq=t.tu+1;

    for(int q=t.rpos[brow];q<tq;++q)

    {

     ccol=t.data[p].j;

     ctemp[ccol]+=matrix.data[p].e*t.data[q].e;

    }

   }

   for(ccol=1;ccol<=m.nu;++ccol)

    if(ctemp[ccol])

    {

     if(++m.tu>maxsize)

      return 0;

     m.data[m.tu].i=arow;

     m.data[m.tu].j=ccol;

     m.data[m.tu].e=ctemp[ccol];

    }

  }

}

return 1;

}

//--------------------------------主函数----------------------------------------

main()

{

rlsmatrix m,t,l;

creatematrix(m);

print(m);

creatematrix(t);

print(t);

add(m,t,l);

cout<<"this is add result:"<<endl;

print(l);

sub(m,t,l);

cout<<"this is sub result:"<<endl;

print(l);

multsmatrix(m,t,l);

cout<<"this is mutiply result:"<<endl;

print(l);

return 1;

}//=============================================================================