汇编语言矩阵相乘课程设计(附源代码)
汇编矩阵相乘
.dataPrintf1: .asciiz "\n"Printf2: .asciiz " * "Printf3: .asciiz " = "Prompt1: .asciiz "First Matrix col: "Prompt2: .asciiz "First Matrix row and Second Matrix col: "Prompt3: .asciiz "Second Matrix row: "Prompt4: .asciiz "First Matrix : "Prompt5: .asciiz "Second Matrix : "PrintfFormat: .asciiz "%g ".align 2PrintfPar: .word PrintfFormatPrintfValue: .space 4data1: .space 1024data3: .space 1024data2: .space 1024;.text.global mainmain:addi r1,r0,Prompt1jal InputUnsignedaddu r17,r1,r0addi r1,r0,Prompt2jal InputUnsignedaddu r11,r1,r0addi r1,r0,Prompt3jal InputUnsignedaddu r12,r1,r0addi r8,r0,0addi r7,r0,0addi r3,r0,data1 ;取矩阵A当前元素在内存区域中的地址Matrix1:subu r5,r7,r17beqz r5,End1addi r6,r0,0beqz r7,Matrix01addi r3,r3,64addi r8,r0,0Matrix01:subu r5,r6,r11beqz r5,Matrix001addi r1,r0,Prompt4jal InputUnsignedaddu r9,r1,r0addu r2,r8,r3sw 0(r2),r9 ;store data3，把新计算出来的元素放入当前内存单元addi r8,r8,4addi r6,r6,1j Matrix01Matrix001:addi r7,r7,1j Matrix1End1:addi r3,r0,data2 ;取矩阵B当前元素在内存区域中的地址addi r7,r0,0addi r8,r0,0Matrix2:subu r5,r7,r11beqz r5,End2addi r6,r0,0beqz r7,Matrix02addi r3,r3,64addi r8,r0,0Matrix02:subu r5,r6,r12beqz r5,Matrix002addi r1,r0,Prompt5jal InputUnsignedaddu r9,r1,r0addu r2,r8,r3sw 0(r2),r9 ;store data3，把新计算出来的元素放入当前内存单元addi r8,r8,4addi r6,r6,1j Matrix02Matrix002:addi r7,r7,1j Matrix2End2:addi r9,r0,0addi r2,r0,data1 ;取矩阵A当前元素在内存区域中的地址addi r8,r0,data3 ;r1表示矩阵C当前的地址addi r10,r8,0Loop1:subu r5,r9,r17beqz r5,Printfaddi r6,r0,0addi r3,r0,data2 ;取矩阵B当前元素在内存区域中的地址beqz r9,Loop2addi r2,r2,64addi r8,r8,64addi r10,r8,0Loop2:subu r5,r6,r11beqz r5,ALaddi r1,r2,0addi r4,r3,0addi r7,r0,0beqz r6,Loop3addi r3,r3,4addi r4,r3,0j Loop3AL: addi r9,r9,1j Loop1Loop3:subu r5,r7,r12beqz r5,BLlw r15,0(r4)lw r13,0(r1)multu r14,r13,r15addu r16,r16,r14addi r7,r7,1addi r4,r4,64addi r1,r1,4j Loop3BL:sw 0(r10),r16 ;store data3，把新计算出来的元素放入当前内存单元addi r10,r10,4 ;赋值完一个元素，偏移量自增1addi r16,r0,0addi r6,r6,1j Loop2Printf: addi r8,r0,0addi r7,r0,0addi r3,r0,data1 ;取矩阵A当前元素在内存区域中的地址PrintfMatrix1:subu r5,r7,r17beqz r5,PrintfEnd1addi r6,r0,0beqz r7,PrintfMatrix01addi r3,r3,64addi r8,r0,0PrintfMatrix01:subu r5,r6,r11beqz r5,PrintfMatrix001addu r2,r8,r3lf f10,0(r2) ;R1 -> D0 D0..Count registercvti2d f0,f10sd PrintfValue,f0 ;打印addi r14,r0,PrintfPartrap 5addi r8,r8,4addi r6,r6,1j PrintfMatrix01PrintfMatrix001:addi r7,r7,1addi r1,r0,Printf1sw PrintfValue,r1addi r14,r0,PrintfValuetrap 5j PrintfMatrix1PrintfEnd1:addi r3,r0,data2 ;取矩阵B当前元素在内存区域中的地址addi r7,r0,0addi r8,r0,0addi r1,r0,Printf2sw PrintfValue,r1addi r14,r0,PrintfValuetrap 5addi r1,r0,Printf1sw PrintfValue,r1addi r14,r0,PrintfValuetrap 5PrintfMatrix2:subu r5,r7,r11beqz r5,PrintfEnd2addi r6,r0,0beqz r7,PrintfMatrix02addi r3,r3,64addi r8,r0,0PrintfMatrix02:subu r5,r6,r12beqz r5,PrintfMatrix002addu r2,r8,r3lf f10,0(r2) ;R1 -> D0 D0..Count registercvti2d f0,f10sd PrintfValue,f0 ;打印addi r14,r0,PrintfPartrap 5addi r8,r8,4addi r6,r6,1j PrintfMatrix02PrintfMatrix002:addi r7,r7,1addi r1,r0,Printf1sw PrintfValue,r1addi r14,r0,PrintfValuetrap 5j PrintfMatrix2PrintfEnd2:addi r1,r0,Printf3sw PrintfValue,r1addi r14,r0,PrintfValuetrap 5addi r1,r0,Printf1sw PrintfValue,r1addi r14,r0,PrintfValuetrap 5addi r3,r0,data3 ;取矩阵B当前元素在内存区域中的地址addi r7,r0,0addi r8,r0,0PrintfMatrix3:subu r5,r7,r17beqz r5,PrintfEnd3addi r6,r0,0beqz r7,PrintfMatrix03addi r3,r3,64addi r8,r0,0PrintfMatrix03:subu r5,r6,r12beqz r5,PrintfMatrix003addu r2,r8,r3lf f10,0(r2) ;R1 -> D0 D0..Count register cvti2d f0,f10sd PrintfValue,f0 ;打印addi r14,r0,PrintfPartrap 5addi r8,r8,4addi r6,r6,1j PrintfMatrix03PrintfMatrix003:addi r7,r7,1addi r1,r0,Printf1sw PrintfValue,r1addi r14,r0,PrintfValuetrap 5j PrintfMatrix3PrintfEnd3:Finish:trap 0。
两个矩阵相乘的源程序
两个矩阵相乘的源程序方案一：/*****************A=B*C******************/ #include<stdio.h>#include<conio.h>#define X 3#define Y 3int a[X][Y];int b[X][Y];int c[X][Y];void matrix(int b[][X],int c[][Y]);main(){int i,j,temp;clrscr();printf("Please input int matrix b[%d][%d]\n",X,Y); for(i=0;i<Y;i++)for(j=0;j<Y;j++){scanf("%d",&temp);b[j]=temp;}printf("Please input int matrix c[%d][%d]\n",X,Y); for(i=0;i<X;i++)for(j=0;j<Y;j++){scanf("%d",&temp);c[j]=temp;}matrix(b,c);printf("Now print resource matrix b[%d][%d]=",X,Y); for(i=0;i<X;i++){printf("\n");for(j=0;j<Y;j++)printf("%d ",b[j]);}printf("\n");printf("Now print resource matrix c[%d][%d]=",X,Y); for(i=0;i<X;i++){printf("\n");for(j=0;j<Y;j++)printf("%d ",c[j]);}printf("\n");printf("Now printm multiply results matrix a[%d][%d]=B*C:",X,Y);for(i=0;i<X;i++){printf("\n");for(j=0;j<Y;j++)printf("%d ",a[j]);}getch();return 0;}/********************************************************************/ void matrix(int b[][X],int c[][Y]){int i,j,k,temp;for(i=0;i<X;i++)for(j=0;j<Y;j++){for(k=0;k<Y;k++)a[j]+=b[k]*c[k][j];}}方案二：/*Matrix control head file*/#ifndef NULL#define NULL 0;#endif#define TYPE longclass Matrix{private:TYPE *data;int MATRIX_H_SIZE;int MATRIX_V_SIZE;bool IS_EMPTY;public:Matrix(){IS_EMPTY=true;}Matrix(int h_dim_size,int v_dim_size){data=new TYPE[h_dim_size*v_dim_size];MATRIX_H_SIZE=h_dim_size;MATRIX_V_SIZE=v_dim_size;IS_EMPTY=false;}Matrix(Matrix *matrix){if (!matrix->IsEmpty()){data=new TYPE[matrix->GetDimX()*matrix->GetDimY()]; MATRIX_H_SIZE=matrix->GetDimX();MATRIX_V_SIZE=matrix->GetDimY();IS_EMPTY=false;TYPE t;for(int i=0;i<MATRIX_H_SIZE;i++)for(int j=0;j<MATRIX_V_SIZE;j++){matrix->GetData(i,j,&t);SetData(i,j,t);}}elseIS_EMPTY=true;}~Matrix(){delete[] data;}bool MatrixReload(int h_dim_size,int v_dim_size){if (!IS_EMPTY) return false;data=new TYPE[h_dim_size*v_dim_size];MATRIX_H_SIZE=h_dim_size;MATRIX_V_SIZE=v_dim_size;IS_EMPTY=false;return true;}bool IsEmpty(){return IS_EMPTY;}int GetDimX(){return MATRIX_H_SIZE;}int GetDimY(){return MATRIX_V_SIZE;}bool MatrixClear(){if (IS_EMPTY) return false;delete [] data;IS_EMPTY=true;return true;}bool SetData(int h_index,int v_index,TYPE data){if (IS_EMPTY) return false;this->data[h_index*MATRIX_V_SIZE+v_index]=data;return true;}bool GetData(int h_index,int v_index,TYPE *return_data){ if (IS_EMPTY) return false;if (h_index>=MATRIX_H_SIZE || v_index>=MATRIX_V_SIZE) return false;*return_data=data[h_index*MATRIX_V_SIZE+v_index];return true;}//矩阵操作TYPE SumHXV(int m,int n,Matrix *matrix) //m行x n列{TYPE sum(0);TYPE temp[2];for(int i=0;i<MATRIX_V_SIZE;i++){GetData(m,i,&temp[0]);matrix->GetData(i,n,&temp[1]);sum+=temp[0]*temp[1];}return sum;}Matrix * HSwap(int m,int n)//行交换{if (IS_EMPTY) return NULL;Matrix *temp=new Matrix(this);TYPE t[2];for(int i=0;i<MATRIX_V_SIZE;i++){temp->GetData(m-1,i,&t[0]);temp->GetData(n-1,i,&t[1]);temp->SetData(m-1,i,t[1]);temp->SetData(n-1,i,t[0]);}return temp;}Matrix * VSwap(int m,int n)//行交换{if (IS_EMPTY) return NULL;Matrix *temp=new Matrix(this);TYPE t[2];for(int i=0;i<MATRIX_H_SIZE;i++){temp->GetData(i,m-1,&t[0]);temp->GetData(i,n-1,&t[1]);temp->SetData(i,m-1,t[1]);temp->SetData(i,n-1,t[0]);}return temp;}Matrix * AddMatrix(Matrix *matrix){if (IS_EMPTY) return NULL;if (matrix->IsEmpty()) return this;if (MATRIX_H_SIZE!=matrix->GetDimX() ||MATRIX_V_SIZE!=matrix->GetDimY())return this;Matrix *temp=new Matrix(MATRIX_H_SIZE,MATRIX_V_SIZE); TYPE t[3];for (int i=0;i<MATRIX_H_SIZE;i++)for (int j=0;j<MATRIX_V_SIZE;j++){ GetData(i,j,&t[0]);matrix->GetData(i,j,&t[1]);t[2]=t[0]+t[1];temp->SetData(i,j,t[2]);}return temp;}Matrix * RightXMatrix(Matrix *matrix) //矩阵右乘{if (IS_EMPTY) return NULL;if (matrix->IsEmpty()) return this;if (MATRIX_V_SIZE!=matrix->GetDimX())return this;Matrix *temp=new Matrix(MATRIX_H_SIZE,matrix->GetDimY());for (int i=0;i<MATRIX_H_SIZE;i++)for (int j=0;j<matrix->GetDimY();j++)temp->SetData(i,j,SumHXV(i,j,matrix));return temp;}Matrix * LeftXMatrix(Matrix *matrix) //矩阵左乘{if (IS_EMPTY) return NULL;if (matrix->IsEmpty()) return this;if (MATRIX_H_SIZE!=matrix->GetDimY())return this;Matrix *temp=new Matrix(matrix->GetDimX(),MATRIX_V_SIZE);for (int i=0;i<matrix->GetDimX();i++)for (int j=0;j<MATRIX_V_SIZE;j++)temp->SetData(i,j,matrix->SumHXV(i,j,this));return temp;}Matrix * NumXMatrix(TYPE num){if (IS_EMPTY) return NULL;Matrix *temp=new Matrix(MATRIX_H_SIZE,MATRIX_V_SIZE); TYPE t;for (int i=0;i<MATRIX_H_SIZE;i++)for (int j=0;j<MATRIX_V_SIZE;j++){GetData(i,j,&t);temp->SetData(i,j,t*num);}return temp;}Matrix * ReverseMatrix() //矩阵转置{if (IS_EMPTY) return this;Matrix *temp=new Matrix(MATRIX_V_SIZE,MATRIX_H_SIZE); TYPE t;for (int i=0;i<MATRIX_H_SIZE;i++)for (int j=0;j<MATRIX_V_SIZE;j++){GetData(i,j,&t);temp->SetData(j,i,t);}return temp;}Matrix * GetEMatrix(int n) //得到nXn的单位矩阵{if(n<2) return NULL;Matrix *temp=new Matrix(n,n);for (int i=0;i<n;i++)for (int j=0;j<n;j++)(i==j)?temp->SetData(i,j,1):temp->SetData(i,j,0); return temp;}Matrix * MatrixPow(int times) //矩阵幂运算{if (IS_EMPTY)return NULL;Matrix *temp=new Matrix(this);for(int i=1;i<times;i++)temp=temp->LeftXMatrix(this);return temp;}};。
c语言课程设计矩阵相乘
c语言课程设计矩阵相乘一、教学目标本节课的学习目标为：知识目标：让学生掌握C语言中矩阵相乘的原理和实现方法；使学生了解矩阵乘法的数学基础和应用场景。
技能目标：培养学生使用C语言进行矩阵相乘编程实践的能力；训练学生的逻辑思维和问题解决能力。
情感态度价值观目标：激发学生对计算机科学和编程的兴趣，培养学生的创新精神和团队合作意识。
二、教学内容本节课的教学内容如下：1.介绍矩阵乘法的数学原理和计算方法；2.讲解C语言中矩阵的表示方法和矩阵相乘的实现方式；3.通过实例分析，让学生理解矩阵相乘的编程过程和逻辑；4.探讨矩阵相乘在实际问题中的应用场景。
三、教学方法本节课采用以下教学方法：1.讲授法：讲解矩阵乘法的数学原理和C语言实现方法；2.案例分析法：分析实际案例，让学生理解矩阵相乘的编程过程；3.实验法：让学生动手编写矩阵相乘的C语言程序，巩固所学知识；4.讨论法：分组讨论矩阵相乘的应用场景，培养学生的团队合作意识。
四、教学资源本节课所需教学资源包括：1.教材：《C语言程序设计》；2.参考书：《矩阵论与应用》、《C语言编程实践》；3.多媒体资料：PPT课件、矩阵相乘的动画演示；4.实验设备：计算机、编程环境。
教学资源应结合教材内容，辅助教学方法的实施，提高学生的学习兴趣和效果。
五、教学评估本节课的评估方式包括：1.平时表现：观察学生在课堂上的参与程度、提问回答等情况，评估学生的学习态度和积极性。
2.作业：布置相关的编程作业，评估学生的理解和掌握程度。
3.考试：安排一次矩阵相乘的编程考试，全面评估学生的知识掌握和编程能力。
评估方式应客观、公正，能够全面反映学生的学习成果。
根据评估结果，对学生的学习情况进行分析和总结，为后续的教学提供参考。
六、教学安排本节课的教学安排如下：1.教学进度：按照教材的章节安排，逐步讲解矩阵乘法的原理和C语言实现方法。
2.教学时间：安排2课时，每课时45分钟，确保有足够的时间进行讲解和练习。
汇编语言矩阵相乘课程设计附源代码
华北科技学院课程设计说明书班级: 姓名:学号:课程名称: 汇编语言课程设计课设时间: 2006-12-05 至2006-12-16 成绩评定:1、工作量：A( )，B( )C( )，D( ) ,F(2、难易度：A( )，B( )，C( )，D( ),F( )3、答辩情况：基本操作：A( )，B()，C()，D( ),F( )代码理解：A( )，B( )，C( )，D( ),F( )4、报告规范度：A( )，B( )，C( )，D( ),F( )5、学习态度：A( )，B( )，C( )，D( ),F( )总评成绩: 指导教师:一．课程设计的目的、任务1.课程设计的目的：使学生综合使用所学过的汇编语言程序设计知识，掌握结构化程序设计的基本思路和方法，利用所学的基本知识和技能，发挥自学能力和查找资料的能力，解决稍微复杂的结构化程序设计问题，加深对所学知识的理解与掌握，增强学生利用自己所学知识解决实际问题的能力，为以后的程序开发打下基础。
课程设计的目的和要求：（1）使学生巩固和加强《汇编语言》课程的理论知识。
（2）使学生掌握汇编语言的基本概念、语法、语义和数据类型的使用特点。
（3）使学生掌握汇编语言程序设计的方法及编程技巧，能正确使用汇编语言编写程序。
（3）进一步理解与运用结构化程序设计的思想和方法；学会利用流程图或N-S 图表示算法。
（4）使学生掌握调试程序的基本方法及上机操作方法。
（ 5）掌握书写程设计开发文档的能力，使学生学会撰写课程设计总结报告。
课程设计的思想和方法还可以作为学生做毕业论文时的参考资料。
（6）通过查阅手册和文献资料，培养学生独立分析问题和解决问题的能力。
为学生做毕业设计打好基础。
（7）初步掌握开发一个小型实用系统的基本方法：结合实际应用的要求，使课程设计既覆盖知识点，又接近工程实际需要。
通过激发学习兴趣，调动学生主动学习的积极性，并引导他们根据实际编程要求，训练自己实际分析问题的能力及编程能力，并养成良好的编程习惯。
c语言课课程设计矩阵相乘
c语言课课程设计矩阵相乘一、教学目标本节课的教学目标是让学生掌握C语言中矩阵相乘的算法，并能够运用C语言编程实现矩阵相乘。
具体分为以下三个方面的目标：1.知识目标：使学生理解矩阵相乘的数学原理，掌握矩阵相乘的算法，并能够用C语言实现矩阵相乘。
2.技能目标：培养学生运用C语言编程解决问题的能力，提高学生的编程技巧和逻辑思维能力。
3.情感态度价值观目标：激发学生对计算机科学和编程的兴趣，培养学生的创新精神和团队合作意识。
二、教学内容本节课的教学内容主要包括以下几个部分：1.矩阵相乘的数学原理：向学生讲解矩阵相乘的定义和运算规则，使学生理解矩阵相乘的内在逻辑。
2.矩阵相乘的算法：介绍矩阵相乘的计算方法，引导学生掌握算法的基本思路。
3.C语言编程实现矩阵相乘：教授学生如何利用C语言编写程序实现矩阵相乘，指导学生调试程序，纠正错误。
三、教学方法为了达到本节课的教学目标，将采用以下几种教学方法：1.讲授法：讲解矩阵相乘的数学原理和算法，使学生掌握基本概念和运算规则。
2.案例分析法：分析实际编程案例，引导学生学会运用C语言实现矩阵相乘。
3.实验法：让学生动手编写程序，调试和优化矩阵相乘的算法，提高学生的实践能力。
四、教学资源为了支持本节课的教学内容和教学方法的实施，将准备以下教学资源：1.教材：选用权威、实用的C语言编程教材，为学生提供理论知识的学习支持。
2.多媒体资料：制作课件、教学视频等资料，以图文并茂的形式展示矩阵相乘的原理和编程方法。
3.实验设备：为学生提供计算机、编程环境等实验设备，确保学生能够进行实际编程操作。
4.在线编程平台：利用在线编程平台，让学生进行编程练习，及时反馈学生的学习进度和问题。
五、教学评估为了全面、客观地评估学生的学习成果，将采用以下几种评估方式：1.平时表现：观察学生在课堂上的参与程度、提问回答等情况，了解学生的学习态度和掌握程度。
2.作业：布置与矩阵相乘相关的编程作业，要求学生独立完成，评估学生的编程能力和理解程度。
矩阵相乘课程设计
“程序设计基础”课程设计报告设计题目矩阵乘法姓名罗文飞学号2014217163专业信息工程系计算机类班级计算机四班（一）要求和规格说明。
编写一个函数实现矩阵A（2行3列）与矩阵B相乘（3行2列），乘积放在C数组中。
在主函数中输入相乘的两数组，并输出结果。
（二）设计。
用二维数组实现二维矩阵的乘法，矩阵A,B分别用一个二维数组表示，矩阵乘积的结果C用一个二维数组存放。
算法：(1)二维矩阵初始化。
(2)两个二维矩阵进行乘法运算。
①输入参加运算的二维矩阵。
②执行矩阵的运算。
③输出运算结果的矩阵。
（三）源代码：#include<iostream.h>#define M 2#define N 3#define K 2int A[M][N]; //矩阵Aint B[N][K]; //矩阵Bint C[M][K]; //矩阵C存放A*B的结果int main(){int i,j,k;cout<<"请输入A[2][3]矩阵中的元素："<<endl;for(i=0;i<M;i++)for(j=0;j<N;j++){cin>>A[i][j]; //输入二维数组A:2行3列}cout<<"请输入B[3][2]矩阵中的元素："<<endl;for(i=0;i<N;i++)for(j=0;j<K;j++){cin>>B[i][j]; //输入二维数组B:3行2列}for(i=0;i<M;i++)for(j=0;j<K;j++){C[i][j]=0; //乘积赋出值为零for(k=0;k<N;k++)C[i][j]+=A[i][k]*B[k][j]; //A数组的第i行与B数组的第j列相乘}cout<<"矩阵相乘的结果C[2][2]为："<<endl;for(i=0;i<M;i++){for(j=0;j<K;j++){cout<<C[i][j]<<" "; //输出矩阵的乘积结果C[2][2] }cout<<endl;}return 0;}运算结果：两个矩阵的乘法：#include <iostream>using namespace std;int main(){int row1=0,row2=0,cow1=0,cow2=0;int i=0,j=0,k=0,temp=0;int array1[20][20],array2[20][20],array[20][20];cout<<"请输入第一个矩阵的行数和列数"<<endl;cin>>row1>>cow1;cout<<"请输入"<<row1<<"行"<<cow1<<"列矩阵"<<endl;for(i=0;i<row1;i++)for(j=0;j<cow1;j++)cin>>array1[i][j];cout<<"请输入第二个矩阵的行数和列数"<<endl;cin>>row2>>cow2;cout<<"请输入"<<row2<<"行"<<cow2<<"列矩阵"<<endl; if(cow1!=row2){cout<<"矩阵不能相乘"<<endl;exit(0);}for(i=0;i<row2;i++)for(j=0;j<cow2;j++)cin>>array2[i][j];for(i=0;i<row1;i++){for(j=0;j<cow2;j++){temp=0;for(k=0;k<cow1;k++)temp=temp+array1[i][k]*array2[k][j];array[i][j]=temp;}}cout<<"2个矩阵相乘的结果是:"<<endl;cout<<"行:"<<row1<<" 列:"<<cow2<<endl;for(i=0;i<row1;i++){for(j=0;j<cow2;j++)cout<<array[i][j]<<" ";cout<<endl;}return 0;}。
矩阵相乘-汇编课设
附件1：
学号：18
课程设计
题目矩阵相乘运算
学院计算机科学与技术
专业计算机科学与技术
班级计算机0903班
姓名易驰杰
指导教师张霞
2012 年 1 月 3 日
课程设计任务书
学生姓名：易驰杰专业班级：计算机0903班
指导教师：张霞工作单位：计算机科学与技术学院
题目: 矩阵相乘运算
初始条件：
理论：完成了《汇编语言程序设计》课程，对微机系统结构和80系列指令系统有了较深入的理解，已掌握了汇编语言程序设计的基本方法和技巧。
实践：完成了《汇编语言程序设计》的4个实验，熟悉了汇编语言程序的设计环境并掌握了汇编语言程序的调试方法。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）
进一步理解和掌握较复杂程序的设计方法，掌握子程序结构的设计和友好用户界面的设计。
具体的设计任务及要求：
1）模拟两个二维数组；
2）实现两个二维数组相乘，并将结果采用矩阵在屏幕上输出；
3）程序采用子程序结构，结构清晰；
4）友好清晰的用户界面，能识别输入错误并控制错误的修改。
在完成设计任务后，按要求撰写课程设计说明书；对课程设计说明书的具体要求请见课程设计指导书。
阅读资料：
1）《IBM—PC汇编语言程序设计实验教程》实验2.4
2）《IBM—PC汇编语言程序设计（第2版）》例6.11
时间安排：
设计安排一周：周1、周2：完成系统分析及设计。
周3、周4：完成程序调试，和验收。
周5：撰写课程设计报告。
指导教师签名：年月日
系主任（或责任教师）签名：年月日。
C22_矩阵的乘法-乘方运算的C程序
//矩阵的乘法、乘方运算的C语言程序//求两个矩阵的乘积及方阵的乘方#include<conio.h> //getch#include<stdio.h> //printf,scanf#include<time.h> //time#include<stdlib.h> //srand,rand//============抽象数据类型矩阵的表示============//typedef struct { //矩阵的定义double *p; //矩阵数据存放的首地址int row; //行数int col; //列数}Matrix;//============抽象数据类型矩阵的实现============//void InitMat(Matrix &m) //初始化为空{m.p=NULL;m.row=0;m.col=0;}void ErrExit(char *s){ //遇错退出并提示printf("\n%s !",s);getch();exit(0);}void InitMat(Matrix &m,int r,int c){ //初始化指针及行列数if(r<=0||c<=0)ErrExit("\n矩阵型行列数错");m.p=new double[r*c];m.row=r;m.col=c;}void RandMat(Matrix &m){ //给矩阵赋随机值for(int i=0;i<m.row;i++)for(int j=0;j<m.col;j++)*(m.p+i*m.col+j)=rand()%3+1; //取1-3的整数}void ClearMat(Matrix &m){ //清空矩阵为全0 for(int i=0;i<m.row;i++)for(int j=0;j<m.col;j++)*(m.p+i*m.col+j)=0;}void UnitMat(Matrix &m) //构造单位矩阵{for(int i=0;i<m.row;i++)for(int j=0;j<m.col;j++)if(i==j)*(m.p+i*m.col+j)=1;else *(m.p+i*m.col+j)=0;}void PrintMat(Matrix m,char *str){ //输出矩阵的所有值printf("\n矩阵%s为：",str);for(int i=0;i<m.row;i++){printf("\n");for(int j=0;j<m.col;j++)printf("%4lg",*(m.p+i*m.col+j));}}void Destroy(Matrix &m) //销毁矩阵，释放内存{if(m.p)delete[] m.p;m.p=NULL;}void MulMat(Matrix &m,Matrix a,Matrix b){ //求两矩阵的积if(a.col!=b.row)ErrExit("\n相乘失配"); //矩阵失配不能相乘InitMat(m,a.row,b.col); //申请空间ClearMat(m); //清空矩阵为全0for(int i=0;i<a.row;i++)for(int j=0;j<b.col;j++)for(int k=0;k<a.col;k++)*(m.p+i*m.col+j)+=*(a.p+i*a.col+k)**(b.p+k*b.col+j); }void CopyMat(Matrix d,Matrix s){ //拷贝矩阵s至d if(d.row!=s.row||d.col!=s.col)ErrExit("\n拷贝扮配");for(int i=0;i<s.row;i++)for(int j=0;j<s.col;j++)*(d.p+i*d.col+j)=*(s.p+i*s.col+j);}void PowMat(Matrix &m,Matrix a,unsigned n){ //求矩阵的乘方if(a.row!=a.col)ErrExit("\n乘方失配");Matrix x;InitMat(x,a.row,a.col);UnitMat(x); //构造单位阵xif(n==0){InitMat(m,a.row,a.col);CopyMat(m,x);}for(unsigned i=1;i<=n;i++){if(m.p)Destroy(m); //MulMat后必须销毁mMulMat(m,x,a);CopyMat(x,m);}Destroy(x);}//下面的程序似乎更简单，但是没有清理内存void PowMat2(Matrix &m,Matrix a,unsigned n){ //求矩阵的乘方InitMat(m,a.row,a.col);UnitMat(m);for(unsigned i=1;i<=n;i++)MulMat(m,m,a);}//=====================程序测试=================//void main(){Matrix m,a,b,c;srand((int)time(0));InitMat(m);InitMat(a,2,3); //申请空间InitMat(b,3,4);InitMat(c,2,2);RandMat(a); //给矩阵赋随机值RandMat(b);RandMat(c);PrintMat(a,"a"); //输出矩阵PrintMat(b,"b");PrintMat(c,"c");MulMat(m,a,b ); //矩阵相乘PrintMat(m,"a*b");Destroy(m);PowMat(m,c,3u); //矩阵乘方PrintMat(m,"c的3次方");Destroy(m);Destroy(a);Destroy(b);Destroy(c);getch();}。
c语言矩阵乘法课程设计
c语言 矩阵乘法课程设计一、课程目标知识目标：1. 学生能理解矩阵乘法的概念，掌握C语言中实现矩阵乘法的基本算法。
2. 学生能运用循环和数组知识，编写出实现矩阵乘法的程序。
3. 学生能理解并描述矩阵乘法在计算机科学中的应用场景。
技能目标：1. 学生能运用C语言编写、调试简单的矩阵乘法程序，提高编程能力。
2. 学生能通过分析算法，优化矩阵乘法程序，提升解决问题的能力。
3. 学生能通过小组合作，进行程序设计和讨论，提高团队协作能力。
情感态度价值观目标：1. 学生在学习过程中，培养对编程的兴趣和热情，增强自信心。
2. 学生通过解决实际问题，体会编程带来的成就感，提高对C语言学习的积极性。
3. 学生在学习中，培养严谨、细心的科学态度，认识到团队合作的重要性。
课程性质：本课程为C语言程序设计实践课程，结合数学知识，锻炼学生的编程能力和实际问题解决能力。
学生特点：学生已具备C语言基础知识，对循环、数组等概念有所了解，但实际编程经验尚不足。
教学要求：通过本课程的学习，教师应引导学生将理论知识与实际操作相结合，培养学生的编程思维和实际操作能力。
在教学过程中，注重学生的主体地位，鼓励学生积极参与讨论和合作，提高学生的综合素养。
二、教学内容1. 矩阵乘法原理复习：回顾矩阵乘法的基本定义，理解矩阵乘法规则。
相关教材章节：第三章 数组与矩阵，第四节 矩阵的运算。
2. C语言矩阵乘法算法分析：讲解C语言实现矩阵乘法的方法，介绍二维数组的使用。
相关教材章节：第二章 C语言基础，第五节 二维数组。
3. 编程实现矩阵乘法：a. 学生自主编写简单矩阵乘法程序，体验编程过程。
b. 讨论优化算法，提高程序执行效率。
相关教材章节：第四章 循环结构，第三节 循环应用实例。
4. 矩阵乘法在实际应用中的案例分析：介绍矩阵乘法在计算机图形学、人工智能等领域中的应用。
相关教材章节：第五章 C语言应用实例，第二节 矩阵乘法应用。
5. 小组合作与实践：a. 学生分组讨论，设计并实现一个矩阵乘法程序。
riscv 矩阵乘法 汇编代码
riscv 矩阵乘法汇编代码RISC-V 是一个基于精简指令集（RISC）的开源指令集架构（ISA）。
矩阵乘法是一个常见的计算密集型任务，通常用于线性代数、图形学、机器学习等领域。
然而，直接写出用于矩阵乘法的RISC-V 汇编代码是相当复杂且冗长的，因为它涉及到循环、内存访问和算术运算。
此外，RISC-V 指令集本身并不直接支持矩阵乘法这样的高级操作，因此需要通过一系列的基础指令来实现。
下面是一个非常简化的示例，展示了如何使用RISC-V 汇编语言实现两个2x2 矩阵的乘法。
请注意，这只是一个教学示例，实际的矩阵乘法实现可能会更加复杂，并且会考虑性能优化。
assembly.section .datamatrixA: .word 1, 2, 3, 4 # 2x2 matrix: [[1, 2], [3, 4]]matrixB: .word 5, 6, 7, 8 # 2x2 matrix: [[5, 6], [7, 8]]result: .word 0, 0, 0, 0 # Space for the result matrix.section .text.globl _start_start:# Load matrix A and B into registersla a0, matrixA # Load address of matrix A into a0la a1, matrixB # Load address of matrix B into a1la a2, result # Load address of result matrix into a2# Initialize loop countersli t0, 0 # i = 0li t1, 0 # j = 0li t2, 0 # k = 0matrix_multiply:# Check if we've finished all rows of Abge t0, 2, end_multiply# Check if we've finished all columns of Bbge t1, 2, next_row_a# Inner loop: calculate a single element of the result matrixli t3, 0 # Accumulator for the element calculationli t4, 0 # l = 0 (for the inner loop)inner_loop:# Check if we've finished the inner loopbge t4, 2, next_column_b# Load elements of A and Blw t5, 0(a0) # Load element A[i][l] into t5lw t6, 0(a1) # Load element B[l][j] into t6# Calculate A[i][l] * B[l][j]mul t7, t5, t6 # t7 = A[i][l] * B[l][j]# Accumulate the resultadd t3, t3, t7 # Accumulator += A[i][l] * B[l][j]# Increment the inner loop counter and pointersaddi t4, t4, 1 # l++addi a0, a0, 4 # Move to the next element in the same row of Aaddi a1, a1, 4 # Move to the next element in the same column of B# Jump back to the beginning of the inner loopj inner_loopnext_column_b:# Reset the inner loop counter and pointersli t4, 0 # l = 0addi a0, a0, -8 # Move back to the beginning of the current row of Aaddi a1, a1, 8 # Move to the next column of B# Increment the column counter of Baddi t1, t1, 1 # j++# Jump back to the beginning of the row loopj matrix_multiplynext_row_a:# Reset the column counter of B and pointersli t1, 0 # j = 0addi a0, a0, 8 # Move to the next row of Ala a1, matrixB # Reset the pointer to the beginning of B# Increment the row counter of Aaddi t0, t0, 1 # i++# Jump back to the beginning of the matrix multiplicationj matrix_multiplyend_multiply:# Store the result back to memoryla a0, resultsw t3, 0(a0) # This is just a placeholder. In reality, you would need to store each element of the result matrix.# Exit the programli a7, 10 # System call code for exitli a0, 0 # Exit statusecall # Perform the system call注意：这个代码只是一个非常简化的示例，它并没有正确地计算和存储整个结果矩阵。
矩阵的转置和乘法课程设计程序
矩阵的转置和乘法课程设计程序#ifndef CMatrix_H_//************************************************条件编译#define CMatrix_H_#include<iostream>#include<fstream>#include"vec.h"//using namespace std;#define MIN(a,b) ((a)<(b))?(a):(b);/*----------------------------------------定义类模板-------------------------------*/template <class T>class CMatrix{struct node{Vector<T> **f;//*******************************************组成矩阵的向量指针int refcnt;//*************************************************被引用次数int length;//****************************************************矩阵的行数T **tmppointer;//*******************************************头指针类型} *p;public://Vector<T> ** begin() const {return p->f;};CMatrix();//***********************************************************默认的构造CMatrix(int xsize,int ysize,T init=0);//*********************************构造函数CMatrix(int xlength,const V ector<T> *vec);//********************************构造函数CMatrix(CMatrix<T> &x); //***********************************************拷贝构造函数~CMatrix();//************************************************************析构函数CMatrix<T> & operator=(const CMatrix<T> &mat);//*************************重载赋值运算符int row() const;//*******************************************************返回行数int col() const;//*******************************************************返回列数Vector<T> & operator []( int i);//******************************************重载[]void Inver(CMatrix &mat);//*********************************************矩阵转置operator T **();//*********************************************************重载**void ReadFromFile();//**************************************************从文件中读入矩阵friend CMatrix cpy(CMatrix &v);//***********************************************拷贝函数friend std::ostream & operator<<(std::ostream &s,const CMatrix<T> &mat);//重载输出函数friend std::istream & operator>>(std::istream &s,const CMatrix<T> &mat);//重载输入函数friend CMatrix<T> operator*(CMatrix<T> &v1,CMatrix<T> &v2);//***************矩阵乘法friend CMatrix<T> operator*(const CMatrix<T> &v,T val); //**********************数乘};/*----------------------------------------类外定义缺省的构造函数----------------------------*/ template <class T>CMatrix<T>::CMatrix(){p=new node;p->length=NULL;p->f=0;p->refcnt=1;p->tmppointer=NULL;}/*----------------------------------------定义可扩展构造函数------------------------*/template <class T>CMatrix<T>::CMatrix(int xsize,int ysize,T init){if(xsize<=0||ysize<=0) cout<<"error!!";p=new node;p->length=xsize;p->f=new Vector<T> *[xsize];for(int i(0);i<xsize;i++)p->f[i]=new Vector<T>(ysize,init);p->refcnt=1;p->tmppointer=NULL;}/*------------------------------------定义构造函数----------------------------*/template <class T>CMatrix<T>::CMatrix(int xlength,const Vector<T> *vec){if(xlength<=0) cout<<"error!!";p=new node;p->length=xlength;p->f=new Vector<T> *[xlength];for(int i(0);i<xlength;i++)p->f[i]=new Vector<T>(*vec);}/*------------------------------------定义拷贝的构造函数-------------------------*/ template <class T>CMatrix<T>::CMatrix(CMatrix<T> &x){x.p->refcnt++;p=x.p;}template <class T>CMatrix<T> cpy(CMatrix<T> &v){int mr=v.row();int mc=v.col();CMatrix<T> x(mr,mc);for(int i(0);i<mr;i++)*(x.p->f[i])=*(v.p->f[i]);return x;}/*-----------------------------------定义析构函数-------------------------—*/ template <class T>CMatrix<T>::~CMatrix(){if(--p->refcnt==0){if(p->f!=NULL){int len=p->length;for(int i(0);i<len;i++)delete p->f[i];if(p->tmppointer!=NULL)delete p->tmppointer;delete p->f;}}}/*------------------------------定义函数返回行数-----------------------*/int CMatrix<T>::row() const{return p->length;}/*----------------------------定义函数返回列数----------------------*/template <class T>int CMatrix<T>::col() const{return p->f[0]->dim();}/*----------------------------定义转置的函数-----------------------*/template <class T>void Inver(CMatrix<T> &mat){int m = mat.row();int n = mat.col();CMatrix<T> tmp(n,m);int i, j;for(i=0; i<n; i++){for(j=0; j<m; j++)tmp[i][j]=mat[j][i];}mat=tmp;}/*---------------------------定义重载函数重载赋值操作符号=--------------------*/ template <class T>CMatrix<T> & CMatrix<T>::operator=(const CMatrix<T> &vec){vec.p->refcnt++;if(--p->refcnt==0){int len=p->length;for(int i(0);i<len;i++)delete p->f[i];delete p->f;if(p->tmppointer!=NULL)delete p->tmppointer;delete p;}p=vec.p;return *this;}/*-------------------------定义重载函数重载[]---------------------------*/Vector<T> &CMatrix<T>::operator[](int i){if((i>=0)&&(i<p->length))return *p->f[i];else{cout<<"error"<<endl;return *p->f[0];}}/*--------------------------------定义重载函数重载**------------------*/template<class T>CMatrix<T>::operator T **(){if(p->tmppointer==NULL){int n=row();p->tmppointer=new T *[n];for(int i(0);i<n;i++)p->tmppointer[i]=p->f[i]->begin();}return p->tmppointer;}template <class T>void CMatrix<T>::ReadFromFile()//******************************从文件中读入矩阵{char filename[256];cin>>filename;ifstream infile;// cout<<"****";int row,col;infile.open(filename,ios::in);if(!infile){cout<<"不能打开输入文件!"<<endl;exit(1);};infile>>row>>col;CMatrix<T> v1(row,col,0);// infile>>v1[0][0];// cout<<v1[0][0]<<"*****"<<endl;for(int i(0);i<row;i++)for(int j(0);j<col;j++)infile>>v1[i][j];*this=v1;}/*-----------------------定义函数重载输出《------------------------------*/ template <class T>std::ostream & operator<<(std::ostream & os,CMatrix<T> &v1){// os<<"{"<<endl;Vector<T> **f=v1.begin();// cout<<v1.begin()<<"*&*"<<endl;int len=v1.row();for(int i(0);i<len;i++)os<<*f[i]<<"\n";return os;}/*-------------------------定义函数重载输入---------------------------*/ template <class T>std::istream & operator>>(std::istream & is,CMatrix<T> &v1){int row,col;cout<<"请您分别输入矩阵的行数和列数:\n";is>>row>>col;CMatrix<T> x(row,col,0);cout<<"请输入"<<row<<'*'<<col<<"矩阵\n";for(int i(0);i<row;i++)for(int j(0);j<col;j++)is>>x[i][j];v1=x;return is;}/*--------------------------定义重载函数重载乘法*---------------------------*/ template <class T>CMatrix<T> operator*(CMatrix<T> &m1,CMatrix<T> &m2){int i,j;int m1rows=m1.row();int m1cols=m1.col();int m2rows=m2.row();int m2cols=m2.col();if(m1cols!=m2rows)cout<<"error!"<<endl;CMatrix<T> v(m1rows,m2cols);CMatrix<T> flip(m2cols,m2rows);for(i=0;i<m2rows;i++)for(j=0;j<m2cols;j++)flip[j][i]=m2[i][j];for(i=0;i<m1rows;i++)for(j=0;j<m2cols;j++)v[i][j]=dot_prod(m1[i],flip[j]);return v;}/*----------------------------------定义函数重载数乘（整型，双精度型）-------------------------------*/ CMatrix<int> operator*(const CMatrix<int> &v,int val){CMatrix<int> temp;temp=v;for(int i(0);i<v.p->length;i++)*(temp.p->f[i])=*(v.p->f[i])*val;return temp;}CMatrix<double> operator*(const CMatrix<double> &v,double val){CMatrix<double> temp;temp=v;for(int i(0);i<v.p->length;i++)*(temp.p->f[i])=*(v.p->f[i])*val;return temp;}#endif/*---------------------------------------------------定义几个选择函数----------------------------------------*/void choiceid();//********************************************选择输入矩阵的类型void processint();//*****************************************选择输入矩阵的饿方式void processdouble();//***************************************选择输入矩阵的方式template<class T>void process(CMatrix<T> &cm,CMatrix<T> &cm1,CMatrix<T> &cm2);void main(){cout<<"!!!!!!!!!!!!!!!!!!!欢迎您进入并使用矩阵转置和乘法程序!!!!!!!!!!!!!!!!!!\n";cout<<"\t（请您注意本程序对您输入的矩阵的项数不等于\n\t\t您事先设定的矩阵项数时无法识别，请您见量!）\n\n";choiceid();}/*---------------------------------------------------------定义选择函数-----------------------------------------*/void choiceid(){cout<<"^----^请您输入矩阵的类型:\n输入整型请按1\n输入浮点型请按2\n";int choice;cin>>choice;switch(choice){case 1:processint();break;case 2:processdouble();break;default:break;}}void processint(){CMatrix<int> icm(2,2,0),icm1,icm2;cout<<"^----^请您选择输入方式:\n从键盘输入请按1\n从文件输入请按2\n";int choice;while(cin>>choice){switch(choice){case 1:cout<<"请您输入第1个矩阵:\n";cin>>icm1;cout<<"请您输入第2个矩阵:\n";cin>>icm2;process(icm,icm1,icm2);break;case 2:cout<<"输入矩阵1的路径:";icm1.ReadFromFile();cout<<"输入矩阵2的路径:";icm2.ReadFromFile();process(icm,icm1,icm2);break;default:break;}}}void processdouble(){CMatrix<double> icm,icm1,icm2;cout<<"^---------^请您请选择输入方式:\n1.从键盘输入矩阵\n2.从文件输入矩阵\n";int choice;while(cin>>choice){switch(choice){case 1:cout<<"请您输入第1个矩阵:\n";cin>>icm1;cout<<"请您输入第2个矩阵:\n";cin>>icm2;process(icm,icm1,icm2);break;case 2:cout<<"输入矩阵1的路径:";icm1.ReadFromFile();cout<<"输入矩阵2的路径:";icm2.ReadFromFile();process(icm,icm1,icm2);break;default:break;}}}template<class T>void process(CMatrix<T> &cm,CMatrix<T> &cm1,CMatrix<T> &cm2){int choice;double val;cout<<"请您选择对矩阵的操作类型:\n1.两矩阵相乘\n2.矩阵数乘\n3.矩阵转置\n其他键退出\n";while(cin>>choice){switch(choice){case 1:cm=cm1*cm2;cout<<"两矩阵相乘的结果为:\n"<<cm<<endl;cout<<"1.退出\n2.继续\n";cin>>choice;if(choice==1){cout<<"谢谢您的使用！再见！\n";}exit(0);if(choice==2){cout<<"请您选择对矩阵的操作类型:\n1.两矩阵相乘\n2.矩阵数乘\n3.矩阵转置\n其他键退出\n";continue;};break;case 2:cout<<"请您输入要乘的数:\n";cin>>val;cout<<"请您输入需要数乘的矩阵:\n1.矩阵1\n2.矩阵2\n";cin>>choice;switch(choice){case 1:cm=cm1*val;cout<<"矩阵1:\n"<<"\n乘以数"<<val<<"的结果为:\n"<<cm<<endl;cout<<"1.退出\n2.继续\n";cin>>choice;if(choice==1){cout<<"谢谢您的使用！再见！\n";} exit(0);if(choice==2){cout<<"请您选择对矩阵的操作类型:\n1.两矩阵相乘\n2.矩阵数乘\n3.矩阵转置\n其他键退出\n";continue;};break;case 2:cm=cm2*val;cout<<"矩阵2:\n"<<"\n乘以数"<<val<<"的结果为:\n"<<cm<<endl;cout<<"1.退出\n2.继续\n";cin>>choice;if(choice==1){cout<<"谢谢您的使用！再见！\n";} exit(0);if(choice==2){cout<<"请您选择对矩阵的操作类型:\n1.两矩阵相乘\n2.矩阵数乘\n3.矩阵转置\n其他键退出\n";continue;};break;}case 3:cout<<"请您输入需要转置的矩阵:\n1.矩阵1\n2.矩阵2\n";while(cin>>choice){if(choice==1){Inver(cm1);cout<<"转置后矩阵1为："<<'\n';cout<<cm1<<endl;break;}else if(choice==2){Inver(cm2);cout<<"转置后矩阵2为："<<'\n';cout<<cm2<<endl;break;}else cout<<"输入错误,请重新输入!"<<endl;continue;};cout<<"1.退出\n2.继续\n";cin>>choice;if(choice==1){cout<<"谢谢您的使用！再见！\n";}exit(0);if(choice==2){cout<<"请选择对矩阵的操作类型:\n1.两矩阵相乘\n2.矩阵数乘\n3.矩阵转置\n";continue;};default:exit(0);}}}/*--------------------------------------------程序结束了！。
汇编课程设计 矩阵的乘法运算
学号：01201010340329课程设计题目矩阵相乘运算学院计算机科学与技术学院专业计算机科学与技术专业班级姓名指导教师20 年月日课程设计任务书学生姓名：专业班级：指导教师：工作单位：计算机科学与技术学院题目: 矩阵相乘运算初始条件：理论：完成了《汇编语言程序设计》课程，对微机系统结构和80系列指令系统有了较深入的理解，已掌握了汇编语言程序设计的基本方法和技巧。
实践：完成了《汇编语言程序设计》的4个实验，熟悉了汇编语言程序的设计环境并掌握了汇编语言程序的调试方法。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）进一步理解和掌握较复杂程序的设计方法，掌握子程序结构的设计和友好用户界面的设计。
具体的设计任务及要求：1）模拟两个二维数组；2）实现两个二维数组相乘，并将结果采用矩阵在屏幕上输出；3）程序采用子程序结构，结构清晰；4）友好清晰的用户界面，能识别输入错误并控制错误的修改。
在完成设计任务后，按要求撰写课程设计说明书；对课程设计说明书的具体要求请见课程设计指导书。
阅读资料：1）《IBM—PC汇编语言程序设计实验教程》实验2.42）《IBM—PC汇编语言程序设计（第2版）》例6.11时间安排：设计安排一周：周1、周2：完成系统分析及设计。
周3、周4：完成程序调试，和验收。
周5：撰写课程设计报告。
指导教师签名：年月日系主任（或责任教师）签名：年月日目录1 问题分析 (4)1.1 具体任务 (4)1.2 输入 (4)1.3 输出 (4)1.4 子程序 (4)2 程序设计 (4)2.1 数据段定义 (4)2.2 回车子程序ENT和输出空格子程序SPA (5)2.3 提示输入错误 ERROR (5)2.4 输入子程序 INPUT (5)2.5 输出子程序 OUTPUT (6)2.6 矩阵相乘子程序 MULTI (7)2.7 主程序 (8)3 调试过程与结果 (8)3.1 调试过程 (8)3.2 输出结果 (9)4 总结 (10)5 参考文献 (10)6 附录 (11)矩阵相乘运算1 问题分析1.1 具体任务（1）模拟两个二维数组；（2）实现两个二维数组相乘，并将结果采用矩阵在屏幕上输出；（3）程序采用子程序结构，结构清晰；（4）友好清晰的用户界面，能识别输入错误并控制错误的修改。
矩阵的转置和乘法课程设计程序
矩阵的转置和乘法课程设计程序#ifndef CMatrix_H_//************************************************条件编译#define CMatrix_H_#include<iostream>#include<fstream>#include"vec.h"//using namespace std;#define MIN(a,b) ((a)<(b))?(a):(b);/*----------------------------------------定义类模板-------------------------------*/template <class T>class CMatrix{struct node{Vector<T> **f;//*******************************************组成矩阵的向量指针int refcnt;//*************************************************被引用次数int length;//****************************************************矩阵的行数T **tmppointer;//*******************************************头指针类型} *p;public://Vector<T> ** begin() const {return p->f;};CMatrix();//***********************************************************默认的构造CMatrix(int xsize,int ysize,T init=0);//*********************************构造函数CMatrix(int xlength,const V ector<T> *vec);//********************************构造函数CMatrix(CMatrix<T> &x); //***********************************************拷贝构造函数~CMatrix();//************************************************************析构函数CMatrix<T> & operator=(const CMatrix<T> &mat);//*************************重载赋值运算符int row() const;//*******************************************************返回行数int col() const;//*******************************************************返回列数Vector<T> & operator []( int i);//******************************************重载[]void Inver(CMatrix &mat);//*********************************************矩阵转置operator T **();//*********************************************************重载**void ReadFromFile();//**************************************************从文件中读入矩阵friend CMatrix cpy(CMatrix &v);//***********************************************拷贝函数friend std::ostream & operator<<(std::ostream &s,const CMatrix<T> &mat);//重载输出函数friend std::istream & operator>>(std::istream &s,const CMatrix<T> &mat);//重载输入函数friend CMatrix<T> operator*(CMatrix<T> &v1,CMatrix<T> &v2);//***************矩阵乘法friend CMatrix<T> operator*(const CMatrix<T> &v,T val); //**********************数乘};/*----------------------------------------类外定义缺省的构造函数----------------------------*/ template <class T>CMatrix<T>::CMatrix(){p=new node;p->length=NULL;p->f=0;p->refcnt=1;p->tmppointer=NULL;}/*----------------------------------------定义可扩展构造函数------------------------*/template <class T>CMatrix<T>::CMatrix(int xsize,int ysize,T init){if(xsize<=0||ysize<=0) cout<<"error!!";p=new node;p->length=xsize;p->f=new Vector<T> *[xsize];for(int i(0);i<xsize;i++)p->f[i]=new Vector<T>(ysize,init);p->refcnt=1;p->tmppointer=NULL;}/*------------------------------------定义构造函数----------------------------*/template <class T>CMatrix<T>::CMatrix(int xlength,const Vector<T> *vec){if(xlength<=0) cout<<"error!!";p=new node;p->length=xlength;p->f=new Vector<T> *[xlength];for(int i(0);i<xlength;i++)p->f[i]=new Vector<T>(*vec);}/*------------------------------------定义拷贝的构造函数-------------------------*/ template <class T>CMatrix<T>::CMatrix(CMatrix<T> &x){x.p->refcnt++;p=x.p;}template <class T>CMatrix<T> cpy(CMatrix<T> &v){int mr=v.row();int mc=v.col();CMatrix<T> x(mr,mc);for(int i(0);i<mr;i++)*(x.p->f[i])=*(v.p->f[i]);return x;}/*-----------------------------------定义析构函数-------------------------—*/ template <class T>CMatrix<T>::~CMatrix(){if(--p->refcnt==0){if(p->f!=NULL){int len=p->length;for(int i(0);i<len;i++)delete p->f[i];if(p->tmppointer!=NULL)delete p->tmppointer;delete p->f;}}}/*------------------------------定义函数返回行数-----------------------*/int CMatrix<T>::row() const{return p->length;}/*----------------------------定义函数返回列数----------------------*/template <class T>int CMatrix<T>::col() const{return p->f[0]->dim();}/*----------------------------定义转置的函数-----------------------*/template <class T>void Inver(CMatrix<T> &mat){int m = mat.row();int n = mat.col();CMatrix<T> tmp(n,m);int i, j;for(i=0; i<n; i++){for(j=0; j<m; j++)tmp[i][j]=mat[j][i];}mat=tmp;}/*---------------------------定义重载函数重载赋值操作符号=--------------------*/ template <class T>CMatrix<T> & CMatrix<T>::operator=(const CMatrix<T> &vec){vec.p->refcnt++;if(--p->refcnt==0){int len=p->length;for(int i(0);i<len;i++)delete p->f[i];delete p->f;if(p->tmppointer!=NULL)delete p->tmppointer;delete p;}p=vec.p;return *this;}/*-------------------------定义重载函数重载[]---------------------------*/Vector<T> &CMatrix<T>::operator[](int i){if((i>=0)&&(i<p->length))return *p->f[i];else{cout<<"error"<<endl;return *p->f[0];}}/*--------------------------------定义重载函数重载**------------------*/template<class T>CMatrix<T>::operator T **(){if(p->tmppointer==NULL){int n=row();p->tmppointer=new T *[n];for(int i(0);i<n;i++)p->tmppointer[i]=p->f[i]->begin();}return p->tmppointer;}template <class T>void CMatrix<T>::ReadFromFile()//******************************从文件中读入矩阵{char filename[256];cin>>filename;ifstream infile;// cout<<"****";int row,col;infile.open(filename,ios::in);if(!infile){cout<<"不能打开输入文件!"<<endl;exit(1);};infile>>row>>col;CMatrix<T> v1(row,col,0);// infile>>v1[0][0];// cout<<v1[0][0]<<"*****"<<endl;for(int i(0);i<row;i++)for(int j(0);j<col;j++)infile>>v1[i][j];*this=v1;}/*-----------------------定义函数重载输出《------------------------------*/ template <class T>std::ostream & operator<<(std::ostream & os,CMatrix<T> &v1){// os<<"{"<<endl;Vector<T> **f=v1.begin();// cout<<v1.begin()<<"*&*"<<endl;int len=v1.row();for(int i(0);i<len;i++)os<<*f[i]<<"\n";return os;}/*-------------------------定义函数重载输入---------------------------*/ template <class T>std::istream & operator>>(std::istream & is,CMatrix<T> &v1){int row,col;cout<<"请您分别输入矩阵的行数和列数:\n";is>>row>>col;CMatrix<T> x(row,col,0);cout<<"请输入"<<row<<'*'<<col<<"矩阵\n";for(int i(0);i<row;i++)for(int j(0);j<col;j++)is>>x[i][j];v1=x;return is;}/*--------------------------定义重载函数重载乘法*---------------------------*/ template <class T>CMatrix<T> operator*(CMatrix<T> &m1,CMatrix<T> &m2){int i,j;int m1rows=m1.row();int m1cols=m1.col();int m2rows=m2.row();int m2cols=m2.col();if(m1cols!=m2rows)cout<<"error!"<<endl;CMatrix<T> v(m1rows,m2cols);CMatrix<T> flip(m2cols,m2rows);for(i=0;i<m2rows;i++)for(j=0;j<m2cols;j++)flip[j][i]=m2[i][j];for(i=0;i<m1rows;i++)for(j=0;j<m2cols;j++)v[i][j]=dot_prod(m1[i],flip[j]);return v;}/*----------------------------------定义函数重载数乘（整型，双精度型）-------------------------------*/ CMatrix<int> operator*(const CMatrix<int> &v,int val){CMatrix<int> temp;temp=v;for(int i(0);i<v.p->length;i++)*(temp.p->f[i])=*(v.p->f[i])*val;return temp;}CMatrix<double> operator*(const CMatrix<double> &v,double val){CMatrix<double> temp;temp=v;for(int i(0);i<v.p->length;i++)*(temp.p->f[i])=*(v.p->f[i])*val;return temp;}#endif/*---------------------------------------------------定义几个选择函数----------------------------------------*/void choiceid();//********************************************选择输入矩阵的类型void processint();//*****************************************选择输入矩阵的饿方式void processdouble();//***************************************选择输入矩阵的方式template<class T>void process(CMatrix<T> &cm,CMatrix<T> &cm1,CMatrix<T> &cm2);void main(){cout<<"欢迎您进入并使用矩阵转置和乘法程序\n";cout<<"\t（请您注意本程序对您输入的矩阵的项数不等于\n\t\t您事先设定的矩阵项数时无法识别，请您见量!）\n\n";choiceid();}/*---------------------------------------------------------定义选择函数-----------------------------------------*/void choiceid(){cout<<"^----^请您输入矩阵的类型:\n输入整型请按1\n输入浮点型请按2\n";int choice;cin>>choice;switch(choice){case 1:processint();break;case 2:processdouble();break;default:break;}}void processint(){CMatrix<int> icm(2,2,0),icm1,icm2;cout<<"^----^请您选择输入方式:\n从键盘输入请按1\n从文件输入请按2\n";int choice;while(cin>>choice){switch(choice){case 1:cout<<"请您输入第1个矩阵:\n";cin>>icm1;cout<<"请您输入第2个矩阵:\n";cin>>icm2;process(icm,icm1,icm2);break;case 2:cout<<"输入矩阵1的路径:";icm1.ReadFromFile();cout<<"输入矩阵2的路径:";icm2.ReadFromFile();process(icm,icm1,icm2);break;default:break;}}}void processdouble(){CMatrix<double> icm,icm1,icm2;cout<<"^---------^请您请选择输入方式:\n1.从键盘输入矩阵\n2.从文件输入矩阵\n";int choice;while(cin>>choice){switch(choice){case 1:cout<<"请您输入第1个矩阵:\n";cin>>icm1;cout<<"请您输入第2个矩阵:\n";cin>>icm2;process(icm,icm1,icm2);break;case 2:cout<<"输入矩阵1的路径:";icm1.ReadFromFile();cout<<"输入矩阵2的路径:";icm2.ReadFromFile();process(icm,icm1,icm2);break;default:break;}}}template<class T>void process(CMatrix<T> &cm,CMatrix<T> &cm1,CMatrix<T> &cm2){int choice;double val;cout<<"请您选择对矩阵的操作类型:\n1.两矩阵相乘\n2.矩阵数乘\n3.矩阵转置\n其他键退出\n";while(cin>>choice){switch(choice){case 1:cm=cm1*cm2;cout<<"两矩阵相乘的结果为:\n"<<cm<<endl;cout<<"1.退出\n2.继续\n";cin>>choice;if(choice==1){cout<<"谢谢您的使用！再见！\n";}exit(0);if(choice==2){cout<<"请您选择对矩阵的操作类型:\n1.两矩阵相乘\n2.矩阵数乘\n3.矩阵转置\n其他键退出\n";continue;};break;case 2:cout<<"请您输入要乘的数:\n";cin>>val;cout<<"请您输入需要数乘的矩阵:\n1.矩阵1\n2.矩阵2\n";cin>>choice;switch(choice){case 1:cm=cm1*val;cout<<"矩阵1:\n"<<"\n乘以数"<<val<<"的结果为:\n"<<cm<<endl;cout<<"1.退出\n2.继续\n";cin>>choice;if(choice==1){cout<<"谢谢您的使用！再见！\n";} exit(0);if(choice==2){cout<<"请您选择对矩阵的操作类型:\n1.两矩阵相乘\n2.矩阵数乘\n3.矩阵转置\n其他键退出\n";continue;};break;case 2:cm=cm2*val;cout<<"矩阵2:\n"<<"\n乘以数"<<val<<"的结果为:\n"<<cm<<endl;cout<<"1.退出\n2.继续\n";cin>>choice;if(choice==1){cout<<"谢谢您的使用！再见！\n";} exit(0);if(choice==2){cout<<"请您选择对矩阵的操作类型:\n1.两矩阵相乘\n2.矩阵数乘\n3.矩阵转置\n其他键退出\n";continue;};break;}case 3:cout<<"请您输入需要转置的矩阵:\n1.矩阵1\n2.矩阵2\n";while(cin>>choice){if(choice==1){Inver(cm1);cout<<"转置后矩阵1为："<<'\n';cout<<cm1<<endl;break;}else if(choice==2){Inver(cm2);cout<<"转置后矩阵2为："<<'\n';cout<<cm2<<endl;break;}else cout<<"输入错误,请重新输入!"<<endl;continue;};cout<<"1.退出\n2.继续\n";cin>>choice;if(choice==1){cout<<"谢谢您的使用！再见！\n";}exit(0);if(choice==2){cout<<"请选择对矩阵的操作类型:\n1.两矩阵相乘\n2.矩阵数乘\n3.矩阵转置\n";continue;};default:exit(0);}}}/*--------------------------------------------程序结束了！。
C++课程设计报告--矩阵乘法计算
C++课程设计报告一、题目名称：矩阵乘法计算二、难易等级：A级三、对题目的分析和注释：分析：依次建立两个矩阵空间并按照矩阵乘法规则进行运算。
（矩阵的乘法规则：1、矩阵的乘法运算必须符合m*n的矩阵与n*s的矩阵相乘。
2、第一个矩阵的第i行的元素依次乘以第二个矩阵的第j列元素后结果相加组成生成矩阵第i行第j列元素。
）注释：（1）设计一个矩阵类，将相应的函数和数据封装在类中，简化程序。
（2）修改程序结构，使程序可以反复执行，直至按键选择退出为止。
（3）本程序用数组表示5*5矩阵，将其改为根据输入矩阵的大小动态分配空间[m][n]来放置数据，其中m，n为用户可输入的任意整数。
（4）增加类的构造函数和成员函数，使得矩阵数据既可以用在对象初始化时赋值，也可以通过键盘赋值，还可以通过读取数据文件输入。
（5）用模板的形式改写矩阵数据类型，使得矩阵中的数据既可以是整型数据，也可以是浮点型数据，执行程序时，分别定义两个整型矩阵和两个浮点型矩阵进行乘法验证。
（6）完成矩阵的乘法运算，在运算之前判断这两个矩阵能否满足乘法运算的条件，若不满足，则给出提示信息。
四、所增加功能模块的设计如果要说增加功能的话，自己编的程序里面不多，我只是按照题目要求，设计了一个矩阵类，同时用模板的形式改写矩阵数据类型和运算符的重载。
1、模板的使用我使用了大量的模板，以T为模板参数，通过对T的不同类型的选择实现相应的运算处理。
其中choose1（）函数本是无参函数，为了方便模板化，给其赋以伪参数T，在执行时通过T的取值生成相应的函数模板。
template<class T>void choose1(T){}调用时：switch(sjlx){case 1:{choose1(1);}break;case 2:{choose1(0.0);}break;case 3:{choose1(1e-10);}break;default:cout<<"输入选择错误!!!"<<endl;}2、矩阵类的构造按照课本要求采用二级指针动态开辟内存空间，节省内存使用；其中数据结构如下：Mat-->Mat[0] ----->Mat[0][0] Mat[0][1] ……Mat[0][j]Mat[1] ----->Mat[1][0] Mat[1][1] ……Mat[1][j]::Mat[i] ----->Mat[i][0] Mat[i][1] ……Mat[i][j]实现构造的代码为：template<class T>CMatrix<T>::CMatrix(int row,int col){int i,j;nRow=row,nCol=col;Mat=new T*[nRow];for(i=0;i<nRow;i++){Mat[i]=new T[nCol];}cout<<"请输入数据:\n";for(i=0;i<nRow;i++)for(j=0;j<nCol;j++){cout<<"第["<<i+1<<"]["<<j+1<<"]个数据:";cin>>Mat[i][j];}}3、运算符的重载要实现矩阵间的乘法运算，有必要对其运算符进行重载。
《高级语言程序设计(2)》课程设计报告——矩阵乘法
《高级语言程序设计（2）》课程设计报告1、程序设计说明书【设计题目】矩阵乘法演示程序【问题描述】用java编写一个矩阵乘法演示程序。
主要表现多线程运算的过程。
要求能用图形界面表现出比较形象的过程，两个矩阵数据随机生成，结果矩阵的每个元素各是一个线程的运行结果。
【软件功能】1)定义矩阵类；2)进行矩阵的乘法运算；3)读取用户输入的行数与列数，随机生成矩阵；4)实现GUI界面；5)响应鼠标事件。
【算法思想】输入矩阵的行数、列数后创建可变数组，并对数组赋值，然后用多线程同时计算，每一个线程计算出的结果即为结果矩阵的行元素。
在多线程计算中，每个线程都是用矩阵1的行元素去乘矩阵2的列元素，每一行乘每一列的结果即为结果矩阵的一个元素。
【类的设计】1)类MatrixMultiply：实现GUI，创建数组用来保存矩阵，显示数组；2)内部类MultiplyThread：用多线程实现矩阵乘法。
【用户界面】【程序技巧】1)将实现多线程矩阵乘法的类定义为内部类，减少对象的调用传送参数等；2)数组用ArrayList定义为可变数组；3)矩阵相乘用多线程实现，提高运算效率。
【模块划分及调用关系】主类MatrixMultiply调用内部类MultiplyThread进行多线程矩阵乘法的计算【模块流程图】【运行说明】程序运行后，在对应的文本框内输入相应矩阵的列数和行数，再单击“确定”按钮，即可得到矩阵1和矩阵2的结果；如想进行第二次运算，单击“重置”按钮，然后重复第一次操作即可。
2、程序上机调试报告【语法错误及其排除】一、调用createArray()方法时格式错误，起先为createArray(rows_1,columns_1)，结果不能创建矩阵，最后改为matrix_1 = createArray(rows_1,columns_1)。
二、数组类型定义错误，起先定义为ArrayList，结果生成的可变二维数组行列无法相乘，最后改为ArrayList<ArrayList>。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
华北科技学院课程设计说明书班级: 姓名:学号:课程名称: 汇编语言课程设计课设时间: 2006-12-05 至2006-12-16成绩评定:1、工作量： A（），B（），C（），D（）,F( )2、难易度：A（），B（），C（），D（）,F( )3、答辩情况：基本操作：A（），B（），C（），D（）,F( )代码理解：A（），B（），C（），D（）,F( )4、报告规范度：A（），B（），C（），D（）,F( )5、学习态度：A（），B（），C（），D（）,F( )总评成绩:指导教师:一．课程设计的目的、任务1.课程设计的目的：使学生综合使用所学过的汇编语言程序设计知识，掌握结构化程序设计的基本思路和方法，利用所学的基本知识和技能，发挥自学能力和查找资料的能力，解决稍微复杂的结构化程序设计问题，加深对所学知识的理解与掌握，增强学生利用自己所学知识解决实际问题的能力，为以后的程序开发打下基础。
课程设计的目的和要求：（1）使学生巩固和加强《汇编语言》课程的理论知识。
（2）使学生掌握汇编语言的基本概念、语法、语义和数据类型的使用特点。
（3）使学生掌握汇编语言程序设计的方法及编程技巧，能正确使用汇编语言编写程序。
（3）进一步理解与运用结构化程序设计的思想和方法；学会利用流程图或N-S图表示算法。
（4）使学生掌握调试程序的基本方法及上机操作方法。
（5）掌握书写程设计开发文档的能力，使学生学会撰写课程设计总结报告。
课程设计的思想和方法还可以作为学生做毕业论文时的参考资料。
（6）通过查阅手册和文献资料，培养学生独立分析问题和解决问题的能力。
为学生做毕业设计打好基础。
（7）初步掌握开发一个小型实用系统的基本方法：结合实际应用的要求，使课程设计既覆盖知识点，又接近工程实际需要。
通过激发学习兴趣，调动学生主动学习的积极性，并引导他们根据实际编程要求，训练自己实际分析问题的能力及编程能力，并养成良好的编程习惯。
（8）培养学生的创新能力和创新思维。
学生可以根据指导书和相关文献上的参考算法，自己设计出相应的应用程序。
（9）培养学生良好的程序设计风格。
在实际编程中，为了提高编程质量，对空行、空格和注释均有要求。
学生在课程设计书写代码时，应该严格按要求处理，以便建立良好的程序设计风格。
2.课程设计的题目——矩阵相乘（1）要求：掌握多重循环程序的设计方法，并熟悉有关矩阵的编程原理。
（2）内容：将一个4 X 4 的矩阵与一个4 X 1 的矩阵相乘，将结果存入相应的单元，分别用十进制数、二进制、十六进制形式显示结果。
3.课程设计环境（1）硬件：PC机。
（2）软件：操作系统为64位Windows7，设计语言为MASM FOR WINDOWS 汇编语言集成实验环境。
4.课程设计要求（1）课程设计可采取每人一题，可任选一题进行设计,至少包含五个功能模块。
或者每组完成一个课题，每组成员分工合作完成一个课程设计，每个人的任务不同；（2）可以选择老师提供的参考选题，也可以自选，如果自选，需要将自选题目的详细内容以及实现要求提供给老师，老师批准后方可采用；（3）要求利用结构化程序设计方法以及汇编语言的编程思想来完成系统的设计；（4）要求有欢迎界面、菜单、文件操作，数据使用数组、结构体等均可，键盘操作或鼠标操作均可；（5）模块化程序设计：要求在设计的过程中，按功能定义过程或宏，多个模块化设计可以用文件的形式来实现；（6）学生所选课题必须上机通过，并获得满意的结果；（7）程序书写风格：锯齿型书写格式。
二．软件需求分析和设计（1）需求分析本程序主要实现的功能是一个4*4矩阵与4*1矩阵相乘最后得到一个4*1矩阵，并且要求用三种方式输出这个矩阵，分别是二进制和十六进制和十进制。
并且这个程序要求菜单的选择。
（2）下面就是这个程序的流程图、三． 程序实现说明（介绍程序实现过程，包括关键代码分析（注意：应该限制代码的数量））YY1.矩阵相乘关键代码MUL_AB: ;矩阵相乘MOV DI, 0MOV HH, 0;--------嵌套循环-------------MUL_0:MOV LL, 0;---------------------MUL_1:MOV BX, HH ;HH为空，BX清零ADD BX, HHMOV SI, LL ;LL为空，SI清零ADD SI, LLMOV CX, LA ;将4传给CX;---------------------MUL_2:MOV AX, MA[BX] ;矩阵一的第一个数放进AXMOV DX, MB[SI] ;矩阵二的第一个数放进DXMUL DX ;两数相乘ADD MC[DI], AX ;结果矩阵第一数先放上AXADD BX, 2 ;地址往下移ADD SI, 2 * LB ;地址下移矩阵二列数*2LOOP MUL_2;---------------------ADD DI, 2 ;地址往下移INC LL ;列数加1CMP LL, LB ;比较结果矩阵列数与矩阵二的列数JNZ MUL_1;---------------------ADD HH, LA ;结果矩阵行数CMP HH, HA * LA ;比较结果矩阵行数数与矩阵一的行数与列数的乘积JB MUL_0RET2.十进制转换关键代码PRINT_AX: ;将存在AX中的数按照十进制输出PUSH BXPUSH CXPUSH DXMOV BX, 10MOV CX, 0P_LOP1:MOV DX, 0DIV BX ;直接除以10，余数在DX一次输出一个INC CXPUSH DXCMP AX, 0 ;商存在AX中,接着用来取余数放到DX里面JNZ P_LOP1MOV AH, 2P_LOP2:POP DXADD DL, '0'INT 21HLOOP P_LOP2 ;CX自加多少次，就自减多少次，输出整个数POP DXPOP CXPOP BXRET3.十六进制转换关键代码HSP PROC FAR ;十六进制转换子程序PUSH BXPUSH CXPUSH DXMOV BX,AXMOV CH,04D ;CH初始定义为4ROTATE:MOV CL,04D ;CL初始定义为4ROL BX,CL ;对操作数进行循环左移4次，每执行一次，把最高位移到最低位，同时还把最高位移到CFMOV AL,BLAND AL,0FH ;取AL的低四位ADD AL,30H ;加上30H输出CMP AL,'9' ;AL与9比较JBE PRINT2 ;小于等于就会跳到PRINT2ADD AL,07H ;大于AL加上07H ，变成字母ABCDEFPRINT2:MOV DL,AL ;AL给DL输出出来MOV AH,2INT 21HDEC CH ;ch自减，不为零继续循环上面代码JNE ROTATEMOV AH,2MOV DL,'H'INT 21HPOP DXPOP CXPOP BXRETHSP ENDP4.二进制转换关键代码DSP PROC FAR ;二进制转换子程序PUSH BXPUSH CXPUSH DXMOV BX,AX ;把数值放到BX保护起来，BX中本身放的就是二进制MOV CX,16 ;为循环做准备T: SHL BX,1 ;把BX的值向左移一位，其高位放在CF标志位里JC PRINT4 ;如果高位是1就输出1JNC PRINT5 ;如果高位是0就输出0PRINT4:MOV DL,31H ;把要在屏幕上输出的字符预先放到DL寄存器里，31H表示字符1 MOV AH,2INT 21HJMP LPRINT5:MOV DL,30H ;把要在屏幕上输出的字符预先放到DL寄存器里，31H表示字符0 MOV AH,2INT 21HL:LOOP TMOV AH,2MOV DL,'B'INT 21HPOP DXPOP CXPOP BXRETDSP ENDP5. 运行结果截图菜单截图矩阵一矩阵二和相乘后矩阵截图（十进制）矩阵三十六机制和二进制截图四．程序总结（软件完成情况，有哪些收获，存在哪些不足对课程设计有哪些建议）这次课设我完成的主要是矩阵的相乘和输出矩阵的进制转换，以及光标定位，菜单输出等等功能！这次课设的时间有两周，其实主要完成在最后一周，通过这次试验最大的收获就是看程序一定要耐心，虽然程序是我拼凑而成，但是基本上已经读懂整个程序，途中遇见几个问题，非常感谢老师和同学们的帮助，最终完成了这个程序。
存在的不足之处就是这两个矩阵是固定格式的，不能任意矩阵相乘，希望以后可以改进，这个课设学习了很多，新的知识主要是BOIS功能的调用，主要集中在字体颜色变化和光标的定位，还学到了矩阵相乘中的嵌套循环，这个对于循环反复操作不同的数非常的重要！另外还了解了进制转换的方法，也是利用了循环移位的操作，本来我觉得汇编是个令人头疼的语言，但是你只要紧紧抓住它其中数的变化就行，能够准确定位数的位置及作用，而且还要了解数的及时清零与更新！往往其中很容易混淆的就是数的位置和作用，之前很容易的辨认错误！这次的实验还是学到了很多东西，主要感谢老师和同学的指导，总体上来说，完成了基本课设要求！希望在以后的学习中，也应该有那种细心钻研的精神！源代码：DATA SEGMENT;================菜单的定义===============str1 db '***********************Menu:*******************',13,10mess1 db ' ********1:print the firstarray:***************',13,10mess2 db ' ********2:print the secondarray:**************',13,10mess3 db ' ********3:print the Hexadecimal system array:*',13,10mess4 db ' ********4:print the Binary system array:*******',13,10mess5 db ' ********5:print the Decimal system array:******',13,10mess6 db '*******************END*************************',13,10 length1 equ $-str1STR2 db 'please make your choose:',13,10;-----------------------------array1 DB 'the first array is (4*4):','$'array2 DB 'the second array is (4*1):','$'H DB 'print array1*array2(Hexadecimal system):','$'B DB 'print array1*array2(Binary system):','$'D DB 'print array1*array2(Decimal system):','$';----------------------------MA DW 11, 12, 13, 14 ;定义4*4矩阵MADW 21, 22, 23, 24DW 31, 32, 33, 34DW 41, 42, 43, 44HA EQU 4 ;行数LA EQU 4 ;列数;-----------------------------MB DW 12 ;定义4*1矩阵MBDW 11DW 11DW 11HB EQU 4LB EQU 1;-----------------------------MC DW HA * LB DUP(?) ;定义结果矩阵HC EQU HALC EQU LBHH DW ?LL DW ?;==============宏的定义============== ;--------------光标的初始定义------- cursor macro row,rankmov ah,2mov dh,rowmov dl,rankmov bh,0int 10hendm;回车换行hchh macromov dl, 10mov ah,2int 21hmov dl ,13mov ah,2int 21hendm;字符串输出PRINT macro xmov ah,9lea dx, xint 21hendmDATA ENDS;*********************************** CODE SEGMENTASSUME CS:CODE, DS:DATA START:MOV AX, DATAMOV DS, AX;==========光标和菜单字体颜色设置========== mov al,3mov ah,00hint 10hmov bp,seg str1mov es,bpmov bp,offset str1mov cx,length1mov dx,0mov bl,05h ;菜单红字定义mov al,0cursor 2,15 ;菜单光标初始定义mov ah,13hint 10h;==========================================;---------菜单跳转选项-----------hchhcursor 12,0out1:mov ah,1int 21hcmp al,'1'jz L1cmp al,'2'jz L2cmp al,'3'jz L3cmp al,'4'jz L4cmp al,'5'jz L5jmp EXIT;----------------主程序------------------- L1: PRINT array1HCHHMOV BX, OFFSET MA ;输出第一个矩阵MOV CX, LAMOV DX, HACALL PRINT_MHCHHJMP OUT1L2: PRINT array2HCHHMOV BX, OFFSET MB ;输出第二个矩阵MOV CX, LBMOV DX, HBCALL PRINT_M1CALL huanhangHCHHJMP OUT1L3: PRINT DHCHHCALL MUL_AB ;矩阵相乘MOV BX, OFFSET MC ;结果十进制输出MOV CX, LCMOV DX, HCCALL PRINT_M2HCHHJMP OUT1L4: PRINT HHCHHMOV BX, OFFSET MC ;结果十六进制输出MOV CX, LCMOV DX, HCCALL PRINT_Z2HCHHJMP OUT1L5: PRINT BHCHHMOV BX, OFFSET MC ;结果二进制输出MOV CX, LCMOV DX, HCCALL PRINT_Z3EXIT:MOV AH, 4CHINT 21H;******************************PRINT_M: ;第一个矩阵输出PUSH CXpush ax ;提示文字，并保护寄存器 push dxpop dxpop axPR2:MOV AX, [BX] ;将BX数给AXCALL PRINT_AX ;直接输出一个数（十进制数）CALL TAB_09 ;输出空格ADD BX, 2 ;转到下一个数LOOP PR2POP CX ;根据列判断一行输入多少数据CALL huanhang ;输出一行的数后立即换行DEC DX ;DX自减JNZ PRINT_M ;DX不为零直接跳到上面继续输出余数 RET;******************************PRINT_M1: ;第二个矩阵输出PUSH CXpush axpush dxpop dxpop axPR20:MOV AX, [BX]CALL PRINT_AXCALL TAB_09ADD BX, 2LOOP PR20POP CXCALL huanhang ;输出一列后立即换行DEC DXJNZ PRINT_M1RET;******************************PRINT_M2: ;相乘矩阵后的输出PUSH CXpush axpush dxpop dxpop axPR21:MOV AX, [BX]CALL PRINT_AXCALL TAB_09ADD BX, 2LOOP PR21POP CXCALL huanhang ;输出一列后立即换行DEC DXJNZ PRINT_M2RET;******************************PRINT_AX: ;将存在AX中的数按照十进制输出 PUSH BXPUSH CXPUSH DXMOV BX, 10MOV CX, 0P_LOP1:MOV DX, 0DIV BX ;直接除以10，余数在DX一次输出一个INC CXPUSH DXCMP AX, 0 ;商存在AX中,接着用来取余数放到DX里面 JNZ P_LOP1MOV AH, 2P_LOP2:POP DXADD DL, '0'INT 21HLOOP P_LOP2 ;CX自加多少次，就自减多少次，输出整个数POP DXPOP CXPOP BXRET;******************************huanhang: ;段内换行，去掉这个后会陷于死循环！PUSH AXPUSH DXMOV AH, 2MOV DL, 13INT 21HMOV DL, 10INT 21HPOP DXPOP AXRET;******************************TAB_09: ;TAB功能调用，让矩阵的输出更加规范！PUSH AXPUSH DXMOV AH, 2MOV DL, 9INT 21HPOP DXPOP AXRET;&&&&&&&&&&&&&&&矩阵相乘&&&&&&&&&&&&&&MUL_AB: ;矩阵相乘MOV DI, 0MOV HH, 0;--------嵌套循环-------------MUL_0:MOV LL, 0;---------------------MUL_1:MOV BX, HH ;HH为空，BX清零ADD BX, HHMOV SI, LL ;LL为空，SI清零ADD SI, LLMOV CX, LA ;将4传给CX;---------------------MUL_2:MOV AX, MA[BX] ;矩阵一的第一个数放进AX MOV DX, MB[SI] ;矩阵二的第一个数放进DX MUL DX ;两数相乘ADD MC[DI], AX ;结果矩阵第一数先放上AX ADD BX, 2 ;地址往下移ADD SI, 2 * LB ;地址下移矩阵二列数*2LOOP MUL_2;---------------------ADD DI, 2 ;地址往下移INC LL ;列数加1CMP LL, LB ;比较结果矩阵列数与矩阵二的列数JNZ MUL_1;---------------------ADD HH, LA ;结果矩阵行数CMP HH, HA * LA ;比较结果矩阵行数数与矩阵一的行数与列数的乘积 JB MUL_0RET;%%%%%%%%%%%%%%十六进制输出%%%%%%%%%%%%%%PRINT_Z2: ;十六进制矩阵输出PUSH CXpush axpush dxpop dxpop axprint1:MOV AX, [BX]CALL HSPCALL TAB_09ADD BX, 2LOOP print1 ;第一行输出POP CXCALL huanhang ;输出一列后立即换行DEC DXJNZ PRINT_Z2RETHSP PROC FAR ;十六进制转换子程序PUSH BXPUSH CXPUSH DXMOV BX,AXMOV CH,04D ;CH初始定义为4ROTATE:MOV CL,04D ;CL初始定义为4ROL BX,CL ;对操作数进行循环左移4次，每执行一次，把最高位移到最低位，同时还把最高位移到CFMOV AL,BLAND AL,0FH ;取AL的低四位ADD AL,30H ;加上30H输出CMP AL,'9' ;AL与9比较JBE PRINT2 ;小于等于就会跳到PRINT2ADD AL,07H ;大于AL加上07H ，变成字母ABCDEFPRINT2:MOV DL,AL ;AL给DL输出出来MOV AH,2INT 21HDEC CH ;ch自减，不为零继续循环上面代码JNE ROTATEMOV AH,2MOV DL,'H'INT 21HPOP DXPOP CXPOP BXRETHSP ENDP;%%%%%%%%%%%%%%十六进制输出%%%%%%%%%%%%%%;***************二进制输出***************PRINT_Z3: ;二进制矩阵输出PUSH CXpush axpush dxpop dxpop axprint3:MOV AX, [BX] ;将BX值传给AXCALL DSPCALL TAB_09ADD BX, 2 ;执行一个数地址加2，到下一个数LOOP print3 ;第一行输出POP CX ;CX出栈CALL huanhang ;输出一列后立即换行DEC DX ;DX出栈JNZ PRINT_Z3RETDSP PROC FAR ;二进制转换子程序PUSH BXPUSH CXPUSH DXMOV BX,AX ;把数值放到BX保护起来，BX中本身放的就是二进制MOV CX,16 ;为循环做准备T: SHL BX,1 ;把BX的值向左移一位，其高位放在CF标志位里 JC PRINT4 ;如果高位是1就输出1JNC PRINT5 ;如果高位是0就输出0PRINT4:MOV DL,31H ;把要在屏幕上输出的字符预先放到DL寄存器里，31H表示字符1MOV AH,2INT 21HJMP LPRINT5:MOV DL,30H ;把要在屏幕上输出的字符预先放到DL寄存器里，31H表示字符0MOV AH,2INT 21HL:LOOP TMOV AH,2MOV DL,'B'INT 21HPOP DXPOP CXPOP BXRETDSP ENDP;***************二进制输出***************CODE ENDSEND START。