矩阵运算实验报告
多核矩阵乘实验报告
一、实验背景随着科学计算、图像处理和大数据分析等领域的发展，矩阵乘法作为基本运算之一，对计算性能的要求越来越高。
传统的单核处理器在处理大规模矩阵乘法时，计算效率低下。
多核处理器技术的发展为矩阵乘法的并行计算提供了新的解决方案。
本实验旨在通过在多核处理器上实现矩阵乘法，评估不同并行策略对性能的影响。
二、实验目的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. 学习矩阵的应用，如线性方程组的求解。
4. 提高数学建模和解决问题的能力。
二、实验内容本次实验主要围绕矩阵的运算和应用展开，具体内容包括：1. 矩阵的加法与减法2. 矩阵的乘法3. 矩阵的逆4. 线性方程组的求解三、实验步骤1. 矩阵的加法与减法（1）选择两个矩阵A和B，确保它们具有相同的行数和列数。
（2）将矩阵A和B对应位置的元素相加或相减，得到新的矩阵C。
（3）验证矩阵C的行数和列数与矩阵A和B相同。
2. 矩阵的乘法（1）选择两个矩阵A和B，确保矩阵A的列数等于矩阵B的行数。
（2）计算矩阵A的每一行与矩阵B的每一列的点积，得到新的矩阵C。
（3）验证矩阵C的行数等于矩阵A的行数，列数等于矩阵B的列数。
3. 矩阵的逆（1）选择一个可逆矩阵A。
（2）使用高斯-约当消元法求解矩阵A的逆。
（3）验证矩阵A与其逆矩阵的乘积为单位矩阵。
4. 线性方程组的求解（1）选择一个线性方程组，例如：AX = B，其中A是系数矩阵，X是未知数矩阵，B是常数矩阵。
（2）使用高斯-约当消元法求解线性方程组。
（3）验证求解得到的X矩阵是否满足原方程组。
四、实验结果与分析1. 矩阵的加法与减法通过实验，我们发现矩阵的加法与减法运算满足交换律和结合律，且结果矩阵的行数和列数与原矩阵相同。
2. 矩阵的乘法实验结果表明，矩阵的乘法运算满足交换律和结合律，且结果矩阵的行数等于第一个矩阵的行数，列数等于第二个矩阵的列数。
3. 矩阵的逆实验发现，对于可逆矩阵，其逆矩阵存在，且满足A A^(-1) = A^(-1) A = E（单位矩阵）。
4. 线性方程组的求解通过高斯-约当消元法，我们成功求解了线性方程组，并验证了求解结果的正确性。
五、实验结论1. 理解了矩阵的基本概念和性质，掌握了矩阵的运算方法。
2. 学会了使用矩阵求解线性方程组，提高了数学建模和解决问题的能力。
线性代数实验报告
线性代数实验报告一、实验目的线性代数是一门重要的数学基础课程，它在工程、科学、计算机等领域都有着广泛的应用。
本次实验的目的是通过实际操作和计算，加深对线性代数基本概念和方法的理解，提高运用线性代数知识解决实际问题的能力。
二、实验环境本次实验使用了软件名称软件进行计算和绘图。
三、实验内容（一）矩阵的运算1、矩阵的加法和减法给定两个矩阵 A 和 B，计算它们的和 A ＋ B 以及差 A B。
观察运算结果，验证矩阵加法和减法的规则。
2、矩阵的乘法给定两个矩阵 C 和 D，其中 C 的列数等于 D 的行数，计算它们的乘积 CD。
分析乘法运算的结果，理解矩阵乘法的意义和性质。
（二）行列式的计算1、二阶和三阶行列式的计算手动计算二阶和三阶行列式的值，熟悉行列式的展开法则。
使用软件验证计算结果的正确性。
2、高阶行列式的计算选取一个四阶或更高阶的行列式，利用软件计算其值。
观察行列式的值与矩阵元素之间的关系。
（三）线性方程组的求解1、用高斯消元法求解线性方程组给定一个线性方程组，将其增广矩阵通过初等行变换化为行阶梯形矩阵。
求解方程组的解，并验证解的正确性。
2、用矩阵的逆求解线性方程组对于系数矩阵可逆的线性方程组，计算系数矩阵的逆矩阵。
通过逆矩阵求解方程组，并与高斯消元法的结果进行比较。
（四）向量组的线性相关性1、判断向量组的线性相关性给定一组向量，计算它们的线性组合是否为零向量。
根据计算结果判断向量组的线性相关性。
2、求向量组的极大线性无关组对于给定的向量组，通过初等行变换找出极大线性无关组。
（五）特征值和特征向量的计算1、计算矩阵的特征值和特征向量给定一个矩阵，计算其特征值和对应的特征向量。
验证特征值和特征向量的定义和性质。
2、利用特征值和特征向量进行矩阵对角化对于可对角化的矩阵，将其化为对角矩阵。
四、实验步骤（一）矩阵的运算1、首先在软件中输入矩阵 A 和 B 的元素值。
2、然后使用软件提供的矩阵加法和减法功能，计算 A ＋ B 和 A B 的结果。
矩阵乘法实验报告总结
矩阵乘法是线性代数中一个基础且重要的运算，广泛应用于科学计算、数据分析和工程领域。
为了深入了解矩阵乘法的并行化实现，提高计算效率，本实验旨在通过MPI（Message Passing Interface）并行编程技术，实现矩阵乘法的并行计算，并分析其性能。
二、实验内容与方法1. 实验环境操作系统：Ubuntu Linux编译器：gcc并行计算平台：632核CPU、400GB内存的分布内存并行计算平台2. 实验方法（1）矩阵乘法算法本实验采用经典的矩阵乘法算法，即按行优先顺序进行计算。
具体步骤如下：① 将矩阵A、B、C划分为p个块，每个块包含m/p行和n/p列。
② 每个进程负责计算C的一个子块，即计算A的m/p行与B的n/p列的乘积。
③ 进程间通过MPI通信进行数据交换，实现并行计算。
（2）MPI编程本实验采用MPI编程实现矩阵乘法。
主要使用以下MPI语句：① MPI_Init：初始化MPI环境。
② MPI_Comm_size：获取进程总数。
③ MPI_Comm_rank：获取进程编号。
④ MPI_Send：发送数据。
⑤ MPI_Recv：接收数据。
⑥ MPI_Finalize：结束MPI环境。
1. 矩阵乘法结果验证通过比较串行计算和并行计算的结果，验证了程序的正确性。
2. 性能分析（1）执行时间在固定矩阵规模n=1000的情况下，分别测试进程数取1、2、4、8、16、32、64时的执行时间。
结果表明，随着进程数的增加，执行时间逐渐减少，且呈近似线性关系。
（2）加速比加速比是指并行计算时间与串行计算时间的比值。
本实验计算了不同进程数下的加速比，发现随着进程数的增加，加速比逐渐提高，且在进程数达到一定数量后，加速比趋于稳定。
（3）并行效率并行效率是指实际加速比与理论加速比之比。
本实验计算了不同进程数下的并行效率，发现随着进程数的增加，并行效率逐渐提高，但存在一个峰值，之后逐渐降低。
四、实验结论与展望1. 结论本实验通过MPI并行编程技术实现了矩阵乘法的并行计算，验证了程序的正确性。
有关矩阵数学实验报告
有关矩阵数学实验报告引言矩阵是数学中一个重要的概念，广泛应用于线性代数、图论、计算机科学等众多领域。
本实验旨在通过实际操作和计算，加深对矩阵的理解，并探索矩阵在现实问题中的应用。
本报告将从实验目的、实验步骤、实验结果和实验结论几个方面进行介绍。
实验目的1. 了解矩阵的基本概念和运算规则；2. 掌握矩阵的求逆、转置和乘法等操作；3. 实践利用矩阵解决实际问题。
实验步骤1. 实验准备：安装并学习使用相应的矩阵数学软件；2. 实验1：矩阵加法和乘法- 创建两个相同维度的矩阵A和B；- 计算A + B和A * B；- 分析结果并进行讨论。
3. 实验2：矩阵求逆和转置- 创建一个可逆矩阵C；- 计算C的逆矩阵C'和C的转置矩阵C^T；- 检验计算结果是否正确。
4. 实验3：矩阵在实际问题中的应用- 选择一个实际问题，并将其抽象成矩阵形式；- 利用矩阵运算解决问题；- 分析结果，并与传统解法进行对比。
实验结果1. 实验1结果分析：经过计算发现，矩阵的加法和乘法满足交换律和结合律，与数的加法和乘法类似。
但是，矩阵乘法不满足交换律，即A * B ≠B * A。
这进一步说明矩阵并不是普通数的简单扩展。
2. 实验2结果检验：针对可逆矩阵C，计算得到的逆矩阵C'和转置矩阵C^T经过验证均正确，满足逆矩阵和转置矩阵的定义和性质。
3. 实验3结果分析：我们选择了一个线性方程组问题，利用矩阵运算求解。
与传统解法相比，矩阵运算更简洁、高效，尤其对于高维度复杂问题具有很大优势。
实验结论通过本次实验，我们对矩阵的概念和运算规则有了更深入的理解。
矩阵不仅仅是一种数学工具，它在现实问题的建模和求解中发挥着重要作用。
矩阵的加法、乘法、逆矩阵和转置等运算规则的学习，为我们处理实际问题提供了更多的方法和思路。
在未来的学习和研究中，矩阵将会贯穿于我们的整个数学和科学计算的领域，为我们带来更大的便利和创造力。
矩阵论的实验报告
一、实验目的1. 理解矩阵的基本概念和性质。
2. 掌握矩阵的运算方法，包括加法、减法、乘法、转置等。
3. 学习矩阵的行列式、逆矩阵、秩和迹的计算方法。
4. 熟悉矩阵的分解方法，如三角分解、Cholesky分解等。
5. 通过实验加深对矩阵论理论的理解和应用。
二、实验原理矩阵论是线性代数的一个重要分支，主要研究矩阵及其运算。
矩阵在自然科学、工程技术、经济学等领域都有广泛的应用。
本实验主要涉及以下内容：1. 矩阵的基本运算：矩阵的加法、减法、乘法、转置等。
2. 矩阵的行列式、逆矩阵、秩和迹的计算方法。
3. 矩阵的分解方法，如三角分解、Cholesky分解等。
三、实验仪器与软件1. 仪器：计算机2. 软件：MATLAB四、实验内容1. 矩阵的基本运算（1）编写MATLAB程序，计算矩阵A和B的加法、减法、乘法、转置。
（2）验证矩阵运算的性质，如结合律、分配律等。
2. 矩阵的行列式、逆矩阵、秩和迹的计算（1）编写MATLAB程序，计算矩阵A的行列式、逆矩阵、秩和迹。
（2）验证计算结果与理论值的一致性。
3. 矩阵的分解方法（1）编写MATLAB程序，对矩阵A进行三角分解（LU分解）。
（2）编写MATLAB程序，对矩阵A进行Cholesky分解。
（3）验证分解结果与理论值的一致性。
4. 应用实例（1）使用矩阵运算解决实际问题，如线性方程组的求解。
（2）使用矩阵分解方法解决实际问题，如求解最小二乘问题。
五、实验步骤1. 编写MATLAB程序，实现矩阵的基本运算。
2. 编写MATLAB程序，计算矩阵的行列式、逆矩阵、秩和迹。
3. 编写MATLAB程序，对矩阵进行三角分解和Cholesky分解。
4. 对实验结果进行分析，验证理论值与实验结果的一致性。
5. 使用矩阵运算和分解方法解决实际问题。
六、实验结果与分析1. 矩阵的基本运算实验结果与分析通过编写MATLAB程序，实现了矩阵的加法、减法、乘法、转置等基本运算。
实验结果与理论值一致，验证了矩阵运算的性质。
矩阵连乘实验报告
程序设计报告、 我保证没有抄袭别人作业!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 实验报告
matlab 实验报告Matlab实验报告引言：Matlab是一种强大的数值计算和可视化软件，广泛应用于科学、工程和经济等领域。
本实验报告将介绍我在使用Matlab进行实验过程中的一些经验和结果。
实验一：矩阵运算在这个实验中，我使用Matlab进行了矩阵运算。
首先，我创建了一个3x3的矩阵A和一个3x1的矩阵B，并进行了矩阵相乘运算。
通过Matlab的矩阵乘法运算符*，我得到了一个3x1的结果矩阵C。
接着，我对矩阵C进行了转置操作，得到了一个1x3的矩阵D。
最后，我计算了矩阵C和矩阵D的点积，并将结果输出。
实验二：数据可视化在这个实验中，我使用Matlab进行了数据可视化。
我选择了一组实验数据，包括时间和温度两个变量。
首先，我将数据存储在一个矩阵中，并使用Matlab的plot函数将时间和温度之间的关系绘制成曲线图。
接着，我使用Matlab的xlabel、ylabel和title函数添加了横轴、纵轴和标题。
最后，我使用Matlab的legend函数添加了图例，以便更好地理解图表。
实验三：数值积分在这个实验中，我使用Matlab进行了数值积分。
我选择了一个函数f(x)进行积分计算。
首先，我使用Matlab的syms函数定义了符号变量x，并定义了函数f(x)。
接着，我使用Matlab的int函数对函数f(x)进行积分计算，并将结果输出。
为了验证结果的准确性，我还使用了Matlab的diff函数对积分结果进行了求导操作，并与原函数f(x)进行了比较。
实验四：信号处理在这个实验中，我使用Matlab进行了信号处理。
我选择了一个音频文件，并使用Matlab的audioread函数读取了该文件。
接着，我使用Matlab的fft函数对音频信号进行了傅里叶变换，并将结果绘制成频谱图。
为了进一步分析信号的特征，我还使用了Matlab的spectrogram函数绘制了信号的时频图。
通过对信号的频谱和时频图的观察，我可以更好地理解信号的频率和时域特性。
矩阵运算实验报告
矩阵运算实验报告实验目的：通过矩阵运算实验，探究矩阵的基本运算规则、性质及应用，并加深对矩阵运算的理解。
实验原理：矩阵是一个由元素按照行和列排列成的矩形阵列，可以进行加法、减法、乘法等基本的运算。
矩阵的加法与减法满足交换律、结合律和分配律；矩阵的乘法满足结合律、分配律和左乘右乘不一定相等的性质。
实验步骤：1. 实验前的准备：准备两个矩阵A和B，并确定其维度。
2. 进行矩阵加法运算：将矩阵A与矩阵B的对应元素相加，得到新的矩阵C。
3. 进行矩阵减法运算：将矩阵A与矩阵B的对应元素相减，得到新的矩阵D。
4. 进行矩阵乘法运算：将矩阵A的行元素与矩阵B的列元素对应相乘，并将结果相加，得到新的矩阵E。
5. 对矩阵进行转置：将矩阵A的行与列互换，得到新的矩阵F。
6. 求矩阵的逆：若矩阵A可逆，则找到矩阵A的逆矩阵G。
实验结果：1. 矩阵加法运算的结果：得到新的矩阵C，其维度与矩阵A和B相同，且C(i,j) = A(i,j) + B(i,j)。
2. 矩阵减法运算的结果：得到新的矩阵D，其维度与矩阵A和B相同，且D(i,j) = A(i,j) - B(i,j)。
3. 矩阵乘法运算的结果：得到新的矩阵E，其维度为A的行数乘以B的列数，且E(i,j) = Σ(A(i,k)*B(k,j))，k的取值范围为1到B的行数（或A的列数）。
4. 矩阵转置的结果：得到新的矩阵F，其维度与矩阵A相反，即F的行数等于A的列数，F的列数等于A的行数，且F(i,j) = A(j,i)。
5. 矩阵逆矩阵的结果：得到新的矩阵G，其与矩阵A的乘积为单位矩阵，即A*G = G*A = I，其中I为单位矩阵。
实验分析：1. 从矩阵加法与减法运算的结果可以看出，矩阵的加法和减法满足交换律、结合律和分配律。
这说明矩阵加法和减法具有良好的运算性质。
2. 从矩阵乘法运算的结果可以看出，矩阵的乘法满足结合律和分配律，但左乘右乘不一定相等，即AB≠BA。
矩阵相乘算法实验报告
矩阵相乘算法实验报告引言矩阵相乘是一种常见的数学运算。
在很多领域，如图像处理、机器学习等都会用到矩阵相乘。
因此，优化矩阵相乘的算法对加快计算速度具有重要意义。
本实验旨在比较不同算法在矩阵相乘问题中的性能表现，并探讨其优化的方法。
实验设计实验目的本实验主要有以下几个目的：1. 了解常见的矩阵相乘算法，包括传统的三重循环算法和Strassen算法；2. 比较不同算法的计算性能并分析其优缺点；3. 探讨优化矩阵相乘算法的方法，提高计算速度。
实验流程1. 设计矩阵相乘函数，实现传统的三重循环算法；2. 设计矩阵相乘函数，实现Strassen算法；3. 设计测试用例，并分别用三重循环算法和Strassen算法进行计算；4. 计算并比较两种算法的运行时间、计算复杂度和空间复杂度；5. 分析并探讨优化矩阵相乘算法的方法。
实验结果与分析传统的三重循环算法三重循环算法是最简单直观的矩阵相乘算法。
其思想是通过嵌套循环，对两个矩阵的每个元素进行相乘累加，最终得到结果矩阵。
这个算法的时间复杂度为O(n^3)，空间复杂度为O(n^2)。
Strassen算法Strassen算法是一种分治法的思想，它把矩阵相乘的问题转化为更小规模的子问题。
它通过将大矩阵分解成四个小矩阵，然后利用递归的方法求解，最后将四个小矩阵合并得到结果矩阵。
Strassen算法的时间复杂度为O(n^log2(7))，空间复杂度为O(n^2)。
实验结果假设设定矩阵的大小为n*n，我们随机生成了n=100、n=500、n=1000大小的两个矩阵进行实验。
实验结果表明，当矩阵较小（n=100）时，三重循环算法的运行时间略微快于Strassen算法。
但是随着矩阵规模的增大，Strassen算法的计算时间明显优于三重循环算法，尤其是在n=1000时，Strassen算法的优势更加明显。
对于计算复杂度，三重循环算法具有较高的时间复杂度，而Strassen算法的时间复杂度较低，这也是导致Strassen算法在大规模矩阵相乘时性能更好的原因之一。
矩阵相乘实验报告
一、实验目的1. 理解矩阵乘法的概念和运算规则。
2. 掌握C语言实现矩阵乘法的基本方法。
3. 学习并运用多线程技术优化矩阵乘法运算效率。
4. 熟悉Linux操作系统下多线程编程的使用。
二、实验环境1. 操作系统：Linux2. 编程语言：C语言3. 开发工具：GCC编译器三、实验内容1. 矩阵乘法原理矩阵乘法是指两个矩阵相乘的结果形成一个新的矩阵。
设矩阵A为m×k维，矩阵B为k×n维，则它们的乘积C为m×n维。
矩阵C中第i行、第j列的元素Ci,j等于矩阵A第i行元素与矩阵B第j列元素对应元素的乘积之和。
2. 矩阵乘法算法（1）单线程矩阵乘法单线程矩阵乘法是最基本的矩阵乘法算法，其核心思想是遍历矩阵A的每一行，同时遍历矩阵B的每一列，计算乘积之和。
具体步骤如下：① 初始化矩阵C为m×n维，将所有元素置为0。
② 遍历矩阵A的行i和矩阵B的列j，计算乘积之和C[i][j]。
③ 将计算得到的乘积之和C[i][j]赋值给矩阵C。
（2）多线程矩阵乘法多线程矩阵乘法利用多线程技术并行计算矩阵乘法，提高运算效率。
具体步骤如下：① 将矩阵A和矩阵B分割成若干个子矩阵，每个子矩阵由一个线程负责计算。
② 创建多个线程，每个线程分别计算一个子矩阵的乘积。
③ 等待所有线程计算完毕，将各个子矩阵的结果合并，得到最终的矩阵C。
3. 实验步骤（1）编写单线程矩阵乘法程序，实现矩阵乘法运算。
（2）编写多线程矩阵乘法程序，利用pthread库实现多线程编程。
（3）比较单线程和多线程矩阵乘法的运行时间，分析多线程优化效果。
四、实验结果与分析1. 实验数据实验中，我们选择两个4×4的矩阵A和B进行乘法运算，矩阵元素随机生成。
2. 实验结果（1）单线程矩阵乘法运行时间：约0.001秒（2）多线程矩阵乘法运行时间：约0.0008秒3. 分析通过实验结果可以看出，多线程矩阵乘法相较于单线程矩阵乘法，运行时间有显著提高。
矩阵计算实验报告
一、实验目的1. 掌握矩阵的基本概念和性质。
2. 熟悉MATLAB软件在矩阵计算中的应用。
3. 熟练运用MATLAB进行矩阵的创建、运算和可视化。
二、实验内容1. 矩阵的创建与引用（1）创建矩阵在MATLAB中，可以使用多种方法创建矩阵，如直接输入矩阵元素、使用冒号操作符、使用linspace和logspace函数等。
例如，创建一个3x4的矩阵A：A = [1, 2, 3, 4; 5, 6, 7, 8; 9, 10, 11, 12];（2）引用矩阵元素可以使用行列索引来引用矩阵元素。
例如，引用矩阵A的第1行第2列元素：A(1, 2)2. 矩阵的运算（1）矩阵的加法与减法矩阵的加法与减法运算满足交换律和结合律，且只适用于相同维度的矩阵。
例如，计算矩阵A与矩阵B的和：B = [1, 2, 3; 4, 5, 6];C = A + B（2）矩阵的乘法矩阵乘法满足分配律，且左乘和右乘满足结合律。
例如，计算矩阵A与矩阵B的乘积：D = A B（3）矩阵的逆若矩阵A是可逆的，则存在矩阵A的逆，记为A^(-1)。
A^(-1)满足以下性质：A A^(-1) = A^(-1) A = I其中，I是单位矩阵。
例如，计算矩阵A的逆：E = inv(A)（4）矩阵的秩矩阵的秩是指矩阵中线性无关的行（或列）的最大数目。
例如，计算矩阵A的秩：rank(A)（5）矩阵的迹矩阵的迹是指矩阵对角线元素之和。
例如，计算矩阵A的迹：trace(A)3. 矩阵的可视化（1）绘制矩阵元素可以使用MATLAB的scatter函数绘制矩阵元素。
例如，绘制矩阵A的元素：scatter(1:size(A, 1), 1:size(A, 2), A)（2）绘制矩阵特征值可以使用MATLAB的eig函数计算矩阵的特征值，并使用plot函数绘制特征值。
例如，计算矩阵A的特征值并绘制：[V, D] = eig(A);plot(diag(D))三、实验步骤1. 打开MATLAB软件，创建一个新的M文件。
矩阵运算实验报告
实验报告-矩阵运算一.实验目的。
1. 通过实践加强对程序设计语言课程知识点的理解和掌握，培养对课程知识综合运用能力、实际分析问题能力及编程能力，养成良好的编程习惯。
2. 通过实践进一步领会程序设计的特点和应用，提高运用C++语言以及面向对象知识解决实际问题的能力。
3. 通过实践掌握用C++语言编写面向对象的实用程序的设计方法，对面向对象方法和思想增加感性的认识；4. 学会利用C++g序设计语言编写出一些短小、可靠的Windows实用程序，切实提高面向对象的程序设计能力。
为后续的相尖课程的学习打下基础°二.实验要求。
1 •学会建立模板类；2. 实现矩阵的加”减”乘”数乘”转置”；3. 动态内存分配并用随机数填充；4. 注意加”减”乘”要进行条件的判断；二.设计思路。
3.1算法基本流程1）获取用户输入的矩阵1的行数和列数，动态生成一个一维数组2）利用随机数生成数组成员，并利用两个循环输出数组，使其符合矩阵的格式3）矩阵2同矩阵1的处理方法4）通过两个矩阵的行数和列数比较来判断能否进行加减乘等运算，如不能，输出相矢信息5）如能够进行计算，则利用数组进行相应运算，并按照正确格式输出6）通过改变一维数组中元素的顺序来实现转宜并输出3.2算法流程图随机创建摯错误信乘数礙女:数组各元素四•基本界面/f"\ NT 幺.ZQ ni fa |> D Q I LI I 冋I 貝] 无标盏•距阵 药矩阵相关运宜 ■atrixl 行： 列： MatrixlMatrix2HttnxZMatrix! r Matnx2列：10行：Io10 10 第1矩腐 I Mtlrixl 厂 + 厂• M<trix2 厂•厂数乗运算-结果如下第漸五•矢键代码。
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_pEleme nts;}; 一5.2另键函数代码void CMyView::O nCHECKadd(){m_nums.SetCheck(O);m_combi ne.SetCheck(O); m_subtrict.SetCheck(O);}_void CMyView::O nCHECKsubtrict(){m_add.SetCheck(O);m_combi ne.SetCheck(O); m_nums.SetCheck(O);}_void CMyView::O nCHECKcombi ne(){m_add.SetCheck(O);m_nums.SetCheck(O); m_subtrict.SetCheck(O);}void CMyView::O nCHECK nums(){m_add.SetCheck(O);m_combi ne.SetCheck(O);m_subtrict.SetCheck(O);}void CMyView::O nBUTTONcompute(){UpdateData(TRUE);// TODO: Add your con trol no tificatio n han dler code hereif(m_add.GetState()==1){_if(op1->imax!=op2->imax||op1->jmax!=op2->jmax||op1==NULL||op2==NU LL)nuresulti行数列数不等无法相加!“；}else{matrixvint> c(op1 ->imax,op1 ->jmax); c=*op1+*op2;m_result=H matrix1 +matrix2H;m_result+=H\r\rT;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{matrixvint> c(op1 ->imax,op1 ->jmax);c=*op1-*op2;m_result=H matrix1 -matrix2'1;m_result+=H\r\rT;m_result+=c.my_show();}——}else if(m_comb in e.GetState()==1){_ if(op1->jmax!=op2->imax||op1==NULL||op2==NULL){m_result=-以上无法相乘!”;}_else{matrixvint> c(op1->imax,op2->jmax);c=(*op1)*(*op2);m_result=H matrix1 *matrix2n;m_result+=H\r\rT;m_result+=c.my_show();}else if(m _nu ms.GetState()==1){_if(op2==NULL){ m_result="运算不出结果!“；}else{matrixv int> c(op2->imax,op2->jmax); c=m_k*(*op2);m_result=H k*matrix2n; m_result+=H\r\rT; m_result+=c.my_show();}——}else{m_result="请先选定一个算法!”；}UpdateData(FALSE);void CMyView::O nBUTTONrotate(){UpdateData(TRUE); if(m_r1 .GetState()==1){_ if(O pl==NULL){ m_result="W先输入矩阵!”；}else{matrixvint> c=rotate(*op1); m_result=n matrix1 转置：m_result+=H\r\n H; m_result+=c.my_show();}——}else if(m_r2.GetState()== 1)if(op2==NULL)m_result=n W先输入矩阵!“;else{matrixvi nt> c=rotate(*op2);m_result="matrix2 转置";m_result+="\r\n";m_result+=c.my_show();}}else{m_result=n m选择一个矩阵!”；}-UpdateData(FALSE);}void CMyView::O nCHECKr1(){UpdateData(TRUE); m_r2.SetCheck(0);UpdateData(FALSE);}void CMyView::O nCHECKr2(){UpdateData(TRUE); m_r1 .SetCheck(O);UpdateData(FALSE);}六.实验心得与编程收获。
- 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++深入详解鑫编。