矩阵运算程序设计
matlab课程设计
matlab课程设计计Matlab应用课程设计任务书学生姓名: 专业班级:指导教师: 工作单位:题目: Matlab矩阵操作设计课程设计目的:《Matlab应用》课程设计的目的是为了让学生熟悉matlab语言，并且利用matlab语言或者函数族进行专业课程理论知识的再现，让学生体会matlab的强大功能，为今后使用matlab语言奠定基础。
课程设计内容和要求利用MATLAB,mathematics对矩阵操作进行设计，具体包括创建(普通、单位、零)矩阵、矩阵加减、矩阵相乘、矩阵的乘方、矩阵除法、矩阵转置、矩阵点乘、求矩阵的特征值和特征向量、矩阵的变形(reshape)、验证如下函数的功能:all、any、find、isempty、isequal、xor。
要求每个学生单独完成课程设计内容，并写出课程设计说明书、说明书应该包括所涉及到的理论部分和充足的实验结果，给出程序清单，最后通过课程设计答辩。
时间安排:所需时序号阶段内容间1 方案设计 1天2 软件设计 2天3 系统调试 1天4 答辩 1天合计 5天指导教师签名: 年月日系主任(或责任教师)签名: 年月日I目录摘要 ..................................................................... . (1)Abstract ............................................................... .............................................. 2 1 要求与基础 ..................................................................... (3)1.1矩阵操作要求 ..................................................................... . (3)1.2 MATLAB基础 ..................................................................... (3)2 矩阵操作 ..................................................................... . (5)2.1矩阵创建 ..................................................................... (5)2.2矩阵加减 ..................................................................... (7)2.3 矩阵相乘 ..................................................................... .. (8)2.4矩阵乘方 ..................................................................... (9)2.5矩阵除法 ..................................................................... .. (11)2.6矩阵转置 ..................................................................... . (12)2.7矩阵点乘 ..................................................................... . (12)2.8求矩阵特征值和特征向量 (13)2.9矩阵变形 ..................................................................... ...................... 14 3 函数功能验证 ..................................................................... (15)3.1Any函数 ..................................................................... .. (15)3.2All函数 ..................................................................... . (16)3.3Find函数 ..................................................................... .. (17)3.4Isequal函数 ..................................................................... . (19)3.5Isempty函数 ..................................................................... .. (20)3.6Any函数 ..................................................................... ....................... 20 4总结和心得 .................................................................................................. 22 5参考文献 ..................................................................... (23)II摘要Matlab集数值计算、符号运算及图形处理等强大功能于一体，是当今国际上公认的最优秀的科技应用软件之一。
matlab程序设计矩阵及其运算
matlab程序设计矩阵及其运算1. 矩阵的定义和表示在matlab中，矩阵是一种常用的数据结构，用于存储和处理多维数据。
矩阵由行和列组成，每个元素都有一个唯一的位置。
在matlab中，可以通过方括号[ ]来定义和表示矩阵。
以下是一些常见的矩阵定义：一维行向量：matlabA = [1 2 3 4 5];一维列向量：matlabB = [1; 2; 3; 4; 5];二维矩阵：matlabC = [1 2 3; 4 5 6; 7 8 9];可以使用size()函数获取矩阵的维度信息，例如：matlab[m, n] = size(C); % m为行数，n为列数2. 矩阵的运算matlab中的矩阵可以进行各种运算，包括基本的加减乘除运算、转置运算、矩阵乘法运算等。
2.1 加法和减法矩阵的加法和减法可以使用+和-运算符进行，例如：matlabA = [1 2 3; 4 5 6; 7 8 9];B = [9 8 7; 6 5 4; 3 2 1];C = A + B; % 矩阵的加法D = A B; % 矩阵的减法2.2 矩阵乘法矩阵乘法在matlab中使用运算符进行，例如：matlabA = [1 2 3; 4 5 6; 7 8 9];B = [9 8 7; 6 5 4; 3 2 1];C = A B; % 矩阵的乘法2.3 转置运算矩阵的转置表示将矩阵的行和列互换，使用'运算符进行，例如：matlabA = [1 2 3; 4 5 6; 7 8 9];B = A'; % A的转置矩阵2.4 矩阵的逆运算矩阵的逆运算是指对于一个可逆矩阵A，存在一个矩阵B，使得A B = B A = I，其中I为单位矩阵。
在matlab中，可以使用inv()函数来求一个矩阵的逆矩阵，例如：matlabA = [1 2; 3 4];B = inv(A); % A的逆矩阵需要注意的是，不是所有的矩阵都有逆矩阵，对于不可逆的矩阵，inv()函数会报错。
4×4_矩阵键盘计算器设计
西华大学课程设计说明书题目4×4 矩阵键盘计算器设计系(部) 电气信息学院专业(班级) 自动化3班姓名学号指导教师胡红平起止日期2012.6.10-2012.6.30计算机接口及应用课程设计任务书系(部)：电气信息学院专业：09自动化指导教师：日期：2012-6-20西华大学课程设计鉴定表摘要近几年来随着科技的飞速发展，单片机的应用正在不断深入，同时带动传统控制检测技术日益更新。
在实时检测和自动控制的单片机应用系统中，单片机往往作为一个核心部件来使用，仅单片机方面的知识是不够的，还应根据具体硬件结合，加以完善。
本任务是个简易得三位数的减法运算，用4×4 矩阵键盘及计算器设计，利用数码管实现255内的减法运算。
程序都是根据教材内和网络中的程序参考编写而成，在功能上还并不完善，限制也较多。
本任务重在设计构思与团队合作，使得我们用专业知识，专业技能分析和解决问题全面系统的锻炼。
关键词：单片机，AT89C51，矩阵键盘，数码管ABSTRACTIn recent years, along with the rapid development of science and technology, the application of SCM is unceasingly thorough, it causes the traditional control test technology increasingly updates. In real-time detection and automatic control of single-chip microcomputer application system, often as a core component to use, only microcontroller aspects of knowledge is not enough, should according to specific hardware combined, and perfects.This task is a simple three digits, subtract with 4 * 4 matrix keyboard and a calculator design, use digital tube realization within the 255 subtract. Program is according to the teaching material and within the network reference and compiled program, on the function is not perfect, restrictions also more. This task focuses on design conception and team cooperation, make us with professional knowledge, professional skills to analyze and solve problems of full system exercise.Keywords:Single-chip，AT89C51，Matrix keyboard，digital tube目录摘要 (I)ABSTRACT (II)第1章课题概述 (1)1.1 课题概述 (1)1.2 课题要求 (2)第2章系统设计 (3)2.1 设计思路 (3)2.2 框图设计 (3)2.3 知识点 (3)2.4 硬件设计 (4)2.4.1 电路原理图 (4)2.4.2 元件选择 (5)2.4.3 PCB制版及效果 (9)2.5 软件设计 (10)2.5.1 程序流程图 (10)2.6 系统仿真及调试 (11)2.6.1 硬件调试 (11)2.6.2 软件调试 (11)2.6.3 软硬件调试 (11)结论 (11)参考文献 (14)附录 (15)第1章课题概述1.1 课题概述随着当今时代的电子领域的发展，尤其是自动化的控制领域，传统的分立元件或数字逻辑电路构成的控制系统正被智能化的单片机所取代。
matlab程序设计矩阵及其运算
矩阵及其运算
1、特征值分解 由以前学过的知识，我们已经了解到在MATLAB是 应用函数eig来解决的。但是应用到特征值分解的部分， 需要在形式上作一定的变化，其使用的格式如下： [V,D]＝eig（X）命令生成两个矩阵V和D，其中V是以 矩阵X的特征向量作为列向量组成的矩阵，D是由矩阵X 的特征值作为主对角线元素构成的对角矩阵，使得满足 关系式X*V=V*D。
矩阵及其运算
randn（M,N）：表示生成M×N阶随机矩阵，生成 的矩阵的元素值在服从正态分布N（0,1）。 例十五 随机矩阵的生成
矩阵及其运算
4 魔术矩阵的生成 魔术矩阵是一个经常遇到的矩阵，它是一个方阵，特 点是每一行、每一列以及每一主对角线元素之和都同。 在MATLAB中，用函数magic来生成。其格式如下： magic（N）：表示生成N×N阶的魔术矩阵，使矩 阵的每一行、每一列以及每一主对角线元素之和都同。 其中N>0,N=2除外。 例十五 魔术矩阵的生成。
矩阵及其运算
四 矩阵的分解运算 MATLAB的数学处理能力之所以强大，很大一部分 的原因就是它的矩阵函数功能的扩展。矩阵分解在数值 分析和科学研究中有着重要的地位。常用的分解方法有 以下几种：三角分解（lu）、正交分解（qr）、特征值 分解（eig）和奇异值分解（svd）。我们这里主要介绍特 征值分解。
矩阵及其运算
reshape（X,[M,N,p,…]）：该命令与上个 reshape（X,M,N,p,…）命令的效果一致。 例十一：
矩阵及其运算
2 矩阵的变向 矩阵的变向包括对矩阵进行旋转、上下翻转、左右翻 转以及对指定的维进行翻转。分别由函数rot90、 flipud、fliplr和flipdim来实现。具体用法如下： rot90（A）：命令返回矩阵A按逆时钟方向旋转90度 所得的矩阵。 rot90（A，K）：命令返回矩阵A按逆时针方向旋转 90×K度所得的矩阵。（K=±1, ±2,…）。 flipud（X）：命令将矩阵X上下翻转。
矩阵乘法(分治法)
算法设计与分析实验报告二、模型拟制、算法设计和正确性证明：设A和B是两个n*n阶矩阵，求他们两的成绩矩阵C。
这里假设n是2的幂次方；A和B是两个n*n的矩阵，他们的乘积C=AB也是一个n*n的矩阵，矩阵C中的元素C[i][j]定义为C[i][j]= ，则每计算一个C[i][j]，需要做n次乘法和n-1次加法。
因此计算C的n2个元素需要n3次乘法和n3- n2次加法。
因此，所需的时间复杂度是O(n3)。
但是使用分治法可以改进算法的时间复杂度。
这里，假设n是2的幂。
将矩阵A,B,C中每一矩阵都分成4个大小相等的子矩阵，每个子矩阵是（n/2）*（n/2）的方阵。
由此，可将方阵C=AB重写为因此可得：C11=A11B11+A12B21C12=A11B12+A12B22C21=A21B11+A22B22C22=A21B12+A22B22这样就将2个n阶矩阵的乘积变成计算8个n/2阶矩阵的乘积和4个n/2阶矩阵的加法。
当n=1时，2个1阶方阵的乘积可直接算出，只需要做一次乘法。
当子矩阵阶n>1时，为求两个子矩阵的乘积，可继续对两个子矩阵分块，直到子矩阵的阶为1。
由此，便产生了分治降阶的递归算法。
但是这个算法并没有降低算法的时间复杂度。
由strassen矩阵乘法，M1=A11（B12-B22）M2=（A11+A12）B22M3=（A21+A22）B11M4=A22（B21-B11）M5=（A11+A22）（B11+B22）M6=（A12-A22）（B21+B22）M7=(A11-A21)(B11+B12)C11=M5+M4-M2+M6C12=M1+M2C21=M3+M4C22=M5+M1-M3-M7四、程序实现和测试过程：程序测试过程（1）测试过程（2）源程序：#include<iostream>#include<math.h>#include<fstream>using namespace std;ifstream infile("123.txt",ios::in);void Input(int n,int **A){//infile>>n;for(int i=0;i<n;i++)for(int j=0;j<n;j++)infile>>A[i][j];}void Output(int n,int **A){for(int i=0;i<n;i++){for(int j=0;j<n;j++)cout<<A[i][j]<<'\t';cout<<endl;}cout<<endl;}void Divide(int n,int **A,int **A11,int **A12,int **A21,int **A22) {int i,j;for(i=0;i<n;i++)for(j=0;j<n;j++){A11[i][j]=A[i][j];A12[i][j]=A[i][j+n];A21[i][j]=A[i+n][j];A22[i][j]=A[i+n][j+n];}}void Unit(int n,int **A,int **A11,int **A12,int **A21,int **A22) {int i,j;for(i=0;i<n;i++)for(j=0;j<n;j++){A[i][j]=A11[i][j];A[i][j+n]=A12[i][j];A[i+n][j]=A21[i][j];A[i+n][j+n]=A22[i][j];}}void Sub(int n,int **A,int **B,int **C){int i,j;for(i=0;i<n;i++)for(j=0;j<n;j++)C[i][j]=A[i][j]-B[i][j];}void Add(int n,int **A,int **B,int **C){int i,j;for(i=0;i<n;i++)for(j=0;j<n;j++)C[i][j]=A[i][j]+B[i][j];}void Mul(int n,int **A,int **B,int **M){if(n==1)M[0][0]=A[0][0]*B[0][0];else{n=n/2;int **A11,**A12,**A21,**A22;int **B11,**B12,**B21,**B22;int **M11,**M12,**M21,**M22;int **M1,**M2,**M3,**M4,**M5,**M6,**M7;int **T1,**T2;A11=new int*[n];A12=new int*[n];A21=new int*[n];A22=new int*[n];B11=new int*[n];B12=new int*[n];B21=new int*[n];B22=new int*[n];M11=new int*[n];M12=new int*[n];M21=new int*[n];M22=new int*[n];M1=new int*[n];M2=new int*[n];M3=new int*[n];M4=new int*[n];M5=new int*[n];M6=new int*[n];M7=new int*[n];T1=new int*[n];T2=new int*[n];int i;for(i=0;i<n;i++){A11[i]=new int[n];A12[i]=new int[n];A21[i]=new int[n];A22[i]=new int[n];B11[i]=new int[n];B12[i]=new int[n];B21[i]=new int[n];B22[i]=new int[n];M11[i]=new int[n];M12[i]=new int[n];M21[i]=new int[n];M22[i]=new int[n];M1[i]=new int[n];M2[i]=new int[n];M3[i]=new int[n];M4[i]=new int[n];M5[i]=new int[n];M6[i]=new int[n];M7[i]=new int[n];T1[i]=new int[n];T2[i]=new int[n];}Divide(n,A,A11,A12,A21,A22);Divide(n,B,B11,B12,B21,B22);// cout<<"A11,A12,A21,A22"<<endl;// Output(n,A11);Output(n,A12);Output(n,A21);Output(n,A22); Sub(n,B12,B22,T1);// cout<<"B12-B22"<<endl;// Output(n,T1);Mul(n,A11,T1,M1);Add(n,A11,A12,T2);Mul(n,T2,B22,M2);Add(n,A21,A22,T1);Mul(n,T1,B11,M3);Sub(n,B21,B11,T1);Mul(n,A22,T1,M4);Add(n,A11,A22,T1);Add(n,B11,B22,T2);Mul(n,T1,T2,M5);Sub(n,A12,A22,T1);Add(n,B21,B22,T2);Mul(n,T1,T2,M6);Sub(n,A11,A21,T1);Add(n,B11,B12,T2);Mul(n,T1,T2,M7);Add(n,M5,M4,T1);Sub(n,T1,M2,T2);Add(n,T2,M6,M11);Add(n,M1,M2,M12);Add(n,M3,M4,M21);Add(n,M5,M1,T1);Sub(n,T1,M3,T2);Sub(n,T2,M7,M22);Unit(n,M,M11,M12,M21,M22);}}int main(){int n;cout<<"please input number n"<<endl;cin>>n;int **A,**B,**C;A=new int*[n];B=new int*[n];C=new int*[n];for(int i=0;i<n;i++){A[i]=new int[n];B[i]=new int[n];C[i]=new int[n];}Input(n,A);cout<<"A Matrix is"<<endl;Output(n,A);Input(n,B);cout<<"B Matrix is"<<endl;Output(n,B);Input(n,C);//Output(n,C);Mul(n,A,B,C);cout<<"The Product of A and B is"<<endl;Output(n,C);// cout<<n<<endl;in();return 0;}1 / 1。
《MATLAB程序设计教程(第二版)》第2章 MATLAB矩阵及其运算
例2-5 将101~125等25个数填入一个5行5列的表格中，
使其每行每列及对角线的和均为565。 M=100+magic(5)
(2) 范得蒙矩阵
范得蒙(Vandermonde)矩阵最后一列全为1，倒数 第二列为一个指定的向量，其他各列是其后列与
倒数第二列的点乘积。可以用一个指定向量生成
一个范得蒙矩阵。在MATLAB中，函数vander(V) 生成以向量V为基础向量的范得蒙矩阵。例如， A=vander([1;2;3;5])即可得到上述范得蒙矩阵。
对于比较大且比较复杂的矩阵，可以为它专门 建立一个M文件。下面通过一个简单例子来说明
如何利用M文件创建矩阵。
例2-2 利用M文件建立MYMAT矩阵。
(1) 启动有关编辑程序或MATLAB文本编辑器，并 输入待建矩阵：
(2) 把输入的内容以纯文本方式存盘(设文件名为
mymatrix.m)。 (3) 在MATLAB命令窗口中输入mymatrix，即运 行该M文件，就会自动建立一个名为MYMAT的 矩阵，可供以后使用。
是维数为0。
4．改变矩阵的形状
reshape(A,m,n)函数在矩阵总元素保持不变的前提下，
将矩阵A重新排成m×n的二维矩阵。
注意：
在MATLAB中，矩阵元素按列存储，即首先存储矩
阵的第1列元素，然后存储第2列元素，……，一直 到矩阵的最后一列元素。reshape函数只是改变原矩 阵的行数和列数，即改变其逻辑结构，但并不改变 原矩阵元素个数及其存储结构。
load 文件名 [变量名表] [-ascii]
其中，文件名可以带路径，但不需带扩展名.mat，
命令隐含一定对.mat文件进行操作。变量名表中 的变量个数不限，只要内存或文件中存在即可，
矩阵计算器
用Matlab GUI编写一个简单的矩阵计算器摘要：矩阵是线性代数的一个主要内容，又是解决众多问题的主要工具。
而矩阵运算是矩阵理论的基本内容之一。
目前，普通的计算器只能够进行数的运算，而不能够实现矩阵的运算。
随着科技的不断发展，人们对矩阵的运用也会不断的增多。
因此，制作一个矩阵计算器对当今科技的发展有一定的推动作用。
关键字：矩阵运算、Matlab GUI、计算器正文：一、矩阵的相关知识在数学上，矩阵是指纵横排列的二维数据表格，最早来自于方程组的系数及常数所构成的方阵。
这一概念由19世纪英国数学家凯利首先提出。
矩阵，是由个数组成的一个行列的矩形表格，通常用大写字母表示，组成矩阵的每一个数，均称为矩阵的元素，通常用小写字母其元素表示，其中下标都是正整数，他们表示该元素在矩阵中的位置。
比如，或表示一个矩阵，下标表示元素位于该矩阵的第行、第列。
元素全为零的矩阵称为零矩阵。
当一个矩阵的行数与烈数相等时，该矩阵称为一个阶方阵。
对于方阵，从左上角到右下角的连线，称为主对角线；而从左下角到右上角的连线称为付对角线。
若一个阶方阵的主对角线上的元素都是，而其余元素都是零，则称为单位矩阵，记为，即：。
如一个阶方阵的主对角线上（下）方的元素都是零，则称为下（上）三角矩阵，例如，是一个阶下三角矩阵，而则是一个阶上三角矩阵。
今后我们用表示数域上的矩阵构成的集合，而用或者表示数域上的阶方阵构成的集合。
矩阵是高等代数学中的常见工具，其中的一个重要用途是解线性方程组。
线性方程组中未知量的系数可以排成一个矩阵，加上常数项，则称为增广矩阵。
另一个重要用途是表示线性变换，即是诸如f(x) 4x之类的线性函数的推广。
同时也常见于统计分析等应用数学学科中。
在物理学中，矩阵于电路学、力学、光学和量子物理中都有应用；计算机科学中，三维动画制作也需要用到矩阵。
矩阵的运算是数值分析领域的重要问题。
将矩阵分解为简单矩阵的组合可以在理论和实际应用上简化矩阵的运算。
Matlab程序设计第2章矩阵及其运算
2.2.2 创建二维数组 方法2：用函数生成特殊矩阵
函数 zeros (全零阵) 格式 B = zeros(n) B = zeros(m,n) 函数 ones (全1阵) 格式 B = ones(n) B = ones(m,n) 函数 eye(单位矩阵) 格式 B = eye(n) B = eye(m,n) %生成n×n全零阵 %生成m×n全零阵
2.2.4二维数组的寻访与赋值
判断数组维数和大小 1) 判断数组维数的指令：ndims 2) 判断数组大小的指令：size 例如：上例中数组A的维数和大小分别为
>> An=ndims(A), As=size(A) An = 2 As = 3 3
表示数组A大小的行数组的长度 (As的长度) 等于数组A的 维数 (An)，length(As)=An 数组A的长度指最长维的长度：length(A)=max(As)。
注意： 1) 子数组寻访取决于 x ( index )中的下标index。 2) 下标 index 可以是单个数值或数组，但是 index 的元素取 值必须在 [ 1 , end ] 的范围内。end 为数组最大下标。 3) 子数组赋值时，注意被赋值的子数组长度与送入的数组长 度一致。
2.2.4二维数组的寻访与赋值
%生成n×n全1阵 %生成m×n全1阵 %生成n×n单位阵 %生成m×n单位阵
2.2.2 创建二维数组 方法2：用函数生成特殊矩阵
函数 randn 格式 y = randn(n) y = randn(m,n) %生成n×n正态分布随机矩阵 %生成m×n正态分布随机矩阵
产生均值为0.6，方差为0.1的4阶矩阵 >> mu=0.6; sigma=0.1; >> x=mu+sqrt(sigma)*randn(4) x= 0.8311 0.7799 0.1335 1.0565 0.7827 0.5192 0.5260 0.4890 0.6127 0.4806 0.6375 0.7971 0.8141 0.5064 0.6996 0.8527
矩阵相乘-并行算法
并行处理技术课程设计分析报告课程设计题目矩阵相乘并行算法设计廖杰学号M*********专业计算机技术任课教师金海石所在学院计算机科学与技术学院报告提交日期2014-01-13一、实验目的1、学习使用集群；2、掌握并行处理或分布计算的编程方法；3、学会以并行处理的思想分析问题。
二、实验要求1、自行生成矩阵作为算法的输入；2、使用并行处理技术编程，例如：MPI、OpenMP、MR；3、矩阵大小至少为1000*1000；4、加速比越大成绩越高。
三、实验容3.1、矩阵的划分：对于矩阵相乘的并行算法，可以有三种：对矩阵按行划分、按列划分和棋盘式分块划分。
和按行或列划分相比，棋盘式划分可以开发出更高的并行度。
对于一个n×n的方阵，棋盘划分最多可以使用n^2个处理器进行并行计算，但使用按行或列分解最多可以使用n个。
对矩阵相乘采用棋盘式划分的算法通常称作Cannon算法。
A）行列划分又叫带状划分（Striped Partitioning），就是将矩阵整行或者整列分成若干个组，每个组指派给一个处理器。
以下图所例为4个CPU，8×8矩阵的带状划分。
在带状划分情况下，每个CPU将会均匀分配到2行(列)数据。
8×8矩阵变成了一个1×4或4×1的分块矩阵，每个CPU所属的分块矩阵大小为8×2或2×8。
B）棋盘划分就是将矩阵分成若干个子矩阵，每个子矩阵指派给一个处理器，此时任一处理器均不包含整行或者整列。
以下图所示即为4个处理器情况下8×8矩阵的棋盘划分，其中处理器阵列为2×2，每个处理器分配到的子矩阵大小为4×4。
矩阵划分成棋盘状可以和处理器连成二维网孔相对应。
对于一个n×n维矩阵和p×p的二维处理器阵列，每个处理器均匀分配有（n/p）×(n/p)=n^2/p^2个元素。
使用棋盘式划分的矩阵相乘算法一般有两种，Cannon算法和Summa算法。
C++课设1、设计一个能够实现n×n矩阵操作的类2、计算器程序
课程设计任务书目录PART I1 需求分析 (2)2 算法基本原理 (2)3 类设计 (3)4 详细设计 (4)4.1类的接口设计 (4)4.2类的实现 (5)4.3主函数设计 (11)5 运行结果与分析 (12)5.1程序运行结果 (12)5.2运行结果分析 (14)PART Ⅱ1 需求分析 (24)2 算法基本原理 (24)3 类设计 (14)4 详细设计 (15)4.1类的实现 (15)4.2主函数设计 (19)5 运行结果与分析 (27)5.1程序运行结果 (27)5.2运行结果分析 (27)6 参考文献 (15)PART I1 需求分析矩阵是线性代数里一个重要的概念，在这里采用C++语言实现一个简单的n ×n矩阵类，类中包括一些简单的运算等操作具体要求如下：（1）使用构造函数完成方阵的初始化赋值（动态内存分配）；（2）使用析构函数完成矩阵动态内存的释放；（3）重载加法运算符＋，实现两个矩阵的和；（4）重载加法运算符－，实现两个矩阵的差；（5）重载加法运算符*，实现两个矩阵的积；（6）重载加法运算符=，实现两个矩阵之间的赋值；（7）使用函数实现矩阵的转置；（8）使用函数求矩阵中的最大值；（9）使用函数求矩阵中的最小值；（10）添加函数Det以得到矩阵对应行列式的值；（11）重载加法运算符<<，实现矩阵按照行列的格式输出；（12）编写一个主函数测试上述功能。
2 算法基本原理矩阵进行加法，减法，乘法运算时，必须满足两个矩阵阶数相同的条件。
加法，减法计算是把矩阵对应的各行各列的每一对数值分别进行加减法运算，结果组成一个新的同阶矩阵。
矩阵乘法是这样定义的，只有当矩阵A的列数与矩阵B的行数相等时A×B才有意义。
一个m×n的矩阵a（m,n)左乘一个n×p的矩阵b（n,p)，会得到一个m×p的矩阵c（m,p)，满足矩阵乘法满足结合率，但不满足交换率3 类设计从上面的算法分析可以看到，本设计面临的计算问题的关键是矩阵运算。
矩阵的转置和乘法课程设计程序
矩阵的转置和乘法课程设计程序#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);}}}/*--------------------------------------------程序结束了！。
数据结构程序设计-矩阵的运算
二．概要设计：
1、抽象数据类型定义如下： ADT SparseMatrix{ 数据对象D：D=｛aij|i=1,2,3…,m;j=1,2,3…,n; ai ∈ElemSet,m和n分别称为矩阵的行数和列数｝ 数据关系R： R={Row,Col} Row={<ai,j,ai,j+1>|1≤i≤m, 1≤j≤n-1} Col={<ai,ai+1,j>|1≤i≤m-1, 1≤j≤n} 基本操作 本程序中，用三元组顺序表作为存储结构。 (1)、CreatSMatrix (TSMatrix &M) 操作结果：创建矩阵M。 (2)、AddSMatrix(TSMatrix A,TSMatrix B,TSMatrix &C,int n) 初始条件：矩阵A和B的行数和列数对应相等。 操作结果：求矩阵A、B的和C=A+B。 (3)、SubMatrix (TSMatrix *a,TSMatrix *b) 初始条件：矩阵A和B的行数和列数对应相等。 操作结果：求矩阵A、B的和C=A+B。 (4)、MultiplicationMatrixPow (TSMatrix *a,TSMatrix *b,TSMatrix *c) 初始条件：矩阵A和B的行数和列数匹配 操作结果：求矩阵A、B的和C=A*B。 (5) OutputSMatrix(TSMatrix M) 初始条件：矩阵M已存在 操作结果：输出矩阵M 2、 本程序包含5个模块
for(i=1;i<=M->mu;i++)//输出矩阵 { for(j=1;j<=M->nu;j++) printf("%5d",a[i][j]); printf("\n"); } } //*************矩阵的求和运算*****************// int AddSMatrix(TSMatrix *M,TSMatrix *N,TSMatrix *Q)//求 采用三元组顺序表存储表示的稀疏矩阵M和N的和,结果赋给矩阵Q { int i,j,p,q,x=0,y=0; if((M->mu<=0)||(M->nu<=0)||(M->tu<=0)||(N->mu<=0)||(N>nu<=0)||(N->tu<=0))//判断行数列数非零元素个数是否符合匹配 return ERROR; if(M->mu!=N->mu||M->nu!=N->nu)//判断A与B的行列数 是否相等的 return ERROR; Q->mu=M->mu;//矩阵Q的初始化 Q->nu=M->nu; Q->tu=0; for(i=1;i<=Q->mu;i++) { for(j=1;j<=Q->nu;j++)//寻找矩阵M,N中非零元素相等 的行列 { for(p=1;p<=M->tu;p++)//求矩阵M行列中所对应的 非零元素的值 赋值给X { if((i==M->data[p].row)&&(j==M->data[p].col))// 如果i是矩阵M中非零元素行，j是其列 { x=M->data[p].e;
矩阵连乘实验报告
程序设计报告、 我保证没有抄袭别人作业!1. 题目内容问题：n 个矩阵<A1, A2, ..., An>相乘，称为‘矩阵连乘’，如何求积？如何确定运算顺序，可以使计算量达到最小化。
2. 算法分析枚举显然不可，如果枚举的话，相当于一个“完全加括号问题”，次数为卡特兰数,卡特兰数指数增长，必然不行。
于是进过分析，采用动态规划算法： 1 找出最优解的性质，并刻划其结构特征。
2 递归地定义最优值。
3 以自底向上的方式计算出最优值。
4 根据计算最优值时得到的信息，构造最优解。
于是动态规划的思想可以描述如下：将矩阵连乘积j i i A A A ...1+，简记为[]j i :A ，这里j i <, i A 是i i p p 1⨯-的矩阵。
1、考察计算[]j i :A 的最优计算次序。
设这个计算次序在矩阵k A 和1+k A 之间将矩阵链断开，j k <<i ，则其相应完全加括号方式为()()j k k k i i A A A A A ......A 211+++。
2、计算量：[]k i :A 的计算量加上[]j k A :1+的计算量。
再加上[]k i :A 和[]j k A :1+相乘的计算量[][]j k i p p p j k m k i m j i 1],1[,,m -+++=。
3、问题：找到一个k ，使得],[m j i 最优。
4、矩阵连乘积计算次序问题的最优解包含着其子问题的最优解。
5、基于最优子结构，可以从子问题的最优解构造原问题的最优解矩阵连乘问题的任何最优解必包含其子问题的最优解。
于是将问题分为两个子问题AiAi+1… Ak and Ak+1Ak+2…Aj);求子问题的最优解；合并子问题的最优解。
6、根据子问题的最优解可以递归地定义原问题的最优解a. 子问题：确定矩阵连乘问题的子问题的形式为j i i A A ...A 1+,for 1≤i ≤j ≤n.b.设计算[]j i :A ， 1≤i ≤n ，所需要的最少数乘数 ，乘次数],[m j i ，则原问题（计算A1..n ）的最优值为]n ,[m i 。
matlab矩阵运算
矩阵操作
改变矩阵的形状： 改变矩阵的形状：reshape
reshape(A,m,n): 将矩阵元素按 列方向 进行重组 重组后得到的新矩阵的元素个数 必须与原矩阵元素个数相等！ 必须与原矩阵元素个数相等！
矩阵操作
查看矩阵的大小： 查看矩阵的大小：size
size(A) 列出矩阵 A 的行数和列数 size(A,1) 返回矩阵 A 的行数 size(A,2) 返回矩阵 A 的列数
例： 解下列方程组
x + y =1 （） 1 (定解方程组） x − y = 4 x + 2y + z =1 （2） （不定方程组） 3 x − 2 y + z = 4 x + 2y =1 （3） 3 x − 2 y = 4 (超定方程组） x− y =2 x + 2y =1 （4） （奇异方程组） 2 x + 4 y = 2
矩阵的 Kronecker 乘积
乘积的定义 矩阵 Kronecker 乘积的定义
设A是n×m矩阵，B是p×q矩阵，则A与B的kronecker乘积为： a11 B a12 B … a1m B a B a B … a B 22 2m C = A ⊗ B = 21 ⋯ ⋯ ⋯ ⋯ an1 B an 2 B … anm B
矩阵基本运算
矩阵的除法： 、 矩阵的除法：/、\ 右除和左除 除法
若 A 可逆方阵，则 B/A <==> A 的逆右乘 B <==> B*inv(A) A\B <==> A 的逆左乘 B <==> inv(A)*B 通常，矩阵除法可以理解为 X=A\B <==> A*X=B X=B/A <==> X*A=B 行数相等时即可进行 时即可进行左除 当 A 和 B 行数相等时即可进行左除 当 A 和 B 列数相等时即可进行右除 列数相等时即可进行右除 时即可进行
数据结构课程设计矩阵的运算
数据结构课程设计报告题目：专业：班级：学号：姓名：指导老师：时间：一、课程设计题目及所涉及知识点设计题目是“矩阵的运算”，所涉及的知识点主要是：1、数据结构中的对于结构体的定义，用typedef struct来实现，根据所设计的问题在结构体里面定义数据类型及其变量，用define定义数组的大小，然后利用typedef 来实现对于变量的未知类型确定正确的类型。
2、利用数组的形式来储存数据，在实现不同操作过程中，有的用一维结构体数组（三元组顺序表）来存储，有的用二维数组来储存。
3、转置的过程中利用的是快速转置的方法，附设了num和cpot两个辅助变量。
4、矩阵的加法、减法、乘法、逆运算的基本算法方式。
5、通过调用每个函数，来实现每个算法的功能。
二、课程设计思路及算法描述设计思路：1、首先是对于转置的考虑，要运用快速转置的方法实现，必须用三元组顺序表来储存数据，所以在第一个结构体中存在int类型的行数（mu）列数（nu）以及非零元素的个数（tu）；然后第二个结构体中分别有非零元素的行下标（i）、列下标（j）和元素数值（e），最后在第一个结构体中实现对第二个结构体成为数组结构体类型。
2、对于其余加法、减法、乘法和逆运算则是运用另一个结构体来实现，里面只有矩阵的行数、列数和一个二维数组（用float来定义类型）。
3、在main函数里面，来实现对于数据的输入操作，利用if语句进行选择来执行操作，利用do……while语句来实现功能的循环操作。
4、分五个函数调用分别来实现转置、加法、乘法、和逆运算，每个里面都有最终输出结果的方式。
算法1：矩阵的转置输入：mu中存放矩阵的行数，tu存放矩阵的列数，i接收行下标的数值，j接收列下标的数值，e来存储数据。
输出：转置后的新矩阵。
输入两行两列数据，在第二行第一列中有个数据为12，其余都为0，则输出的结果为第一行第二列数据为12，其余为0。
算法2：矩阵的加法运算输入：i中存放矩阵的行数，j中存放矩阵的列数，二维数组b中存放每个数据。
第二章 矩阵运算
据全下标换算出单下标。 据单下标换算出全下标。
广西大学电气工程学院
Matlab程序设计
“逻辑1”标识
所谓“逻辑1”标识 法是：通过与A同样大小的 逻辑数组L中“逻辑值1”所在的位置，指出A中 元素的位置。 L的元素或是0或是1，它是“逻辑数组(Logical Array)”。是一种特殊的数据类型。 例
（3）定数线性采样法
在设定的“总点数”下，均匀采样生成一维“行”数组。 – 通用格式：x=linspace(a,b,n) [说明]该指令生成（1 ×n）数组，其作用与x=a:(b-a)/(n-1):b同。
–
广西大学电气工程学院
Matlab程序设计
一维数组的子数组寻访和赋值
例1：子数组的寻访（Address）。 例2：子数组的赋值（Assign）。
其显示结果是一样的。
广西大学电气工程学院
Matlab程序设计
特殊矩阵(P42)
非数NaN “空”数组（空阵） 全 0阵 单位阵 全 1阵 随机阵 其他特殊矩阵（表2-6）
广西大学电气工程学院
Matlab程序设计
非数NaN
按IEEE规定，0/0，∞/∞，0×∞等运算都会产生非数 （Not a Number）。该非数在MATLAB中用NaN或 nan记述。 根据IEEE数学规范，NaN具有以下性质：
A.^n
A.^p p.^A A+B A-B
A^n
A^p p^A A+B A-B
Matlab程序设计
数组运算和矩阵运算指令对照汇总（二）
数 指 令 组 运 含
对应元素相乘 A的元素被B的对应元素除 （一定与上相同） 以自然数e为底，分别以A的 元素为指数，求幂 对A的各元素求对数 对A的各元素求平方根 求A各个元素的函数值。f(.) 表示为上节所列各函数 A、B阵对应元素间的关系 运算。#代表关系运算符
矩阵运算实验报告
实验报告--矩阵运算一．实验目的。
1.通过实践加强对程序设计语言课程知识点的理解和掌握，培养对课程知识综合运用能力、实际分析问题能力及编程能力，养成良好的编程习惯。
2.通过实践进一步领会程序设计的特点和应用，提高运用C++ 语言以及面向对象知识解决实际问题的能力。
3.通过实践掌握用C++ 语言编写面向对象的实用程序的设计方法，对面向对象方法和思想增加感性的认识；4.学会利用C++程序设计语言编写出一些短小、可靠的Windows实用程序，切实提高面向对象的程序设计能力。
为后续的相关课程的学习打下基础。
二．实验要求。
1.学会建立模板类；2.实现矩阵的“加”、“减”、“乘”、“数乘”、“转置” ；3.动态内存分配并用随机数填充；4.注意“加”、“减”、“乘” 要进行条件的判断；三．设计思路。
3.1算法基本流程1)获取用户输入的矩阵1的行数和列数,动态生成一个一维数组2)利用随机数生成数组成员,并利用两个循环输出数组,使其符合矩阵的格式3)矩阵2同矩阵1的处理方法4)通过两个矩阵的行数和列数比较来判断能否进行加减乘等运算,如不能,输出相关信息5)如能够进行计算,则利用数组进行相应运算,并按照正确格式输出6)通过改变一维数组中元素的顺序来实现转置并输出3.2算法流程图四．基本界面。
五．关键代码。
5.1关键类的声明class CMatrixclass{public:CMatrixclass(){int m_Row = 0; //行int m_Col = 0; //列m_pElements = NULL; //一维数组};virtual ~CMatrixclass(){delete [] m_pElements;}public:int m_Row;int m_Col;int * m_pElements;};5.2关键函数代码void CMyView::OnCHECKadd(){m_nums.SetCheck(0);m_combine.SetCheck(0);m_subtrict.SetCheck(0);}void CMyView::OnCHECKsubtrict(){m_add.SetCheck(0);m_combine.SetCheck(0);m_nums.SetCheck(0);}void CMyView::OnCHECKcombine(){m_add.SetCheck(0);m_nums.SetCheck(0);m_subtrict.SetCheck(0);}void CMyView::OnCHECKnums(){m_add.SetCheck(0);m_combine.SetCheck(0);m_subtrict.SetCheck(0);}void CMyView::OnBUTTONcompute(){UpdateData(TRUE);// TODO: Add your control notification handler code hereif(m_add.GetState()==1){if(op1->imax!=op2->imax||op1->jmax!=op2->jmax||op1==NULL||op2==NU LL){m_result="行数列数不等无法相加!";}else{matrix<int> c(op1->imax,op1->jmax);c=*op1+*op2;m_result="matrix1+matrix2";m_result+="\r\n";m_result+=c.my_show();}}else if(m_subtrict.GetState()==1){if(op1->imax!=op2->imax||op1->jmax!=op2->jmax||op1==NULL||op2==NU LL){m_result="行数列数不等无法相减!";}else{matrix<int> c(op1->imax,op1->jmax);c=*op1-*op2;m_result="matrix1-matrix2";m_result+="\r\n";m_result+=c.my_show();}}else if(m_combine.GetState()==1){if(op1->jmax!=op2->imax||op1==NULL||op2==NULL){m_result="以上无法相乘!";}else{matrix<int> c(op1->imax,op2->jmax);c=(*op1)*(*op2);m_result="matrix1*matrix2";m_result+="\r\n";m_result+=c.my_show();}}else if(m_nums.GetState()==1){if(op2==NULL){m_result="运算不出结果!";}else{matrix<int> c(op2->imax,op2->jmax); c=m_k*(*op2);m_result="k*matrix2";m_result+="\r\n";m_result+=c.my_show();}}else{m_result="请先选定一个算法!";}UpdateData(FALSE);}void CMyView::OnBUTTONrotate(){UpdateData(TRUE);if(m_r1.GetState()==1){if(op1==NULL){m_result="请先输入矩阵!";}else{matrix<int> c=rotate(*op1);m_result="matrix1转置";m_result+="\r\n";m_result+=c.my_show();}}else if(m_r2.GetState()==1){if(op2==NULL){m_result="请先输入矩阵!";}else{matrix<int> c=rotate(*op2);m_result="matrix2转置";m_result+="\r\n";m_result+=c.my_show();}}else{m_result="请选择一个矩阵!";}UpdateData(FALSE);}void CMyView::OnCHECKr1(){UpdateData(TRUE);m_r2.SetCheck(0);UpdateData(FALSE);}void CMyView::OnCHECKr2(){UpdateData(TRUE);m_r1.SetCheck(0);UpdateData(FALSE);}六．实验心得与编程收获。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
目录1 课题分析 (1)2 模块化分析 (1)2.1 输入模块 (1)2.1.1 输入模块要求 (1)2.1.2 输入模块程序说明 (1)2.2 判断模块 (3)2.3 求和求差模块 (3)2.4 乘法模块 (5)2.4.1 求乘积模块概要 (5)2.4.2 子程序段说明 (5)2.4.3 乘法模块流程图 (8)3 运行分析 (9)4 心得体会 (11)参考文献 (13)矩阵运算程序设计1 课题分析根据给定的任务：能用键盘输入矩阵的参数（行、列及元素值），在进行运算前，先判断两个矩阵是否符合运算规则实现这两个矩阵的加，实现这两个矩阵的减，实现这两个矩阵的乘。
进行模块化分析，所以程序中应该包括输入模块，保存需要处理的数据。
判断模块，根据矩阵运算规则判断输入的数据能否进行矩阵加法，减法或者乘法运算，并调用相应的计算程序。
计算模块，包括矩阵的加法，矩阵的减法和矩阵的乘法运算。
输出模块，显示运算的结果。
2 模块化分析2.1 输入模块2.1.1 输入模块要求先能用键盘输入矩阵的参数，行数和列数，然后根据输入各元素值，在输入数据之前有明显的提示信息，输入完后要保持各数据。
运算完后要将各类计算的结果显示在屏幕上，并且要有明显的提示信息。
2.1.2 输入模块程序说明输入的行列数保存到N和M中，为后来的比较和输入做准备，本程序段只是针对矩阵1的行和列，矩阵2则在此基础上经行替换即可以得到。
LEA DX,INFORMATION1 ;取信息提示地址偏移量MOV AH,09h ;9号功能调用显示提示信息INT 21HLEA DX,input1 ;提示输入矩阵1 的行数MOV AH,09h ;9号功能调用显示提示信息INT 21HMOV AH,1 ;1号功能调用保存输入信息INT 21HMOV n1,AL ;矩阵1行数存在N1段首SUB n1,30h存入行数和列数后，将行数和列数的乘积放在nm1中。
MOV AL,m1MOV BL,n1MUL BLMOV nm1,AL其中INFORMATION1，inp ut1，input2的内容在数据段定义，定义的内容如下，0AH,0DH,的作用在于换行。
INFORMATION1 DB 0AH,0DH,'Please enter the line and the row of the Array1!$' ;提示说明inp ut1 DB 'Input n,m(1~9)',0ah,0dh,'n=$'inp ut2 DB 0AH,0DH,'m=$'保存矩阵1的程序段如下：在提示输入矩阵1后，用下列循环程序将输入的每个字符保存进matrix1:LEA DI,matrix1 ；DI指向矩阵1首地址MOV CL,nm1 ；循环执行次数为行数乘以列数next: MOV AH,1 ；保存1个字符INT 21hCMP AL,' ' ；跳过‘’号JE nextMOV [DI],AL ；将该字符存在DI指向的地址INC DI ；DI加1LOOP next ；循环调用完毕后，将末尾处赋值$表示矩阵保存结束。
2.2 判断模块设有两个矩阵，矩阵A（n1*m1）和矩阵B（n2*m2），比较各个参数，判断其能进行哪些运算。
根据矩阵运算规则，只有两个矩阵为同型矩阵时，这两个矩阵才能进行加减法运算，即n1=n2且m1=m2；只有当矩阵第一个矩阵的列数等于第二个矩阵的行数时，即n1乘积AB才是有意义的，并且Ab的行数等于第一个矩阵的行数，AB的列数等于第二个矩阵的列数。
根据以上运算规则，可以做出比较判断流程图如图2-1所示：图2-1 判断模块流程图2.3 求和求差模块若在根据行列数判断能进行加法运算，则将输入的每个数据逐个相加即可，对减法运算同理，重要的是处理好加法进位和借位减法。
根据加法运算和汇编语言的规则，可做出加法流程图如图2-2所示：图2-3 加法流程图注意的是，与求和的子程序相比，求差的子程序在求和的程序基础上做了以下的修改：将[DI]+[SI]<3A改为[SI]-[DI]>2F，将加法的调整为两位数改变为添加负号。
2.4 乘法模块2.4.1 求乘积模块概要对于矩阵的相乘的实现，一共有三道循环，第一个最内部的循环就是在定行与定列的相乘时候几个数据的相乘后相加的循环；然后外部的一个循环就是关于定行选择不同列进行相乘的循环；最外面的一个循环就是关于选行的循环。
不过三个循环实现起来的深度有点大，可以把最外面的一道循环写成三次分别调用，这样可以使程序容易实现，看起来更清楚明白。
2.4.2 子程序段说明按照子程序调用的顺序依次介绍各子程序主要程序段的功能。
（1）2号程序CHENGFA2的主要程序段如下：它完成的主要任务是计算取出的两数的积。
l2: MOV AL,[SI]SUB AL,30HMOV CL,[DI]SUB CL,30HMUL CL ；完成两数相乘AAM ；做BC D调整ADD AX,3030HMOV DL,AHLEA BX,sum1 ；将结果存入sum1Sum2的求法只是在SI偏移1，DI偏移M2后重新计算的结果。
（2）1号程序CHENGFA1的主要程序段如下：它完成的主要任务是计算两数积的和。
CHENGFA1 PROC Xl1: LEA DI,sum1LEA SI,sum2LEA BX,SUMADD BX,2Xl2: MOV DL,[DI]MOV AL,'$' CMP DL,AL JE Xl3MOV AL,[SI] ADD DL,AL SUB DL,30h CMP DL,3AH JB XXXSUB DL,0AH MOV [BX],DL INC DIINC SIDEC BXMOV DL,[DI] MOV AL,[SI] ADD DL,AL ADD DL,1H SUB DL,30h CMP DL,3AH JB XXXSUB DL,0AH MOV [BX],DLINC DIINC SIDEC BXMOV DL,[DI]MOV AL,[SI]ADD DL,ALADD DL,1HSUB DL,30hXl3: MOV [BX],DLMOV AL,','MOV [BX+4],ALMOV AL,'$'MOV [BX+5],ALCALL CHENGFA3 XXX: MOV [BX],DLINC DIINC SIDEC BXJMP Xl2RETCHENGFA1 ENDP（3）3号程序CHENGFA3的主要程序段如下：它完成的主要任务是判断矩阵3的元素是否计算完毕，否则将SUM的值存入SUM1,并在偏移指定量后重新计算SUM的值。
lc: MOV AL,M1MOV BL,NBCMP BL,ALJB laCALL SHUCHU la: LEA DI,SUMLEA SI,sum1MOV AL,[DI+2]MOV [SI],AL MOV AL,[DI+1] MOV [SI+1],AL MOV AL,[DI] MOV [SI+2],AL MOV AL,'$' MOV [SI+3],AL LEA SI,matrix1 LEA DI,matrix2 XOR AX,AXXOR BX,BX MOV AL,nz MOV BL,m1 MUL BL XOR BX,BX MOV BL,nb MOV BH,0 CBWADD AX,BX ADD SI,AX MOV AL,nb MOV BL,m2 MUL BL XOR BX,BX MOV BL,NY MOV BH,0 CBWADD AX,BX ADD DI,AX INC NBMOV AL,[SI] CMP AL,'$'JE l3SUB AL,30HMOV CL,[DI] SUB CL,30H MUL CLAAMADD AX,3030H MOV DL,AHLEA BX,sum2 MOV CL,'0'MOV [BX+2],CL MOV [BX+1],DL MOV [BX],AL MOV AL,'$' MOV [BX+3],ALCALL CHENGFA1 JMP lcRET（4）输出程序shuchu的主要程序段如下：它完成的主要任务是将计算出的SUM值输出。
Xl4: LEA BX,SUMMOV AL,[BX]CMP AL,'0'JNE Xl5MOV CL,5Xl6: MOV AL,[BX+1]MOV [BX],ALINC BXLOOP Xl6JMP Xl4在提示结果输出后，使用9号功能调用将结果输出。
2.4.3 乘法模块流程图先判断每个元素是否计算完，否则执行循环乘法，并累计求和，每个元素计算完后，再计算下个元素，同时利用每列的计数符标志是否转行计算。
2号程序主程序1号程序 3号程序图2-4乘法模块流程图3运行分析（1）矩阵1和矩阵2为同型的方阵时，输出加法，减法和乘法的运算结果显示如图3-1所示：图3-1 同型方阵运算结果（2）矩阵1和矩阵2行数列数分别相等，但行数不等于列数，输出加法和减法的运算结果，没有乘法运算结果，显示如图3-2所示：图3-2 行数列数分别相等，行数不等于列数运算结果图（3）矩阵1的列数和矩阵2行数相等，但矩阵1行数不等于矩阵2列数，输出乘法运算结果，没有加法和减法的运算结果，显示如图3-3所示：图3-3 行数列数分别相等，但行数不等于列数结果图（4）矩阵1和矩阵2无法进行计算的返回结果，显示错误，如图3-4所示：图3-4 结果错误显示图4心得体会学完微机原理与接口技术这门课程，觉得这是一门很有趣的课程，但是由于知识掌握的不是很牢固，便来了这次微机原理与接口技术的课程设计，这次课程设计，总体上可以说是处于“学会了一些新知识，弄清了一些原来保留的问题，又出现了一些新问题”的循环中。
在矩阵的输入上面由于知识层面不高，便限定了矩阵的行列数，而且在矩阵的元素上也只能输入正的0到9，不能输入负数，程序存在一定的局限性。
在矩阵的输出中，本想将矩阵显示成行列的行列的形式，但是探索了很久还没弄出来，而且让程序本身错误更多，便放弃了。
在判断的时候，根据运算规则判断出能否进行加减乘法运算的时候我们没有很好的加入提示性的语句。
在输入的时候，当输入的不是数字和空格的时候，我们将它们都显示出来了，这一点做的很不对，应该将不是空格和数字的输入不显示出来。
程序依旧存在很多bug，我们做的确实有很多不足。
通过微机原理与接口技术这门课程学习了关于汇编语言的知识，起初学起来的时候感觉很有难度。
当知道要做课程设计的时候心里面感觉有些害怕和担心，担心自己不会或者做不好。