矩阵运算实验报告
多核矩阵乘实验报告
一、实验背景随着科学计算、图像处理和大数据分析等领域的发展，矩阵乘法作为基本运算之一，对计算性能的要求越来越高。
传统的单核处理器在处理大规模矩阵乘法时，计算效率低下。
多核处理器技术的发展为矩阵乘法的并行计算提供了新的解决方案。
本实验旨在通过在多核处理器上实现矩阵乘法，评估不同并行策略对性能的影响。
二、实验目的1. 评估不同并行策略对矩阵乘法性能的影响；2. 分析多核处理器在矩阵乘法计算中的并行度；3. 对比不同核数处理器在矩阵乘法计算中的性能差异。
三、实验环境1. 操作系统：Linux Ubuntu 16.042. 编程语言：C/C++3. 开发环境：Visual Studio Code4. 处理器：Intel Core i7-8550U，8核心，16线程5. 内存：16GB DDR4四、实验方法1. 矩阵乘法算法实现本实验采用C/C++语言实现矩阵乘法，主要采用以下两种并行策略：（1）线程级并行：将矩阵分割成多个子矩阵，每个线程负责计算一个子矩阵；（2）任务级并行：将整个矩阵乘法任务分配给多个线程，每个线程负责计算矩阵的某一行或某一列。
2. 性能评估实验通过比较不同并行策略和核数处理器在矩阵乘法计算中的运行时间，评估其性能。
五、实验结果与分析1. 线程级并行性能分析表1展示了不同线程数下矩阵乘法的运行时间。
| 线程数 | 运行时间（秒） || ------ | ------------ || 1 | 2.3 || 2 | 1.1 || 4 | 0.6 || 8 | 0.3 || 16 | 0.2 |由表1可知，随着线程数的增加，运行时间逐渐减少。
这是因为线程级并行可以将计算任务分配给多个处理器核心，提高计算效率。
2. 任务级并行性能分析表2展示了不同任务数下矩阵乘法的运行时间。
| 任务数 | 运行时间（秒） || ------ | ------------ || 1 | 2.3 || 2 | 1.1 || 4 | 0.6 || 8 | 0.3 || 16 | 0.2 |由表2可知，任务级并行与线程级并行的性能趋势相似。
矩阵的乘法实验报告
一、实验目的1. 理解矩阵乘法的概念和运算规则。
2. 掌握矩阵乘法的编程实现方法。
3. 通过实验验证矩阵乘法的正确性。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3. 库：NumPy三、实验原理矩阵乘法是指两个矩阵相乘的运算。
设矩阵A为m×n的矩阵，矩阵B为n×p的矩阵，则它们的乘积C为一个m×p的矩阵。
矩阵乘法的运算规则如下：C[i][j] = Σ(A[i][k] B[k][j])，其中k为1到n的整数。
四、实验步骤1. 导入NumPy库。
```pythonimport numpy as np```2. 定义矩阵A和B。
```pythonA = np.array([[1, 2], [3, 4]])B = np.array([[5, 6], [7, 8]])```3. 计算矩阵A和B的乘积C。
```pythonC = np.dot(A, B)```4. 打印结果。
```pythonprint("矩阵A：")print(A)print("矩阵B：")print(B)print("矩阵C（A乘B）：")print(C)```五、实验结果与分析1. 运行实验程序，得到以下结果：```矩阵A：[[1 2][3 4]]矩阵B：[[5 6][7 8]]矩阵C（A乘B）：[[19 22][43 50]]```2. 分析结果：- 矩阵A为2×2的矩阵，矩阵B为2×2的矩阵，它们的乘积C为2×2的矩阵。
- 根据矩阵乘法的运算规则，我们可以计算出矩阵C的每个元素。
- 实验结果与理论计算相符，说明矩阵乘法的编程实现是正确的。
六、实验总结1. 本实验成功实现了矩阵乘法的编程，验证了矩阵乘法的正确性。
2. 通过实验，加深了对矩阵乘法概念和运算规则的理解。
3. NumPy库在矩阵运算方面具有强大的功能，为编程提供了便利。
矩阵运算软件实验报告
一、实验目的1. 熟悉矩阵运算软件的基本功能和使用方法。
2. 掌握矩阵的创建、编辑、保存、调用等操作。
3. 熟练运用矩阵的基本运算，如加减乘除、求逆、求行列式、求秩、求迹等。
4. 通过实际操作，提高对矩阵运算的理解和应用能力。
二、实验环境1. 软件名称：MATLAB2. 操作系统：Windows 103. 编程环境：MATLAB R2020b三、实验内容1. 矩阵的创建与编辑（1）创建一个2x3的矩阵A：```A = [1 2 3; 4 5 6]```（2）创建一个3x3的矩阵B，并将元素设置为随机数：```B = randn(3);```（3）编辑矩阵A，将第2行第3列的元素修改为10：```A(2,3) = 10;```2. 矩阵的保存与调用（1）将矩阵A保存为“matrixA.mat”：```save matrixA.mat A```（2）调用保存的矩阵A：```load matrixA.mat```3. 矩阵的基本运算（1）矩阵的加减运算：```C = A + B; % 矩阵A与B相加D = A - B; % 矩阵A与B相减```（2）矩阵的乘除运算：```E = A B; % 矩阵A与B相乘F = A / B; % 矩阵A与B相除（元素-wise）```（3）求矩阵的逆：```G = inv(A); % 求矩阵A的逆```（4）求矩阵的行列式：```detA = det(A); % 求矩阵A的行列式```（5）求矩阵的秩：```rankA = rank(A); % 求矩阵A的秩```（6）求矩阵的迹：```traceA = trace(A); % 求矩阵A的迹```4. 矩阵的应用（1）解线性方程组：```x = A\b; % 解线性方程组Ax = b```（2）矩阵的特征值与特征向量：```[V, D] = eig(A); % 求矩阵A的特征值和特征向量```四、实验结果与分析1. 通过实验，成功创建了多个矩阵，并掌握了矩阵的保存与调用方法。
矩阵数值计算实验报告
#### 一、实验目的本次实验旨在通过MATLAB软件，对矩阵进行数值计算，掌握矩阵的基本操作、运算函数的使用，以及解决实际问题的能力。
通过实验，加深对线性代数基本理论的理解，提高数值计算技能。
#### 二、实验环境软件：MATLAB R2020a硬件：****************************，8GB RAM#### 三、实验内容1. 矩阵的创建与操作（1）创建矩阵：通过MATLAB内置函数创建不同类型的矩阵，如`zeros`、`ones`、`rand`等。
```matlabA = zeros(3,3); % 创建3x3零矩阵B = ones(2,2); % 创建2x2单位矩阵C = rand(4,4); % 创建4x4随机矩阵```（2）矩阵的引用：使用矩阵的行和列索引访问矩阵元素。
```matlabE = A(1,1); % 访问矩阵A的第一个元素```（3）矩阵的运算：进行矩阵的加法、减法、乘法等运算。
```matlabD = A + B; % 矩阵A和B相加F = A . C; % 矩阵A和C对应元素相乘```2. 矩阵的基本运算（1）矩阵的逆：计算矩阵的逆矩阵。
```matlabA_inv = inv(A);```（2）矩阵的行列式：计算矩阵的行列式值。
```matlabdet_A = det(A);```（3）矩阵的秩：计算矩阵的秩。
```matlabrank_A = rank(A);```（4）矩阵的迹：计算矩阵的迹。
```matlabtrace_A = trace(A);```3. 矩阵分解（1）奇异值分解（SVD）：对矩阵进行奇异值分解。
```matlab[U, S, V] = svd(A);```（2）LU分解：将矩阵分解为下三角矩阵和上三角矩阵。
```matlab[L, U] = lu(A);```4. 解线性方程组（1）使用矩阵的逆解方程组。
```matlabb = [1; 2; 3];x = A_inv b;```（2）使用矩阵分解方法解方程组。
matlab矩阵运算实验报告
matlab矩阵运算实验报告Matlab矩阵运算实验报告一、引言矩阵运算是数学和工程领域中的重要概念之一，它在各个领域中都有广泛的应用。
Matlab作为一种强大的数学软件工具，提供了丰富的矩阵运算功能，可以帮助我们进行高效的数值计算和数据处理。
本实验报告将介绍Matlab中的矩阵运算功能，并通过实例展示其在实际问题中的应用。
二、矩阵运算的基本概念矩阵是由若干个数按照行和列排列形成的一个矩形阵列，它是线性代数中的基本工具。
在Matlab中，矩阵可以通过直接输入数值或使用内置函数生成。
矩阵运算包括加法、减法、乘法、转置等操作，这些操作可以对矩阵的每个元素进行运算，也可以对整个矩阵进行运算。
三、矩阵运算的实例分析1. 矩阵的创建与赋值在Matlab中，可以使用以下命令创建一个矩阵，并对其进行赋值操作：A = [1, 2, 3; 4, 5, 6; 7, 8, 9];这样就创建了一个3行3列的矩阵A，并对其进行了赋值。
可以通过输入A来查看矩阵A的内容。
2. 矩阵的加法与减法矩阵的加法和减法是按照对应元素进行运算的。
例如，对于两个3行3列的矩阵A和B，可以使用以下命令进行加法运算：C = A + B;同样地，可以使用以下命令进行减法运算：D = A - B;这样就得到了矩阵C和D。
3. 矩阵的乘法矩阵的乘法是按照行乘以列的方式进行的。
例如，对于一个3行2列的矩阵A和一个2行4列的矩阵B，可以使用以下命令进行乘法运算：C = A * B;这样就得到了一个3行4列的矩阵C。
4. 矩阵的转置矩阵的转置是将矩阵的行和列进行交换的操作。
例如，对于一个3行2列的矩阵A，可以使用以下命令进行转置操作：B = A';这样就得到了一个2行3列的矩阵B。
四、矩阵运算的应用实例矩阵运算在实际问题中有着广泛的应用。
以下是一个简单的实例，通过矩阵运算来解决线性方程组的问题。
假设有一个线性方程组：2x + y = 4x + 3y = 6可以将其表示为矩阵形式：A = [2, 1; 1, 3];B = [4; 6];通过矩阵运算可以求解出未知数x和y的值：X = A \ B;这样就得到了未知数x和y的值。
矩阵运算基础实验报告
一、实验目的1. 理解矩阵的基本概念和性质。
2. 掌握矩阵的创建、基本运算和常用函数。
3. 熟悉MATLAB软件在矩阵运算中的应用。
二、实验环境1. 操作系统：Windows 102. 软件环境：MATLAB R2020b三、实验内容1. 矩阵的创建与基本运算（1）创建矩阵在MATLAB中，可以使用多种方式创建矩阵，如：- 使用方括号[]直接输入矩阵元素。
- 使用冒号(:)生成向量。
- 使用linspace()、logspace()、zeros()、ones()等函数生成特殊矩阵。
（2）矩阵的基本运算- 矩阵加减法：两个矩阵的对应元素相加或相减。
- 矩阵乘法：包括标量乘法、矩阵乘法和转置运算。
- 矩阵除法：使用除号(/)或乘方运算符()实现。
- 矩阵求逆：使用inv()函数计算矩阵的逆。
2. 矩阵的常用函数（1）矩阵转置：使用T()或'符号实现。
（2）矩阵求行列式：使用det()函数。
（3）矩阵求特征值和特征向量：使用eig()函数。
（4）矩阵求条件数：使用cond()函数。
3. 矩阵的应用实例（1）求解线性方程组给定线性方程组：$$\begin{cases}2x + 3y = 8 \\x - y = 1\end{cases}$$在MATLAB中，可以使用以下代码求解：```A = [2, 3; 1, -1];b = [8; 1];x = A\b;disp(x);```（2）求解矩阵的逆给定矩阵A：```A = [4, 7; 2, 6];A_inv = inv(A);disp(A_inv);```四、实验结果与分析1. 创建矩阵（1）创建一个3x3矩阵：```A = [1, 2, 3; 4, 5, 6; 7, 8, 9];```（2）创建一个向量：```v = [1, 2, 3, 4, 5];```2. 矩阵的基本运算（1）矩阵加减法：```A = [1, 2; 3, 4];B = [5, 6; 7, 8];disp(A + B); % 结果为[6, 8; 10, 12] disp(A - B); % 结果为[-4, -4; -2, -4] ```（2）矩阵乘法：```A = [1, 2; 3, 4];B = [5, 6; 7, 8];disp(A B); % 结果为[19, 22; 43, 50] ```（3）矩阵求逆：```A = [4, 7; 2, 6];disp(inv(A)); % 结果为[-3, 7; 2, -1] ```3. 矩阵的常用函数（1）矩阵转置：```A = [1, 2, 3; 4, 5, 6];disp(A'); % 结果为[1, 4; 2, 5; 3, 6] ```（2）矩阵求行列式：```A = [4, 7; 2, 6];disp(det(A)); % 结果为-12```（3）矩阵求特征值和特征向量：```A = [1, 2; 3, 4];[V, D] = eig(A);disp(V); % 特征向量disp(D); % 特征值```五、实验总结通过本次实验，我们掌握了矩阵的基本概念、创建方法、基本运算和常用函数。
矩阵乘法(分治法)
算法设计与分析实验报告二、模型拟制、算法设计和正确性证明：设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。
指针矩阵相乘实验报告
一、实验目的1. 理解指针在C语言中的作用，掌握指针的使用方法。
2. 学习矩阵相乘的基本原理，并利用指针实现矩阵相乘。
3. 提高编程能力和问题解决能力。
二、实验内容本次实验主要实现了两个矩阵的相乘，要求使用指针操作完成。
假设两个矩阵分别为A和B，其中A为m×k矩阵，B为k×n矩阵，乘积矩阵C为m×n矩阵。
三、实验原理矩阵相乘的原理如下：C[i][j] = Σ(A[i][k] B[k][j]) （k从0到k-1）其中，C[i][j]表示乘积矩阵C的第i行第j列的元素，A[i][k]表示矩阵A的第i 行第k列的元素，B[k][j]表示矩阵B的第k行第j列的元素。
四、实验步骤1. 定义两个二维数组A和B，分别代表两个矩阵。
2. 定义一个二维数组C，用于存储乘积矩阵。
3. 使用指针遍历两个矩阵，并计算乘积矩阵C的元素。
4. 输出乘积矩阵C。
五、实验代码```c#include <stdio.h>#define M 3 // 矩阵A的行数#define N 3 // 矩阵B的列数#define K 3 // 矩阵A的列数和矩阵B的行数int main() {int A[M][K] = {{1, 2, 3},{4, 5, 6},{7, 8, 9}};int B[K][N] = {{9, 8, 7},{6, 5, 4},{3, 2, 1}};int C[M][N];// 计算乘积矩阵Cfor (int i = 0; i < M; i++) {for (int j = 0; j < N; j++) {for (int k = 0; k < K; k++) {(C + i N + j) += (A + i K + k) (B + k N + j); }}}// 输出乘积矩阵Cfor (int i = 0; i < M; i++) {for (int j = 0; j < N; j++) {printf("%d ", (C + i N + j));}printf("\n");}return 0;}```六、实验结果执行上述代码，输出乘积矩阵C为：```30 24 1884 69 54138 114 90```七、实验总结通过本次实验，我们掌握了指针在C语言中的使用方法，并成功实现了矩阵相乘。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告
--矩阵运算
一．实验目的。
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 here
if(m_add.GetState()==1)
{
if(op1->imax!=op2->imax||op1->jmax!=op2->jmax||op1==NULL||op 2==NULL)
{
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||op 2==NULL)
{
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);
}
六．实验心得与编程收获。
这个程序是相对简单一些的,但在编写的过程中我仍然感觉收获很多.首先是合理运用一维数组,利用它来进行矩阵的相关运算,并且最后利用数组来输出矩阵,这也加强了我运用CString的能力.然后在制作界面方面使我更加得心应手,能够快速完成界面及相关的属性设置.最后还有动态生成矩阵方面也帮我复习了从前
的知识.
七．总结展望与参考书目。
7.1总结展望
尽管这次的矩阵并不完善，只能作一些简单的运算，但是我想矩阵在今后无论学习还是工作中应该都会经常遇到,这是一个比较基础的知识,通过这次的编程过程,我对于矩阵的理解加深了,同时我了解到了比如矩阵与一维数组之间的相互转化等知识,我想这对今后一定会很有帮助。
今后我也一定会更加努力的去把握。
7.2参考书目
1)visual C++ MFC编程实例周靖主编清华大学
2)深入浅出MFC 候俊杰编
3)VC++深入详解鑫编。