C课程设计矩阵的加减乘混合运算.docx
《C课程设计矩阵的加减乘混合运算.docx》由会员分享,可在线阅读,更多相关《C课程设计矩阵的加减乘混合运算.docx(26页珍藏版)》请在冰豆网上搜索。
![C课程设计矩阵的加减乘混合运算.docx](https://file1.bdocx.com/fileroot1/2023-2/24/331753cd-9c7c-4d09-8b65-19c544851243/331753cd-9c7c-4d09-8b65-19c5448512431.gif)
C课程设计矩阵的加减乘混合运算
矩阵混合运算
指导教师:
浙江理工大学
班级:
学号:
姓名:
矩阵混合运算
一、程序要求
二、输入输出范例
三、程序结构分析及关键函数说明
四、程序代码与说明
五、运行结果与分析
六、设计日志及心得体会
一、
程序要求及范例
·定义矩阵(维数小于5×5)的加减法和乘法
·计算输入的若干矩阵的加减法运算和乘法混合运算
·矩阵数目不定,混合运算顺序不定,矩阵数值不定,均有键盘输入控制
·若输入有错,可以随时更改任一矩阵数值
·当输入矩阵不能满足矩阵运算时,提示矩阵维数错误
二、输入输出范例
·输入:
-首先输入每个矩阵的数值,输入矩阵格式如[111;222]
-输入几个矩阵的混合运算
·输出:
-输出计算结果
·输入范例:
A=[111;222]
B=[10;01;11]
C=[10;01]
D=C+A*B或者D=A*B+C
·输出
-D=
32
45
三、程序结构分析及关键函数说明
1.加运算函数
在进行矩阵相加前要判断两矩阵是否能够相加,如果能就按照矩阵的相加方式进行运算,若不能则提示错误并返回,具体的程序段如下:
intaddMatrix(Matrix*c,Matrix*a,Matrix*b)
{
inti,j;
if(a->rows!
=b->rows||a->cols!
=b->cols)//errortoadd
{
printf("矩阵维数输入错误!
");
return0;
}
else
{
c->rows=a->rows;
c->cols=a->cols;
for(i=0;irows;i++)
{
for(j=0;jcols;j++)
{
c->data[i][j]=a->data[i][j]+b->data[i][j];
}
}
return1;
}
}
2.减运算函数
在进行矩阵相减前要判断两矩阵是否能够相减,如果能就按照矩阵的相减方式进行运算,若不能则提示错误并返回,具体的程序段如下:
intsubtractMatrix(Matrix*c,Matrix*a,Matrix*b)
{
inti,j;
if(a->rows!
=b->rows||a->cols!
=b->cols)//error
{
printf("矩阵维数输入错误!
");
return0;
}
else
{
c->rows=a->rows;
c->cols=a->cols;
for(i=0;irows;i++)
{
for(j=0;jcols;j++)
{
c->data[i][j]=a->data[i][j]-b->data[i][j];
}
}
return1;
}
}
3.乘运算函数
该程序设计的核心问题是矩阵的乘法运算的逻辑性的编写,在进行矩阵相乘前要判断两矩阵是否能够相乘,即判断内积是否相等,如果能就按照矩阵的相乘方式进行运算,若不能则提示错误并返回,具体的程序段如下:
intmultiplyMatrix(Matrix*c,Matrix*a,Matrix*b)
{
inti,j,k;
if(a->cols!
=b->rows)
{
printf("矩阵维数输入错误!
");
return0;
}
else
{
c->rows=a->rows;
c->cols=b->cols;
for(i=0;irows;i++)
{
for(j=0;jcols;j++)
{
c->data[i][j]=0;
for(k=0;kcols;k++)
{
c->data[i][j]+=a->data[i][k]*b->data[k][j];
}
}
}
return1;
}
}
四、程序代码与说明
#include
#include
#include
#include
#defineMAX_DIM6
#defineMAX_CHAR128
typedefstruct//结构体定义矩阵
{
floatdata[MAX_DIM][MAX_DIM];//二维数组表示矩阵
introws;//行
intcols;//列
}Matrix;
typedefstruct_ListNode//定义一个头结点
{
charname[MAX_CHAR];
Matrix*mat;
struct_ListNode*next;//指向下一个结点
}ListNode;
typedefstruct
{
ListNode*head;//定义一个指向头结点的指针
}MList;
enumTYPE{OP,MAT};//枚举类型
typedefstruct_Token//定义Token标识符判断表达式
{
union//联合体取值为op和mat中结构最大的值
{
charop;
Matrix*mat;
};
enumTYPEtype;//联合体的类型
}Token;
typedefstruct_Stack//定义栈
{
Token**arr;//用数组存储标识符
intn;//数组里标识符的个数
intcap;//数组的大小
}Stack;
Stack*initStack(intcap);//初始化,定义一个空栈
voidfreeStack(Stack*pStack);//释放栈的空间
voidreszieStack(Stack*pStack,intnewCap);//重定义栈的大小
voidpush(Stack*pStack,Token*pToken);//入栈操作
Token*pop(Stack*pStack);//出栈
Token*top(Stack*pStack);//栈顶
intgetIndex(charch);//不同标识符对应不同的操作
charpriorMap[9][9]=
{
{'>','>','<','<','<','<','<','>','>'},
{'>','>','<','<','<','<','<','>','>'},
{'>','>','>','>','<','<','<','>','>'},
{'>','>','>','>','<','<','<','>','>'},
{'>','>','>','>','>','>','<','>','>'},
{'>','>','>','>','>','>','<','>','>'},
{'<','<','<','<','<','<','<','=','$'},
{'>','>','>','>','>','>','&','>','>'},
{'<','<','<','<','<','<','<','&','='}
};
Matrix*newMatrix(introws,intcols);//函数原型,创建新矩阵
voidfreeMatrix(Matrix*mat);//销毁矩阵,释放内存
intaddMatrix(Matrix*c,Matrix*a,Matrix*b);//矩阵的加法
intsubtractMatrix(Matrix*c,Matrix*a,Matrix*b);//矩阵的减法
intmultiplyMatrix(Matrix*c,Matrix*a,Matrix*b);//矩阵的乘法
voidprintMatrix(Matrix*mat);//输出结果
ListNode*newNode(charname[],Matrix*mat);
MList*newMList();
voidfreeNode(ListNode*node);
voidfreeMList(MList*ml);
voidaddNode(MList*ml,ListNode*node);
ListNode*parseMat(charline[]);
voidprintLNode(ListNode*node);
Matrix*findByName(MList*ml,charname[]);
intmain()
{
printf("矩阵的混合运算\n");
printf("矩阵范例A=[111;222]\n");
printf("请按范例格式输入\n");
charline[MAX_CHAR];
charname[MAX_CHAR];
char*pch;
MList*ml=newMList();
Matrix*newMat=NULL;
while
(1)
{
fgets(line,MAX_CHAR,stdin);//输入一串字符
if(strlen(line)==1&&line[0]=='\n')
{
continue;
}
pch=strchr(line,'[');
if(pch!
=NULL)
{
ListNode*node=parseMat(line);
addNode(ml,node);
}
else
{
pch=strchr(line,'=');
*pch='\0';
char*expr=pch+1;
Stack*pStackVals=initStack(16);
Stack*pStackOps=initStack(16);
Token*pToken=NULL,*pTokenA=NULL,*pTokenB=NULL;
pToken=(Token*)malloc(sizeof(Token));
pToken->op='#';
pToken->type=OP;
push(pStackOps,pToken);
intlen=strlen(expr);
expr[len++]='#';
intb=0,e=0,cnt;
charch;
while(b!
=len)
{
ch=expr[b];
if(isspace(ch))//判断是否为空格
{
b++;
}
elseif(isalpha(ch))//矩阵
{
cnt=0;
e=b;
while(isalpha(expr[e]))
{
name[cnt++]=expr[e++];
}
name[cnt]='\0';
b=e;
Matrix*mat=findByName(ml,name);
pToken=(Token*)malloc(sizeof(Token));
pToken->type=MAT;
pToken->mat=mat;
push(pStackVals,pToken);
}
else//操作符
{
while
(1)
{
charcmp=priorMap[getIndex(top(pStackOps)->op)][getIndex(ch)];
if(cmp=='<')
{
pToken=(Token*)malloc(sizeof(Token));
pToken->type=OP;
pToken->op=ch;
push(pStackOps,pToken);
break;
}
elseif(cmp=='=')
{
free(pop(pStackOps));
break;
}
elseif(cmp=='>')
{
pToken=pop(pStackOps);
switch(pToken->op)
{
case'+':
pTokenB=pop(pStackVals);
pTokenA=pop(pStackVals);
newMat=newMatrix(0,0);
addMatrix(newMat,pTokenA->mat,pTokenB->mat);
free(pTokenA);
free(pTokenB);
pToken=(Token*)malloc(sizeof(Token));
pToken->type=MAT;
pToken->mat=newMat;
push(pStackVals,pToken);
break;
case'-':
pTokenB=pop(pStackVals);
pTokenA=pop(pStackVals);
newMat=newMatrix(0,0);
subtractMatrix(newMat,pTokenA->mat,pTokenB->mat);
free(pTokenA);
free(pTokenB);
pToken=(Token*)malloc(sizeof(Token));
pToken->type=MAT;
pToken->mat=newMat;
push(pStackVals,pToken);
break;
case'*':
pTokenB=pop(pStackVals);
pTokenA=pop(pStackVals);
newMat=newMatrix(0,0);
multiplyMatrix(newMat,pTokenA->mat,pTokenB->mat);
free(pTokenA);
free(pTokenB);
pToken=(Token*)malloc(sizeof(Token));
pToken->type=MAT;
pToken->mat=newMat;
push(pStackVals,pToken);
break;
}
}
}
b++;
}
}
newMat=top(pStackVals)->mat;
freeStack(pStackVals);
freeStack(pStackOps);
break;
}
}
ListNode*resNode=newNode(line,newMat);
printLNode(resNode);
freeMList(ml);
return0;
}
Matrix*newMatrix(introws,intcols)
{
Matrix*mat=(Matrix*)malloc(sizeof(Matrix));
mat->rows=rows;
mat->cols=cols;
returnmat;
}
voidfreeMatrix(Matrix*mat)
{
free(mat);
mat=NULL;
}
intaddMatrix(Matrix*c,Matrix*a,Matrix*b)
{
inti,j;
if(a->rows!
=b->rows||a->cols!
=b->cols)//errortoadd
{
printf("矩阵维数输入错误!
");
return0;
}
else
{
c->rows=a->rows;
c->cols=a->cols;
for(i=0;irows;i++)
{
for(j=0;jcols;j++)
{
c->data[i][j]=a->data[i][j]+b->data[i][j];
}
}
return1;
}
}
intsubtractMatrix(Matrix*c,Matrix*a,Matrix*b)
{
inti,j;
if(a->rows!
=b->rows||a->cols!
=b->cols)//errortoadd
{
printf("矩阵维数输入错误!
");
return0;
}
else
{
c->rows=a->rows;
c->cols=a->cols;
for(i=0;irows;i++)
{
for(j=0;jcols;j++)
{
c->data[i][j]=a->data[i][j]-b->data[i][j];
}
}
return1;
}
}
intmultiplyMatrix(Matrix*c,Matrix*a,Matrix*b)
{
inti,j,k;
if(a->cols!
=b->rows)
{
return0;
}
else
{
c->rows=a->rows;
c->cols=b->cols;
for(i=0;irows;i++)
{
for(j=0;jcols;j++)
{
c->data[i][j]=0;
for(k=0;kcols;k++)
{
c->data[i][j]+=a->data[i][k]*b->data[k][j];
}
}
}
return1;
}
}
voidprintMatrix(Matrix*mat)
{
inti,j;
for(i=0;irows;i++)
{
for(j=0;jcols;j++)
{
printf("\t%.2f",mat->data[i][j]);
}
printf("\n");
}
}
voidprintLNode(ListNode*node)
{
printf("%s=\n",node->name);
printMatrix(node->mat);
}
ListNode*newNode(charname[],Matrix*mat)
{
ListNode*node=(ListNode*)malloc(sizeof(ListNode));
strcpy(node->name,name);
node->mat=mat;
node->next=NULL;
returnnode;
}
MList*newMList()
{
MList*ml=(MList*)malloc(sizeof(MList));
ml->head=NULL;
returnml;
}
voidfreeNode(ListNode*node)
{
if(node==NULL)
{
return;
}
freeMatrix(node->mat);
free(node);
}
voidfreeMList(MList*ml)
{
if(ml==NULL)
{
return;
}
ListNode*currNode,*temp;
currNode=ml->head;
while(currNode!
=NULL)
{
temp=currNode;
freeNode(temp);
currNode=currNode->next;
}
free(ml);
}
voidaddNode(MList*ml,ListNode*node)
{
node->next=ml->head;
ml->head=node;
}
ListNode*parseMat(charline[])
{
chartmp[MAX_CHAR];
Matrix*mat=newMatrix(0,0);
char*pch,*pch1,*pstop;
pch=strchr(line,'=');
*pch='\0';
ListNode*node=newNode(line,mat);
char*data=pch+2;
pstop=strchr(data,']');
*pstop='\0';
pch=strtok(data,";");
while(pch!
=NULL)
{
strcpy(tmp,pch);
pch1=strtok(tmp,"");
mat->cols=0;
while(pch1!
=NULL)
{
mat->data[mat->rows][mat->cols++]=atof(pch1);
pch1=strtok(NULL,"");
}
mat->rows++;
if(pch+strlen(pch)==pstop)
{
break;
}
pch=strtok(pch+strlen(pch)+1,";");
}
returnnode;
}
Matrix*findByName(MList*ml,charname[])
{
ListNode*currNode=ml->head;
while(currNode!
=NULL)
{
if(strcmp(name,currNode->name)==0)
{
returncurrNode->mat;
}
currNode=currNode->next;
}
returnNULL;
}
Stack*initStack(intcap)
{
inti;
Stack*pSta