下载文档原格式
一、实验目的和要求（1）掌握各种特殊矩阵如对称矩阵、上下三角矩阵和对角矩阵的压缩存储方法。
（2）掌握稀疏矩阵的各种存储结构以及基本运算实现算法。
（3）掌握广义表的递归特性、存储结构以及基本运算实现算法。
二、实验环境、内容和方法实验内容：①打开Visual C++6.0并输入实验指导书上的程序，并进行调试和运行。
②自行尝试编写第六个实验。
实验方法：（一）综合运用课本所学的知识，用不同的算法实现在不同的程序功能。
（二）结合指导老师的指导，解决程序中的问题，正确解决实际中存在的异常情况，逐步改善功能。
（三）根据实验内容，编译程序。
实验环境：Windows xp Visual C++6.0三、实验过程描述实验①以下是一个5*5阶的螺旋方阵。
设计一个程序输出该形式的n*n阶方阵。
1 2 3 4 516 17 18 19 615 24 25 20 714 23 22 21 813 12 11 10 9一、打开Visual C++6.0并输入如下程序#include <stdio.h>#define MaxLen 10void fun(int a[MaxLen][MaxLen],int n){int i,j,k=0,m;if (n%2==0)m=n/2;elsem=n/2+1;for (i=0;i<m;i++){for (j=i;j<n-i;j++){k++;a[i][j]=k;}for (j=i+1;j<n-i;j++){k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;a[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("\n");printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}printf("\n");}二、,编译并连接此程序，如图三、运行此程序，如图实验②假设n*n的稀疏矩阵A采用三元组表示，设计一个程序实现如下功能：（1）生成如下两个稀疏矩阵的三元组a和b：a:1 0 3 0 b: 3 0 0 00 1 0 0 0 4 0 00 0 1 0 0 0 1 00 0 1 1 0 0 0 2(2)输出a转置矩阵的三元组(3)输出a+b的三元组(4) 输出a*b的三元组一、输入如图所示程序#include <stdio.h>#define N 4typedef int ElemType;#define MaxSize 100typedef struct{ int r;int c;ElemType d;} TupNode;typedef struct{ int rows;int cols;int nums;TupNode data[MaxSize];} TSMatrix;void CreatMat(TSMatrix &t,ElemType A[N][N]){int i,j;t.rows=N;t.cols=N;t.nums=0;for (i=0;i<N;i++){for (j=0;j<N;j++)if (A[i][j]!=0){t.data[t.nums].r=i;t.data[t.nums].c=j;t.data[t.nums].d=A[i][j];t.nums++;}}}void DispMat(TSMatrix t){int i;if (t.nums<=0)return;printf("\t%d\t%d\t%d\n",t.rows,t.cols,t.nums);printf("\t------------------\n");for (i=0;i<t.nums;i++)printf("\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d); }void TranMat(TSMatrix t,TSMatrix &tb){int p,q=0,v;tb.rows=t.cols;tb.cols=t.rows;tb.nums=t.nums;if (t.nums!=0){for (v=0;v<t.cols;v++)for (p=0;p<t.nums;p++)if (t.data[p].c==v){tb.data[q].r=t.data[p].c;tb.data[q].c=t.data[p].r;tb.data[q].d=t.data[p].d;q++;}}}int MatAdd(TSMatrix a,TSMatrix b,TSMatrix &c) {int i=0,j=0,k=0;ElemType v;if (a.rows!=b.rows || a.cols!=b.cols)return 0;c.rows=a.rows;c.cols=a.cols;while (i<a.nums && j<b.nums){if (a.data[i].r==b.data[j].r){if(a.data[i].c<b.data[j].c){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else if (a.data[i].c>b.data[j].c){c.data[k].r=b.data[j].r;c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}else{v=a.data[i].d+b.data[j].d;if (v!=0){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=v;k++;}i++;j++;}}else if (a.data[i].r<b.data[j].r){c.data[k].r=a.data[i].r;c.data[k].c=a.data[i].c;c.data[k].d=a.data[i].d;k++;i++;}else{c.data[k].r=b.data[j].r;c.data[k].c=b.data[j].c;c.data[k].d=b.data[j].d;k++;j++;}c.nums=k;}return 1;}int value(TSMatrix c,int i,int j){int k=0;while (k<c.nums && (c.data[k].r!=i || c.data[k].c!=j)) k++;if (k<c.nums)return(c.data[k].d);elsereturn(0);}int MatMul(TSMatrix a,TSMatrix b,TSMatrix &c){int i,j,k,p=0;ElemType s;if (a.cols!=b.rows)return 0;for (i=0;i<a.rows;i++)for (j=0;j<b.cols;j++){s=0;for (k=0;k<a.cols;k++)s=s+value(a,i,k)*value(b,k,j);if (s!=0){c.data[p].r=i;c.data[p].c=j;c.data[p].d=s;p++;}}c.rows=a.rows;c.cols=b.cols;c.nums=p;return 1;}void main(){ElemType a1[N][N]={{1,0,3,0},{0,1,0,0},{0,0,1,0},{0,0,1,1}};ElemType b1[N][N]={{3,0,0,0},{0,4,0,0},{0,0,1,0},{0,0,0,2}};TSMatrix a,b,c;CreatMat(a,a1);CreatMat(b,b1);printf("a的三元组:\n");DispMat(a);printf("b的三元组:\n");DispMat(b);printf("a转置为c\n");TranMat(a,c);printf("c的三元组:\n");DispMat(c);printf("c=a+b\n");MatAdd(a,b,c);printf("c的三元组:\n");DispMat(c);printf("c=a*b\n");MatMul(a,b,c);printf("c的三元组:\n");DispMat(c);}二、程序运行结果如图实验③编写一个程序实现广义表的各种运算，并在此基本上设计一个程序完成如下功能：（1）建立广义表g=“(b,(b,a,(#),d),((a,b),c,((#))))”的链式存储结构；（2）输出广义表g的长度；（3）输出广义表g的深度；（4）输出广义表g的最大原子；一、输入如图所示程序#include <stdio.h>#include <malloc.h>typedef char ElemType;typedef struct lnode{ int tag;union{ElemType data;struct lnode *sublist;}val;struct lnode *link;} GLNode;GLNode *CreatGL(char *&s){GLNode *h;char ch;ch=*s++;if (ch!='\0'){h=(GLNode *)malloc(sizeof(GLNode));if (ch=='('){h->tag=1;h->val.sublist=CreatGL(s);}else if (ch==')')h=NULL;else{h->tag=0;h->val.data=ch;}}else h=NULL;ch=*s++;if (h!=NULL)if (ch==',')h->link=CreatGL(s);elseh->link=NULL;return h;}int GLLength(GLNode *g){int n=0;g=g->val.sublist;while (g!=NULL){n++;g=g->link;}return n;}int GLDepth(GLNode *g){int max=0,dep;if (g->tag==0)return 0;g=g->val.sublist;if (g==NULL)return 1;while (g!=NULL){if (g->tag==1){dep=GLDepth(g);if (dep>max) max=dep;}g=g->link;}return(max+1);}void DispGL(GLNode *g){if (g!=NULL){if (g->tag==1){printf("(");if (g->val.sublist==NULL) printf("");else DispGL(g->val.sublist);}else printf("%c", g->val.data);if (g->tag==1) printf(")");if (g->link!=NULL){printf(",");DispGL(g->link);}}}void main(){GLNode *g;char *str="(b,(b,a,a),((a,b),c))";g=CreatGL(str);printf(" 广义表g:");DispGL(g);printf("\n");printf(" 广义表g的长度:%d\n",GLLength(g));printf(" 广义表g的深度:%d\n",GLDepth(g));printf("\n");}二、程序运行结果如图。
matlab矩阵实验报告《MATLAB矩阵实验报告》摘要：本实验报告利用MATLAB软件进行了矩阵实验，通过对矩阵的运算、转置、逆矩阵、特征值等操作进行了分析和讨论。
实验结果表明，MATLAB在矩阵运算方面具有高效、准确的特点，能够满足工程和科学计算的需求。
引言：矩阵是线性代数中的重要概念，广泛应用于工程、物理、经济等领域。
MATLAB是一种强大的数学软件，能够对矩阵进行各种运算和分析。
本实验旨在利用MATLAB软件对矩阵进行实验，探讨其在矩阵运算中的应用和优势。
实验方法：1. 创建矩阵：利用MATLAB软件创建不同大小的矩阵，包括方阵和非方阵。
2. 矩阵运算：进行矩阵的加法、减法、乘法等运算，比较不同大小矩阵的计算效率和结果准确性。
3. 矩阵转置：对矩阵进行转置操作，观察转置后矩阵的性质和应用。
4. 逆矩阵：求解矩阵的逆矩阵，并分析逆矩阵在实际问题中的应用。
5. 特征值和特征向量：利用MATLAB软件求解矩阵的特征值和特征向量，分析其在物理、工程等领域的应用。
实验结果与讨论：通过实验发现，MATLAB软件在矩阵运算中具有高效、准确的特点。
对于大规模矩阵的运算，MATLAB能够快速进行计算并给出准确的结果。
在矩阵转置和逆矩阵求解方面，MATLAB也能够满足工程和科学计算的需求。
此外，通过求解矩阵的特征值和特征向量，可以得到矩阵的重要性质，为实际问题的分析和求解提供了有力支持。
结论：本实验利用MATLAB软件进行了矩阵实验，通过对矩阵的运算、转置、逆矩阵、特征值等操作进行了分析和讨论。
实验结果表明，MATLAB在矩阵运算方面具有高效、准确的特点，能够满足工程和科学计算的需求。
希望本实验能够对矩阵运算和MATLAB软件的应用有所启发，为相关领域的研究和应用提供参考。
实验三矩阵类的设计与实现一、实验目的通过上机实践，巩固课堂老师所讲关于矩阵设计的知识，通过反复的调试，找错，设计出矩阵。
二、实验过程#include<iostream.h>#include<stdlib.h>#include<math.h>#include<stdio.h>class XXXMatrix{private:int rows,columns;double **element;public:XXXMatrix(int rows=4,int columns=4);XXXMatrix(int *mat,int rows,int columns);XXXMatrix(const XXXMatrix& m);~XXXMatrix();int rintv(int n,double a[][4]);XXXMatrix& inverse(XXXMatrix& mat);XXXMatrix& transpose(double a[][4]);void init(int rows,int columns);double get(int i,int j);bool set(int i,int j,int value);friend ostream& operator <<(ostream& out,XXXMatrix &mat);XXXMatrix& operator +=(XXXMatrix& mat);XXXMatrix& operator=(const XXXMatrix& mat);bool operator==(const XXXMatrix& mat);bool operator!=(const XXXMatrix& mat);XXXMatrix& operator-(XXXMatrix& mat);XXXMatrix& operator-();XXXMatrix& operator*(XXXMatrix& mat);};void XXXMatrix::init(int rows,int columns) {if(rows<=0||columns<=0)throw"矩阵行或列数非正数异常";this->rows=rows;this->columns=columns;element=new double *[rows];for(int i=0;i<rows;i++){element[i]=new double[columns];for(int j=0;j<columns;j++)element[i][j]=0;}}XXXMatrix::XXXMatrix(int rows,int columns) {init(rows,columns);}XXXMatrix::XXXMatrix(int *mat,int rows,int columns){init(rows,columns);for(int i=0;i<rows;i++)for(int j=0;j<columns;j++)element[i][j]=*(mat+i*columns+j);}XXXMatrix::XXXMatrix(const XXXMatrix& m) {init(m.rows,m.columns);for(int i=0;i<m.rows;i++)for(int j;j<m.columns;j++)element[i][j]=m.element[i][j]; }XXXMatrix::~XXXMatrix(){for(int i=0;i<rows;i++)delete(element[i]);delete(element);}double XXXMatrix::get(int i,int j){if(i>=0&&i<rows&&j>=0&&j<columns)return element[i][j];}bool XXXMatrix::set(int i,int j,int value){if(i>=0&&i<rows&&j>=0&&j<columns){element[i][j]=value;return true;}return false;}ostream& operator<<(ostream& out,XXXMatrix& mat){out<<"矩阵XXXMatrix("<<mat.rows<<"x"<<mat.columns< <")"<<endl;for(int i=0;i<mat.rows;i++){for(int j=0;j<mat.columns;j++)out<<mat.element[i][j]<<" ";out<<"\n";}return out;}XXXMatrix& XXXMatrix:: operator=(const XXXMatrix& mat){if(this->rows==mat.rows&&this->column s==mat.columns){for(int i=0;i<mat.rows;i++)for(int j=0;j<mat.columns;j++)element[i][j]=mat.element[i][j];return *this;}throw"两个矩阵阶数不同，不能相加"; }bool XXXMatrix:: operator==(const XXXMatrix& mat){if(this->rows==mat.rows&&this->column s==mat.columns){for(int i=0;i<mat.rows;i++){for(int j=0;j<mat.columns;j++)if(this->element[i][j]!=mat.element[i][j]){break;return false;}elsereturn true;}}}bool XXXMatrix:: operator!=(const XXXMatrix& mat){if(this->rows==mat.rows&&this->column s==mat.columns){for(int i=0;i<mat.rows;i++){for(int j=0;j<mat.columns;j++)if(this->element[i][j]==mat.element[i][j]){break;return false;}elsereturn true;}}}XXXMatrix& XXXMatrix:: operator-( XXXMatrix& mat){if(this->rows==mat.rows&&this->column s==mat.columns){for(int i=0;i<mat.rows;i++)for(int j=0;j<mat.columns;j++)element[i][j]-=mat.element[i][j];return *this;}throw"两个矩阵阶数不同，不能相加"; }XXXMatrix& XXXMatrix::operator-(){for(int i=0;i<this->rows;i++)for(int j=0;j<this->columns;j++)this->element[i][j]=-this->element[i][j];return *this;throw"两个矩阵阶数不同，不能相加"; }XXXMatrix&XXXMatrix::operator*(XXXMatrix& mat){int i,j,k;double s;for(i=0;i<mat.rows;i++)for(j=0;j<mat.columns;j++){s=0.0;for(k=0;k<mat.columns;k++)s=s+mat.element[i][k]*this->element[k][j ];this->element[i][j]=s;}return *this;}XXXMatrix& XXXMatrix::inverse(XXXMatrix& mat){if(this->rows==mat.columns&&this->colu mns==mat.rows)for(int i=0;i<mat.columns;i++)for(int j=0;j<mat.rows;j++)this->element[i][j]=mat.element[j][i];return *this;}int XXXMatrix::rintv(int n,double a[][4]) {int *is,*js,i,j,k,u,v;double p,d;is=(int *) malloc(n*sizeof(int));js=(int *) malloc(n*sizeof(int));for(k=0;k<=n-1;k++){d=0.0;for(i=k;i<=n-1;i++)for(j=k;j<=n-1;j++){p=fabs(a[i][j]);if(p>d){d=p;is[k]=i;js[k]=j;}}if(d+1.0==1.0){free(is);free(js);printf("err**not inv\n");return(0);}if(is[k]!=k)for(j=0;j<=n-1;j++){p=a[k][j];a[k][j]=a[is[k]][j];a[is[k]][j]=p;}if(js[k]!=k)for(i=0;i<=n-1;i++){u=i*n+k;v=i*n+js[k];p=a[i][k];a[i][k]=a[i][js[k]];a[i][js[k]]=p;}a[k][k]=1.0/a[k][k];for(j=0;j<=n-1;j++)if(j!=k){u=k*n+j;a[k][j]=a[k][j]*a[k][k];}for(i=0;i<=n-1;i++)if(i!=k) for(j=0;j<=n;j++)if(j!=k){a[i][j]=a[i][j]-a[i][k]*a[k][j];} for(i=0;i<=n-1;i++)if(i!=k){a[i][k]=-a[i][k]*a[k][k];}}for(k=n-1;k>=0;k--){if(js[k]!=k)for(j=0;j<=n-1;j++){p=a[k][j];a[k][j]=a[js[k]][j];a[js[k]][j]=p;}if(is[k]!=k)for(i=0;i<n-1;i++){p=a[i][k];a[i][k]=a[i][is[k]];a[i][is[k]]=p;}}free(is);free(js);return (1);}XXXMatrix& XXXMatrix::transpose(double a[][4]){int q;q=rintv(4,a);for(int i=0;i<this->rows;i++)for(int j=0;j<this->columns;j++)this->element[i][j]=a[i][j];return *this;}XXXMatrix&XXXMatrix::operator+=(XXXMatrix& mat) {if(this->rows==mat.rows&&this->column s==mat.columns){for(int i=0;i<mat.rows;i++)for(int j=0;j<mat.columns;j++)element[i][j]+=mat.element[i][j];return *this;}throw"两个矩阵阶数不同，不能相加"; }int main(){const int M=3,N=4;static double a[4][4]={{0.5,0.0,0.0,0.0},{0.0,0.5,0.0,0.0},{0.0, 0.0,0.5,0.0},{0.0,0.0,0.0,0.5}};cout<<"待求逆矩阵为:"<<endl;for(int i=0;i<=3;i++){for(int j=0;j<=3;j++)cout<<a[i][j]<<" ";cout<<endl;}XXXMatrix B(3,4),C(4,3),D(4,4);D.transpose(a); //求逆cout<<"求逆后的矩阵为"<<D;int table1[M*N]={1,0,0,0,0,1};XXXMatrix mat1(table1,M,N); //矩阵1mat1.set(2,2,1);B=mat1;int table2[M][N]={1,2,3,4,5,6,7,8,9};XXXMatrix mat2(*table2,M,N); //矩阵2cout<<"矩阵P为"<<endl;cout<<mat1;cout<<"和P相等的矩阵Q为"<<endl; //赋值cout<<B;if(mat1==B)cout<<"两矩阵相等!!!"<<endl; //相等-B;cout<<"负的矩阵-Q"<<endl; //求负值cout<<B;cout<<"矩阵R为"<<endl;cout<<mat2;mat1+=mat2; //+=mat2-mat1;mat2-mat1;//相减cout<<"矩阵相加S=P+R\n"<<mat1;cout<<"矩阵相减R-S-S\n"<<mat2;if(mat1!=B)cout<<"两矩阵不再相等!!!"<<endl; //!=C.inverse(B);cout<<"转置"<<C; //转置return 0;}三、实验成果四、实验体会由于矩阵设计的成员函数较多，操作起来不是很容易，在上机过程中遇到很多困难，但是通过老师指导，经过多次调试，终于成功了。
python矩阵及其基本运算实验报告-回复Python矩阵及其基本运算实验报告一、引言矩阵（Matrix）是线性代数中的重要概念之一，常用于表示和解决线性方程组、向量运算、最小二乘拟合等问题。
在本实验中，我们将探讨矩阵在Python编程语言中的实现方式以及基本运算。
二、实验目的1. 理解矩阵的概念及其在线性代数中的重要性；2. 掌握利用Python编程语言创建矩阵的方法；3. 掌握矩阵的基本运算，包括矩阵加法、矩阵减法、矩阵乘法、转置等操作；4. 利用实例演示矩阵运算的应用场景。
三、实验过程1. 矩阵的表示在Python中，可以使用嵌套列表（Nested List）来表示矩阵。
例如，我们可以用一个3x3的矩阵表示为：matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]]其中，每一行为一个子列表，表示矩阵的一行。
2. 矩阵的加法和减法矩阵的加法和减法在概念上非常简单，即对应元素相加或相减。
在Python 中，我们可以通过嵌套循环来实现这两种运算。
例如，对于两个相同维度的矩阵A和B，它们的加法运算可以表示为：C = [[0, 0, 0],[0, 0, 0],[0, 0, 0]]for i in range(len(A)):for j in range(len(A[0])):C[i][j] = A[i][j] + B[i][j]减法运算的代码与加法运算类似，只需要将相加的操作符改为减号。
3. 矩阵的乘法矩阵的乘法是矩阵运算中的一个重要操作，它不仅涉及到元素相乘，还需要将相乘的结果按照一定规则相加。
在Python中，可以利用嵌套循环来实现矩阵的乘法运算。
考虑两个矩阵A和B相乘的情况，其中A的维度为m×n，B的维度为n ×p，则它们的乘积C的维度为m×p。
乘法运算的代码如下所示：C = [[0, 0, 0],[0, 0, 0],[0, 0, 0]]for i in range(len(A)):for j in range(len(B[0])):for k in range(len(B)):C[i][j] += A[i][k] * B[k][j]在上述代码中，通过三层循环来计算矩阵C的每个元素，其中i、j、k分别代表矩阵C的行、列和矩阵A、B的对应元素。
第1篇一、实验目的1. 理解矩阵的基本概念及其应用。
2. 掌握矩阵的创建、显示、赋值、转置、求逆、求行列式等基本操作。
3. 熟悉C语言在矩阵操作中的应用。
二、实验环境1. 操作系统：Windows 102. 编译器：Visual Studio 20193. 语言：C语言三、实验内容1. 矩阵的创建与赋值2. 矩阵的显示3. 矩阵的转置4. 矩阵的求逆5. 矩阵的行列式求解6. 矩阵的加法、减法、乘法四、实验步骤1. 创建矩阵```cinclude <stdio.h>define MAX_SIZE 10int main() {int matrix[MAX_SIZE][MAX_SIZE];int row, col, i, j;printf("请输入矩阵的行数和列数：\n");scanf("%d %d", &row, &col);printf("请输入矩阵的元素：\n");for (i = 0; i < row; i++) {for (j = 0; j < col; j++) {scanf("%d", &matrix[i][j]);}}return 0;}```2. 显示矩阵```cvoid printMatrix(int matrix[][MAX_SIZE], int row, int col) { int i, j;for (i = 0; i < row; i++) {for (j = 0; j < col; j++) {printf("%d ", matrix[i][j]);}printf("\n");}}```3. 矩阵转置```cvoid transposeMatrix(int matrix[][MAX_SIZE], int row, int col, int transposed[][MAX_SIZE]) {int i, j;for (i = 0; i < row; i++) {for (j = 0; j < col; j++) {transposed[j][i] = matrix[i][j];}}}```4. 矩阵求逆```c// 略，求逆算法较为复杂，可参考相关资料```5. 矩阵的行列式求解```c// 略，行列式求解算法较为复杂，可参考相关资料```6. 矩阵的加法、减法、乘法```cvoid addMatrix(int matrix1[][MAX_SIZE], int matrix2[][MAX_SIZE], int row, int col, int result[][MAX_SIZE]) {int i, j;for (i = 0; i < row; i++) {for (j = 0; j < col; j++) {result[i][j] = matrix1[i][j] + matrix2[i][j];}}}void subtractMatrix(int matrix1[][MAX_SIZE], int matrix2[][MAX_SIZE],int row, int col, int result[][MAX_SIZE]) {int i, j;for (i = 0; i < row; i++) {for (j = 0; j < col; j++) {result[i][j] = matrix1[i][j] - matrix2[i][j];}}}void multiplyMatrix(int matrix1[][MAX_SIZE], int matrix2[][MAX_SIZE],int row1, int col1, int col2, int result[][MAX_SIZE]) {int i, j, k;for (i = 0; i < row1; i++) {for (j = 0; j < col2; j++) {result[i][j] = 0;for (k = 0; k < col1; k++) {result[i][j] += matrix1[i][k] matrix2[k][j];}}}}```五、实验结果与分析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）使用矩阵分解方法解方程组。
一、实验目的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); % 特征值```五、实验总结通过本次实验，我们掌握了矩阵的基本概念、创建方法、基本运算和常用函数。
一、实验目的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 ∈C m ×n ，s 1，s 2，…，s r 是A 的非零奇异值，则存在m 阶酉矩阵U ∈C m×n及n 阶酉矩阵V ，m ×n 矩阵D ，D= 10000000000000r s s 骣琪琪鬃?琪琪琪琪桫= 000骣S 琪琪桫 使得A=UDVH 这就是矩阵A 的奇异值分解。
2、算法第一步：求出AHA 的特征值1λ≥2λ≥…≥r λ＞0=1r λ+=…=n λ，确定非零奇异值i si=1,2，…，r 。
第二步：分别求出矩阵A H A 的对应于特征值i λ的特征向量并将其单位正交化，得到标准正交向量组α1，α2，…，αn 令V=（α1，α2，…，αn ）=（V1，V2），V1=（α1，α2，…，αr ），V2=（αr+1，αr+2，…，αn ）。
第三步：若U=（γ1，γ2，…，γr ，γr+1，γr+2，…，γm ）=（U1，U2），其中U1=（γ1，γ2，…，γr ），U2=（γr+1，γr+2，…，γm ），则因（A α1，A α2，…，A αr ）=（s 1γ1，s 2γ2，…，s r γr ）即有U 1=A V 1 1-S 。
其中1-S =11121r s s s ---骣琪琪琪琪鬃?琪琪桫第四步：解方程组AAHy=0，对基础解系单位正交化可以求得γr+1，γr+2，…，γm ，令U=（γ1，γ2，…，γr ，γr+1，γr+2，…，γm ）。
3、程序及结果矩阵A=[1 0;0 1;1 0] 求矩阵A 的奇异值分解A=[1 0;0 1;1 0];A*A' ans =1 0 10 1 01 0 1>> A'*Aans =2 00 1第一步：求出AHA的特征值eig(A'*A)ans =21确定非零奇异值1.4142 ，1的特征向量并将其单位正交化第二步：分别求出矩阵AHA的对应于特征值i[v,d]=eig(A'*A)v =0 11 0d =1 00 2第三步：若U=（U1，U2）求U1，U2M=[1.4142 0;0 1]M =1.4142 00 1.0000>> N=inv(M)N =0.7071 00 1.0000>> U1=A*v*NU1 =0 1.00000.7071 00 1.0000解方程组AA H y=0 求U2r=rank(A*A')r =2>> y=null(A*A',r)y =0.7071-0.7071则U=(U1,U2)U2 =0 1.0000 0.70710.7071 0 00 1.0000 -0.7071D=[1.4142 0;0 1;0 0]D =1.4142 00 1.00000 0U2*D*v'ans =1.0000 00 1.00001.0000 0则有A= U2*D*v'实验二：矩阵奇LU 分解1、原理设A ∈C n ×n 若A 可以表示成一个下三角矩阵和一个上三角矩阵的乘积A=LU ，则称其为矩阵A 的LU 分解（三角分解）。
