利用初等行变换求矩阵的逆运算的代码
矩阵求逆代码
public static double MatrixValue(double[,] MatrixList, int Level) //求得|A| 如果为0 说明不可逆{//计算行列式的方法// a1 a2 a3// b1 b2 b3// c1 c2 c3// 结果为a1·b2·c3+b1·c2·a3+c1·a2·b3-a3·b2·c1-b3·c2·a1-c3·a2·b1(注意对角线就容易记住了）double[,] dMatrix = new double[Level, Level]; //定义二维数组，行列数相同for (int i = 0; i < Level; i++)for (int j = 0; j < Level; j++)dMatrix[i, j] = MatrixList[i, j]; //将参数的值，付给定义的数组double c, x;int k = 1;for (int i = 0, j = 0; i < Level && j < Level; i++, j++){if (dMatrix[i, j] == 0) //判断对角线上的数据是否为0{int m = i;for (; dMatrix[m, j] == 0; m++) ; //如果对角线上数据为0，从该数据开始依次往后判断是否为0if (m == Level) //当该行从对角线开始数据都为0 的时候返回0return 0;else{// Row change between i-row and m-rowfor (int n = j; n < Level; n++){c = dMatrix[i, n];dMatrix[i, n] = dMatrix[m, n];dMatrix[m, n] = c;}// Change value pre-valuek *= (-1);}}// Set 0 to the current column in the rows after current rowfor (int s = Level - 1; s > i; s--){x = dMatrix[s, j];for (int t = j; t < Level; t++)dMatrix[s, t] -= dMatrix[i, t] * (x / dMatrix[i, j]);}}double sn = 1;for (int i = 0; i < Level; i++){if (dMatrix[i, i] != 0)sn *= dMatrix[i, i];elsereturn 0;}return k * sn;}public static double[,] ReverseMatrix(double[,] dMatrix, int Level){double dMatrixValue =MatrixValue(dMatrix, Level);if (dMatrixValue == 0) return null; //A为该矩阵若|A| =0 则该矩阵不可逆返回空double[,] dReverseMatrix = new double[Level, 2 * Level];double x, c;// Init Reverse matrixfor (int i = 0; i < Level; i++) //创建一个矩阵（A|I）以对其进行初等变换求得其矩阵的逆{for (int j = 0; j < 2 * Level; j++){if (j < Level)dReverseMatrix[i, j] = dMatrix[i, j]; //该（A|I）矩阵前Level列为矩阵A 后面为数据全部为0elsedReverseMatrix[i, j] = 0;}dReverseMatrix[i, Level + i] = 1;//将Level+1行开始的Level阶矩阵装换为单位矩阵（起初的时候该矩阵都为0 现在在把对角线位置装换为1 ）//参考/gaosuzk/content/lljx/wzja/12/12-6.htm}for (int i = 0, j = 0; i < Level && j < Level; i++, j++){if (dReverseMatrix[i, j] == 0) //判断一行对角线是否为0{int m = i;for (; dMatrix[m, j] == 0; m++) ;if (m == Level)return null; //某行对角线为0的时候判断该行该数据所在的列在该数据后是否为0 都为0 的话不可逆返回空值else{// Add i-row with m-rowfor (int n = j; n < 2 * Level; n++) //如果对角线为0 则该i行加上m行m行为（初等变换要求对角线为1，0-->1先加上某行，下面在变1）dReverseMatrix[i, n] += dReverseMatrix[m, n];}}// 此时数据：第二行加上第一行为第一行的数据// 1 1 3 1 1 0// 1 0 1 0 1 0// 4 2 1 0 0 1//// Format the i-row with "1" startx = dReverseMatrix[i, j];if (x != 1) //如果对角线元素不为1 执行以下{for (int n = j; n < 2 * Level; n++)if (dReverseMatrix[i, n] != 0)dReverseMatrix[i, n] /= x; //相除使i行第一个数字为1}// Set 0 to the current column in the rows after current rowfor (int s = Level - 1; s > i; s--) //该对角线数据为1 时，这一列其他数据要转换为0{x = dReverseMatrix[s, j];// 第一次时// 1 1 3 1 1 0// 1 0 1 0 1 0// 4(x) 2 1 0 0 1//for (int t = j; t < 2 * Level; t++)dReverseMatrix[s, t] -= (dReverseMatrix[i, t] * x);//第一个轮回用第一行*4 减去第三行为第三行的数据依次类推// 1 1 3 1 1 0// 1 0 1 0 1 0// 0(x) -2 -11 -4 -4 1}}// Format the first matrix into unit-matrixfor (int i = Level - 2; i >= 0; i--)//处理第一行二列的数据思路如上就是把除了对角线外的元素转换为0{for (int j = i + 1; j < Level; j++)if (dReverseMatrix[i, j] != 0){c = dReverseMatrix[i, j];for (int n = j; n < 2 * Level; n++)dReverseMatrix[i, n] -= (c * dReverseMatrix[j, n]);}}double[,] dReturn = new double[Level, Level];for (int i = 0; i < Level; i++)for (int j = 0; j < Level; j++)dReturn[i, j] = dReverseMatrix[i, j + Level];//就是把Level阶的矩阵提取出来（减去原先为单位矩阵的部分）return dReturn;}static void Main(string[] args){double[,] dMatrix = new double[3, 3] { { 0, 1, 2 }, { 1, 0, 1 }, { 4, 2, 1 } };double[,] dReturn = ReverseMatrix(dMatrix,3);//执行上述转换如果不可逆返回null 可逆返回逆矩阵if (dReturn != null) //存储结果的矩阵不为空说明可逆{for (int i = 0; i < 3; i++)Console.WriteLine(string.Format("{0} {1} {2}",dReturn[i, 0], dReturn[i, 1], dReturn[i, 2])); //输出Console.ReadKey();}}//好久没接触过矩阵了，不得不翻课本搜资料的查/*无非就是不停的循环嵌套知道处理流程就行，这种问题最好还是自己钻研先有自己的思路并转化为代码然后再看别人的代码了解别人的思路则样才可以举一反三希望对你有所帮助*/。
初等行列变换求逆矩阵
1111
初等行列变换是一种用于求解逆矩阵的方法，其基本思想是通过对原始矩阵进行初等行变换，将其转换为单位矩阵，从而得到逆矩阵。
具体来说，对于$m\times n$矩阵$A$，施行一次初等行变换相当于在$A$的左边乘以相应$m$阶初等矩阵；对$A$施行一次初等列变换相当于在$A$的右边乘以相应的$n$阶初等矩阵。
由于初等矩阵都是可逆的，并且它们的逆矩阵也是初等矩阵。
因此，如果原始矩阵$A$可逆，那么可以通过对其进行初等行变换将其转换为单位矩阵。
在实际应用中，这种方法可以有效地求解逆矩阵，并且可以应用于其他矩阵运算，如判断矩阵是否可逆、解矩阵方程等。
需要注意的是，初等行列变换求逆矩阵的方法需要谨慎使用，因为在某些情况下可能会导致误差或错误。
在计算过程中，建议仔细检查每一步的计算结果，以确保结果的准确性。
矩阵求逆的几种算法
1.测量空间中的矩阵求逆Function Rect_yu(A()As Double,L As Long,C()As Double)As Double '矩阵求逆Dim T0 As DoubleDim T1 As DoubleDim T2 As DoubleDim T3 As DoubleDim B()As DoubleDim Num As DoubleDim Chay As LongDim Chax As LongChay =0Chax =0ReDim B(L -1,L -1)Num =0Dim add As Doubleadd =1 / Rect(A(),L)For T0 =0 To LFor T3 =0 To LFor T1 =0 To L -1If T1 < T0 ThenChax =0ElseChax =1End IfFor T2 =0 To L -1If T2 < T3 ThenChay =0ElseChay =1End IfB(T1,T2)=A(T1 +Chax,T2 +Chay)Next T2Next T1'Rect(B(),L -1)'调用求行列式值C(T3,T0)=Rect(B(),L -1)*add *((-1)^ (T0 +T3))Next T3Next T0End Function******************************************************************************** ******2.复杂的矩阵求逆Option Explicit'先写一个函数用于交换两个数的函数Private Sub swap(byref a As Double,byref b As Double)Dim c As Doublec = aa = bb = cEnd Sub'下面是求矩阵逆阵的函数Public Function Inv(m() As Double) As Double()Dim i As IntegerDim j As IntegerDim k As IntegerDim n As IntegerDim temp As Double'从第 k 行、第 k 列开始的右下角子阵中选取绝对值最大的元素，并记住次元素在的行号和列号，'在通过行交换和列交换将它交换到主元素位置上.这一步称为全选主元n = UBound(m, 1)Dim iw() As IntegerDim jw() As IntegerDim fMax As DoubleReDim iw(0To n), jw(0To n) As IntegerFor k = 0To nfMax = 0For i = k To nFor j = k To nIf Abs(m(i, j)) > fMax Then fMax = Abs(m(i, j))iw(k) = ijw(k) = jNext jNext iIf iw(k) <> k ThenFor i = 0To nswap m(k, i), m(iw(k), i)Next iEnd IfIf jw(k) <> k ThenFor i = 0To nswap m(i, k), m(i, jw(k))Next iEnd IfNext k''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''在m右边增加一个单位阵，构成一个m的增广矩阵mmDim mm() As DoubleReDim mm(0To n, 0To2 * n + 1)For i = 0To nFor j = 0To nmm(i, j) = m(i, j)Next jNext iFor i = 0To nFor j = n + 1To2 * n + 1If i = j - n - 1Thenmm(i, j) = 1Elsemm(i, j) = 0End IfNext jNext i'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''通过初等行变换(即高斯消去法)使原矩阵变为单位阵，则右边的单位阵即是原矩阵的逆阵For k = 0To n - 1For i = k + 1To ntemp = mm(i, k) / mm(k, k)For j = 0To2 * n + 1mm(i, j) = mm(i, j) - mm(k, j) * tempNext jNext iNext kFor k = n To1Step -1For i = k - 1To0Step -1temp = mm(i, k) / mm(k, k)For j = 2 * n + 1To0Step -1mm(i, j) = mm(i, j) - mm(k, j) * tempNext jNext iNext kFor i = 0To nDim s As Doubles = mm(i, i)For j = 0To2 * n + 1mm(i, j) = mm(i, j) / sNext jNext i'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''输出变换后的右边的矩阵For i = 0To nFor j = 0To nm(i, j) = mm(i, j + n + 1)Next jNext i'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''根据在全选主元过程中所记录的行、列交换的信息进行恢复，恢复的原则如下：在全选主元过程中，'先交换的行（列）后进行恢复；原来的行（列）交换用列（行）交换来恢复。
矩阵的逆C语言代码及报告
矩阵的逆，一，问题分析设原矩阵是C，其逆矩阵是B首先将B置为单位矩阵，然后用C和B构造一个新的矩阵(C,B), 用初等列变换, 将左边(即C)化为单位矩阵, 右半块(即B)就是原来C矩阵的逆。
首先我们需要先检验矩阵是否可逆二，源程序及注释。
#include <iostream.h>#define M 3#define N (2*M)int main(){int i,j,k;double a[M][M]={1,2,3,2,2,1,3,4,3};double result[M][M];double b[M][N];cout<<"请输入矩阵的值（默认大小为3*3的矩阵）："<<endl;for(i=0;i<M;i++){for(j=0;j<M;j++){cin>>a[i][j]; //输入矩阵b[i][j]=a[i][j];}}for(i=0;i<M;i++){for(j=M;j<N;j++){if(i==(j-M)){b[i][j]=1; //在矩阵右侧加一个特征矩阵（单位矩阵）}else{b[i][j]=0;}}} for(i=0;i<M;i++){if(b[i][i]==0){for(k=i;k<M;k++){if(b[k][k]!=0){for(int j=0;j<N;j++){double temp;temp=b[i][j];b[i][j]=b[k][j];b[k][j]=temp;}break;}}if(k==M){cout<<"该矩阵不可逆！"<<endl; }}for(j=N-1;j>=i;j--){b[i][j]/=b[i][i];}for(k=0;k<M;k++){if(k!=i){double temp=b[k][i];for(j=0;j<N;j++){b[k][j]-=temp*b[i][j];}}}} for(i=0;i<M;i++){for(j=3;j<N;j++){result[i][j-3]=b[i][j];}}for(i=0;i<M;i++){for(j=0;j<M;j++){cout<<result[i][j]<<" ";}cout<<endl;}return 0;}三，运行结果显示四，调试和运行程序过程中产生的问题及采取的措施：。
矩阵求逆的C++代码
矩阵求逆的C++代码按照算法导论上矩阵求逆的原理，写了个C++代码。
有A*X=I，则X为inv（A）。
1. ⽤⾼斯消元法对原矩阵LUP分解，使得PA=LU。
P为置换矩阵，为了使每次消元时取有列最⼤值的⾏。
L下三⾓阵，U上三⾓阵。
2. 根据分解结果求出线性⽅程组A*xi=ei的xi向量，ei是单位阵I的列向量i，则xi为X的对应列向量。
3. 把xi组合成X，即为逆矩阵。
struct LUPMat{float* L, *U, *P; //dim*dimint* pai; //dimint dim; //dimension of LUP, size is d*d};void DelLUPMat( LUPMat lm){delete [] lm.L;delete [] lm.U;delete [] lm.P;delete [] lm.pai;}void printMatrix(float* mat, int dim){for(int i=0; i<dim; i++){for(int j=0; j<dim; j++)printf("%2.2f ", mat[i*dim+j]);printf("\n");}}void printVector(float* vec, int dim){for(int i=0; i<dim; i++){printf("%2.2f ", vec[i]);}printf("\n");//LUP decomposition of dim*dim matrix LUPMat LUPDecomp(float *A, int dim){float* mat = new float[dim*dim];for(int i=0; i<dim; i++)for(int j=0; j<dim; j++)mat[i*dim+j] = A[i*dim+j];float* l = new float[dim*dim];float* u = new float[dim*dim];float* p = new float[dim*dim];int* pai = new int[dim]; //pai[i]=k, then p[i][k]=1 for(int i=0; i<dim; i++)pai[i] = i;float cmax; //max value of columnint maxLineNo; //line of cmaxfor(int k=0; k<dim; k++){//find max value of the k-th columncmax=0;for(int i=k; i<dim; i++){if(abs(mat[i*dim+k])>abs(cmax)){cmax = mat[i*dim+k];maxLineNo = i;}}if(cmax==0){printf("singular matrix!\n");exit(1);}int tmpk = pai[k];pai[k] = pai[maxLineNo];pai[maxLineNo] = tmpk;float tmpLn;//exchange linefor(int li=0; li<dim; li++)tmpLn = mat[k*dim+li];mat[k*dim+li] = mat[maxLineNo*dim+li];mat[maxLineNo*dim+li] = tmpLn;}//LU decompositionfor(int i=k+1; i<dim; i++){mat[i*dim+k] = mat[i*dim+k]/mat[k*dim+k];for(int j=k+1; j<dim; j++)mat[i*dim+j] = mat[i*dim+j] - mat[i*dim+k]*mat[k*dim+j]; }}for(int i=0; i<dim; i++){for(int j=0; j<dim; j++){if(i>j){l[i*dim+j] = mat[i*dim+j];u[i*dim+j] = 0;}else if(i==j){u[i*dim+j] = mat[i*dim+j];l[i*dim+j] = 1;}else{u[i*dim+j] = mat[i*dim+j];l[i*dim+j] = 0;}}}for(int i=0; i<dim; i++){for(int j=0; j<dim; j++)p[i*dim+j] = 0;p[i*dim+pai[i]] = 1;}LUPMat ret;ret.L = l;ret.U = u;ret.P = p;ret.pai = pai;ret.dim = dim;delete [] mat;return ret;}//testbenchvoid LUPDecomp_tb(){float mat[DIM*DIM] = {2, 0, 2, 0.6,3, 3, 4, -2,5, 5, 4, 2,-1, -2, 3.4, -1};printMatrix(mat, DIM);LUPMat lm = LUPDecomp(mat, DIM);cout<<"P = "<<endl;printMatrix(lm.P, DIM);cout<<"L = "<<endl;printMatrix(lm.L, DIM);cout<<"U = "<<endl;printMatrix(lm.U, DIM);DelLUPMat(lm);}float *SolveLinearEq(float* A, float* b, int dim) {LUPMat lm = LUPDecomp(A, dim);float* x = new float[dim];float* y = new float[dim];for(int i=0; i<dim; i++){y[i] = b[lm.pai[i]];for(int j=0; j<i; j++)y[i] -= y[j]*lm.L[i*dim+j];}//cout<<"y:"<<endl;printVector(y, dim);for(int i=dim-1; i>=0; i--){for(int j=dim-1; j>i; j--)y[i] -= lm.U[i*dim+j]*x[j];x[i] = y[i]/lm.U[i*dim+i];}//cout<<"y:"<<endl;printVector(y, dim);delete [] y;DelLUPMat(lm);return x;}void SolveLinearEq_tb(){const int dim=3;float A[dim*dim] ={1, 2, 0,3, 4, 4,5, 6, 3};cout<<"A: "<<endl;printMatrix(A, dim);float b[dim] ={3, 7, 8};float* x = SolveLinearEq(A, b, dim); cout<<"x: "<<endl;printVector(x, dim);delete [] x;}float* InverseMatrix(float *A, int dim) {float *invA = new float[dim*dim]; float *e = new float[dim];float *x;for(int i=0; i<dim; i++)e[i] = 0;for(int i=0; i<dim; i++){e[i] = 1;if(i>0) e[i-1]=0;x = SolveLinearEq(A, e, dim);// cout<<"No. "<<i<<" x: ";printVector(x, dim);// cout<<"e: ";printVector(e, dim);for(int j=0; j<dim; j++)invA[j*dim+i] = x[j];}delete [] x;return invA;}float* isInverse(float* A, float* invA, int dim){float* aij = new float[dim*dim];for(int i=0; i<dim; i++)for(int j=0; j<dim; j++){aij[i*dim+j]=0;for(int k=0; k<dim; k++)aij[i*dim+j] += A[i*dim+k]*invA[k*dim+j]; }return aij;}void InverseMatrix_tb(){const int dim=3;float A[dim*dim] ={1, 2, 0,3, 4, 4,5, 6, 3};cout<<"A: "<<endl;printMatrix(A, dim);float* invA = InverseMatrix(A, dim);cout<<"inverse of A: "<<endl;printMatrix(invA, dim);float* aij = isInverse(A, invA, dim); cout<<"A*invA:"<<endl;printMatrix(aij, dim);delete [] invA;delete [] aij;}测试程序的结果：。
矩阵代码大全(矩阵的逆、乘法、加法、行列式)(c++程序).wps
班级：数学112班学号：201112010222姓名：吕文辉报告日期：2012/12/17 实验代码：1.输入10个数进行排序：#include<iostream>using namespace std;int main(){int a[10],i,j,t;cout<<"input 10 numbers"<<endl;for(i=0;i<10;i++)cin>>a[i];for(i=0;i<10;i++)for(j=i+1;j<10;j++)if(a[i]>a[j]){t=a[j];a[j]=a[i];a[i]=t;}for(i=0;i<10;i++)cout<<a[i]<<" ";cout<<endl;return 0;}2.输入一个矩阵，输出一个矩阵：#include <iostream>#include <iomanip>using namespace std;const int m=2,n=3;int main(){int a[m][n],i,j,k=0;cout<<"input a array"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>a[i][j];for(i=0;i<m;i++)for(j=0;j<n;j++){ cout<<a[i][j]<<" ";k=k+1;if(k%(m+1)==0)cout<<endl;}cout<<endl;return 0;}3.矩阵转置的程序代码：#include <iostream>using namespace std;int const m=2,n=3;int main(){int i,j,k=0,kk=0;int a[m][n],b[n][m];for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>a[i][j];for(i=0;i<m;i++)for(j=0;j<n;j++)b[j][i]=a[i][j];cout<<"原来的矩阵a为："<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++){ cout<<a[i][j]<<" ";kk=kk+1;if(kk%n==0) cout<<endl; }cout<<"原来矩阵a的转置b矩阵是："<<endl;for(i=0;i<n;i++)for(j=0;j<m;j++){ cout<<b[i][j]<<" ";k=k+1;if(k%m==0) cout<<endl; }cout<<endl;return 0;}4.矩阵乘法的代码程序：#include <iostream>#include <iomanip>using namespace std;int const m=3,n=3,q=3;int main(){ double a[m][n],b[n][q],c[m][q];int i,j,k,kk=0;cout<<"输入矩阵a"<<endl;for(i=0;i<m;i++)for(j=0;j<n;j++)cin>>a[i][j];cout<<"输入矩阵b："<<endl;for(i=0;i<n;i++)for(j=0;j<q;j++)cin>>b[i][j];for(i=0;i<m;i++)for(j=0;j<q;j++){ c[i][j]=0;for(k=0;k<n;k++)c[i][j]=c[i][j]+a[i][k]*b[k][j];}cout<<"矩阵c为矩阵a与b的乘积"<<endl;for(i=0;i<m;i++)for(j=0;j<q;j++){ cout<<setw(7)<<c[i][j];kk=kk+1;if(kk%q==0) cout<<endl;}return 0;}5求矩阵的行列式（即矩阵必须为方阵（n×n））;原理：将一个矩阵经过初等行变换化为上三角矩阵。
矩阵求逆函数C语言源代码---原创----请勿传播!
矩阵求逆函数C语言源代码---原创----请勿传播!#include#include#define MC NR#define NR 5 //只需在此修改矩阵的行数，然后准备好矩阵文件，结果在weng_out.txt文件中void ArrayOut(long double *p,int m,int n);void MatDiv(long double *b,int m,long double *c);void main(){long double A[NR][MC]={0.0},AT[MC][NR]={0.0},C[NR][MC]={0.0};int i=0,j=0;FILE *fp=NULL;//----------------------------------读取文件--------------------fp=fopen("weng.txt","r+");for(i=0;i<nr*mc;i++){< bdsfid="79" p=""></nr*mc;i++){<> fscanf(fp,"%lf",(*A+i) );if(fgetc(fp)==EOF) break;}fclose(fp);printf("读取的文件：\n");ArrayOut(*A,NR,MC);printf("---------------------\n");MatDiv(*A,NR,*C);ArrayOut(*C,NR,MC);//-------------------------------------------------------------------fp=fopen("weng_out.txt","w+");fprintf(fp,"\n\n---------result 矩阵的逆，精确结果10-8以上------------\n");for(i=0;i<mc;i++)< bdsfid="93" p=""></mc;i++)<>{for(j=0;j<nr;j++)< bdsfid="96" p=""></nr;j++)<>fprintf(fp,"%18.8e",C[i][j]);fprintf(fp,"\n");}fprintf(fp,"\n\n---------result 6位有效数字------------\n");for(i=0;i<mc;i++)< bdsfid="102" p=""></mc;i++)<>{for(j=0;j<nr;j++)< bdsfid="105" p=""></nr;j++)<>fprintf(fp,"%15.5e",C[i][j]);fprintf(fp,"\n");}fclose(fp);}void ArrayOut(long double *p,int m,int n){int i,j;for(i=0;i<m;i++){< bdsfid="115" p=""></m;i++){<>for(j=0;j<n;j++)< bdsfid="117" p=""></n;j++)<>printf("%12.6g",*(p+i*n+j) );printf("\n");}}void MatDiv(long double *b,int m,long double *c){int i,j,k;long double t2,head,front;long double *a=new long double [m*2*m];//------------------(A,E)--m=3 ------------------------------------ for(i=0;i<m;i++){< bdsfid="128" p=""></m;i++){<> for(j=0;j<m;j++)< bdsfid="130" p=""></m;j++)<>*(a+i*2*m+j)=*(b+i*m+j);for(j=m;j<2*m;j++){if(i==(j-m)) *(a+i*2*m+j)=1;else *(a+i*2*m+j)=0;}}printf("----------(A,E)----------\n");ArrayOut(a,m,m*2);//------------------处理首行为零情形--对换-----------------if(*a==0){for(i=0;i<m;i++)< bdsfid="143" p=""></m;i++)<>if(*(a+i*m)!=0) break;for(j=0;j<2*m;j++){t2=*(a+i*2*m+j);*(a+i*2*m+j)=*(a+j);*(a+j)=t2;} }//---------------------上三角阵-------------------------------- for(i=1;i<m;i++){< bdsfid="149" p=""></m;i++){<>front=*(a+(i-1)*2*m+i-1);for(j=i;j<m;j++){< bdsfid="152" p=""></m;j++){<>head=*(a+j*2*m+i-1);if(head==0) continue;for(k=i-1;k<2*m;k++)*(a+j*2*m+k)=*(a+j*2*m+k)-*(a+(i-1)*2*m+k)*head/front;}}//---------------------下三角阵--------------------------------for(i=m-1;i>0;i--){front=*(a+i*2*m+i);for(j=i;j>0;j--){head=*(a+(j-1)*2*m+i);//front 和head 相差2*mif(head==0) continue;for(k=i;k<2*m;k++)*(a+(j-1)*2*m+k)=*(a+(j-1)*2*m+k)-*(a+i*2*m+k)*head/front;}}//---------------------前半部分化为单位阵--------------------------------for(i=0;i<m;i++){< bdsfid="171" p=""></m;i++){<>t2=*(a+i*2*m+i);for(k=0;k<2*m;k++){*(a+i*2*m+k)/=t2;if(k>=m) *(c+i*m+k-m)=*(a+i*2*m+k);}}delete []a;}。
C语言求矩阵的逆矩阵
C语言求矩阵的逆矩阵班级：自动化1604小组成员：潘孝枫金豆2017年4月作业要求：1.用C语言编程；2.查阅相关资料，至少了解三种以上的求矩阵的逆的方法；3.俩人一组，提交大作业报告，含源代码。
方法一：用伴随矩阵求矩阵的逆矩阵（潘孝枫）最主要的问题就是求解矩阵的逆矩阵，而且是一个动态矩阵1.求解矩阵的伴随矩阵，套用求行列式的函数解决问题的关键是如何运用一个循环递归将求行列式的函数反复嵌套函数的分块1.求矩阵的行列式的函数2.求余子式的函数3.求逆的函数#include <stdio.h>#include <math.h>#define N 9 //默认行列式最大输入阶数为9 float Fun(int n, float a[N][N] ); //定义行列式计算程序，n为行列式阶数，a为矩阵a/*主程序*/int main(void){int n ; //定义阶数ninti, j, i1, j1,i2 ,j2 ; //定义循环变量float a[N][N] , b[N][N] , c[N][N]; //定义数组，a为原始录入数组，b为中间变量数组，用于提取与计算余子式，c为输出结果数组float d; //定义a的行列式值printf("Input the order of matrix a:"); //输入a的阶数scanf("%d",&n);printf("Input matrix a:\n"); //输入矩阵afor( i = 0; i< n; i++){for( j = 0; j < n; j++){scanf("%f", &a[i][j]);}}d=Fun( n, a ); //计算a的行列式if(fabs(d)<1e-6) //判断a的行列式值是否为0{printf("The determinant is not invertible!"); //输出“行列式值为0，不可逆”}else{printf("The determinant of a is %f",d); //非0继续运算if(n==1) //阶数为1的情况{c[0][0]=1/d;}else //阶数大于1的情况{for( i = 0; i<=n-1; i++){for( j = 0; j <= n-1; j++){for(i1=0, i2=0; i2<n-1; i1++, i2++){for(j1=0, j2=0; j2<n-1; j1++, j2++){if(i1 == i){i1++;}if(j1 == j){j1++;}b[i2][j2]=a[i1][j1]; //提取a[i][j]所对应的余子式到矩阵b中}}c[j][i]=pow( -1 , i + j ) * Fun( n - 1 , b)/d; //计算a[i][j]对应的代数余子式，存入矩阵c中并完成转置}}}printf("\n"); //输出结果for(i=0;i<n;i++){for(j=0;j<n;j++){printf("%10f",c[i][j]);}printf("\n");}}}/*求行列式*/float Fun( int n, float a[N][N] ) //定义求矩阵行列式的程序，采用逐步降阶求值{float b[N][N]; //定义矩阵binti = 0, j = 0; //定义循环变量i,jfloat sum = 0; //定义行列式运算结果sumint c = 0,p = 0; //定义辅助变量c,pif(n == 1) //行列式阶数为1函数直接返回a[0][0]值{return a[0][0];}for(i = 0;i < n; i++) //针对行列式第一列展开{for(c = 0;c < n-1; c++){for(j = 0;j < n-1;j++){if (c <i) //判断录入数组b时行数值，如果c大于i，则在执行录入数组a时行数下移一行，否则不执行数+1的操作{p = 0;}else{p = 1;}b[c][j] = a[c+p][j+1]; //取出a[i][j]第一列每个元素对应的余子式存入数组b中}}sum += a[i][0] * Fun(n - 1, b ) * pow(- 1 , i ); //求出a第一列每个元素代数余子式之和，其中嵌套Fun进行逐步降阶完成高阶行列式计算}return sum;}方法二：用行初等变换来求矩阵的逆//应用矩阵初等变换的方法求逆矩阵//参数说明：// naturalmat 原矩阵// num 矩阵的阶数// InvMat 求解结果，逆矩阵bool Matrix_Inv(double **naturalmat,int num,double **InvMat){int i,j,k;double **MatEnhanced;//增广矩阵(A|E)MatEnhanced = (double**)malloc(num*sizeof(double*)); for(i=0;i<num;i++)MatEnhanced[i] = (double*)malloc(2*num*sizeof(double));double *temp;temp = (double*)malloc(2*num*sizeof(double));double xishu=1;//初等变换时系数，设初值为1for(i=0;i<num;i++) //增广矩阵赋值，前半部分 {for(j=0;j<num;j++)MatEnhanced[i][j] = naturalmat[i][j];}for(i=0;i<num;i++) //增广矩阵赋值，后半部分 {for(j=num;j<2*num;j++)MatEnhanced[i][j] = 0;//先将后半部分全部赋值为0MatEnhanced[i][i+num] = 1;//再将其对角线部分赋值为1}//接下来进行初等行变换for(i=0;i<num;i++){if(MatEnhanced[i][i] == 0)//如果前半部分的对角线上的元素为0，此时进行行变换{if(i == num-1)//如果是最后一行，那么说明该矩阵不可return false;//对第i行以后的各行进行判断，找到第i个元素不为零的行，并与第i行进行交换for(j=i;j<num;j++){if(MatEnhanced[j][i] != 0){k = j;//记住该行的行号break;//退出循环}}//接下来对第i行和第k行进行交换temp = MatEnhanced[k];//第k行MatEnhanced[k] = MatEnhanced[i];MatEnhanced[i] = temp;//初等变换for(j=0;j<num;j++)//对其他行的所有列进行计算{if(j != i)//本行不参与计算{if(MatEnhanced[j][i] != 0)//只有当其不为零时进行计算，否则不计算{xishu = MatEnhanced[j][i]/MatEnhanced[i][i];for(k=i;k<2*num;k++)//对后面的所有列进行计算MatEnhanced[j][k] -= xishu*MatEnhanced[i][k];}}}}//将本行所有列都除以对角线上的值，将前半部分化成单位矩阵xishu = MatEnhanced[i][i];for(j=i;j<2*num;j++)if(xishu != 0)MatEnhanced[i][j] /= xishu;}//计算完成后，后半部分即为原矩阵的逆矩阵，将其赋值给InvMat. for(i=0;i<num;i++){for(j=0;j<num;j++)InvMat[i][j] = MatEnhanced[i][j+num];}//内存释放free(MatEnhanced);free(temp);return true;//返回}。
c语言实现矩阵的加减乘除求逆运算
#include〈stdio.h>＃include〈stdlib。
h〉＃define col 3#define row 3class matrix//类的定义｛private:double m［col]［row];//矩阵设置为私有的，public：matrix（）｛}//无参数的构造函数matrix（double a[col］[row])；//有参数的构造函数matrix Add(matrix ＆b）；//加法运算声明matrix Sub（matrix ＆b);//减法运算声明matrix Mul(matrix &b)；//乘法运算声明matrix Div（matrix &b)；//除法运算声明matrix Inverse（）;//求逆运算声明~matrix();//析构函数声明void display(）;//显示函数声明｝；matrix：：matrix(double a［col]［row]）//构造函数的定义｛int i,j；for（i=0;i<col;i++)for（j=0;j〈row；j++)m［i］［j］=a［i］[j];}matrix matrix:：Add(matrix &b）//加法运算{int i，j;matrix＊c=(matrix*)malloc(sizeof（matrix））;for（i=0；i<col；i++)for(j=0;j<row；j++）c—〉m［i][j]=m[i］［j］+b.m［i］［j]；return（＊c）;｝matrix matrix:：Sub(matrix ＆b)//减法运算{int i，j;matrix＊c=(matrix*）malloc（sizeof（matrix）)；for（i=0;i〈col；i++）for（j=0;j<row;j++)c->m[i][j]=m[i］［j]—b。
m［i]［j];return ＊c；}matrix matrix:：Mul（matrix &b)//乘法运算{int i,j,k；double sum=0；matrix＊c=（matrix*)malloc(sizeof（matrix)）;for（i=0;i<col；i++){for(j=0;j〈row;j++)｛for（k=0；k〈row;k++)sum+=m［i］[k］*（b.m［k］［j］）;c-〉m[i][j］=sum；sum=0；｝}return(*c)；}matrix matrix：：Div（matrix ＆b）//除法运算{//除法直接求解，参见主函数matrix c;return（c);}matrix matrix::Inverse（）//求逆运算｛//参考博客：http：///rollenholt/articles/2050662。
C++求矩阵的逆程序代码
求解逆矩阵源代码：#include <stdio.h>#include <stdlib.h>#include <math.h>#define TINY 1.0e-20void inverse(double**,int);void ludcmp(double**, int, int*, double*);void lubksb(double**, int, int*, double*);double **matrix(int,int,int,int);double *vector(int,int);void free_matrix(double**,int,int,int,int);void free_vector(double*,int,int);void inverse(double **mat, int dim){int i,j,*indx;double **y,d,*col;y = matrix(0,dim-1,0,dim-1);indx = (int *)malloc((unsigned)(dim*sizeof(int)));col = vector(0,dim-1);ludcmp(mat,dim,indx,&d);for (j=0;j<dim;j++){for (i=0;i<dim;i++) col[i] = 0.0;col[j] = 1.0;lubksb(mat,dim,indx,col);for (i=0;i<dim;i++) y[i][j] = col[i];}for (i=0;i<dim;i++)for (j=0;j<dim;j++)mat[i][j] = y[i][j];free_matrix(y,0,dim-1,0,dim-1);free_vector(col,0,dim-1);free(indx);}void ludcmp(double **a, int n, int *indx, double *d){int i,imax,j,k;double big,dum,sum,temp;double *vv;vv = (double*)malloc((unsigned)(n*sizeof(double)));if (!vv){fprintf(stderr,"Error Allocating Vector Memory\n");exit(1);}*d = 1.0;for (i=0;i<n;i++){big = 0.0;for (j=0;j<n;j++){if ((temp=fabs(a[i][j])) > big) big = temp;}if (big == 0.0){fprintf(stderr,"Singular Matrix in Routine LUDCMP\n");for (j=0;j<n;j++) printf(" %f ",a[i][j]); printf("/n");exit(1);}vv[i] = 1.0/big;}for (j=0;j<n;j++){for (i=0;i<j;i++){sum = a[i][j];for (k=0;k<i;k++) sum -= a[i][k] * a[k][j];a[i][j] = sum;}big = 0.0;for (i=j;i<n;i++){sum = a[i][j];for (k=0;k<j;k++) sum -= a[i][k] * a[k][j];a[i][j] = sum;if ((dum=vv[i]*fabs(sum)) >= big){big = dum;imax = i;}}if (j != imax){for (k=0;k<n;k++){dum = a[imax][k];a[imax][k] = a[j][k];a[j][k] = dum;}*d = -(*d);vv[imax] = vv[j];}indx[j] = imax;if (a[j][j] == 0.0) a[j][j] = TINY;if (j != n-1){dum = 1.0 / a[j][j];for (i=j+1;i<n;i++) a[i][j] *= dum;}}free(vv);}void lubksb(double **a, int n, int *indx, double *b) {int i,ip,j,ii=-1;double sum;for (i=0;i<n;i++){ip = indx[i];sum = b[ip];b[ip] = b[i];if (ii>=0)for (j=ii;j<i;j++) sum -= a[i][j] * b[j];else if (sum) ii = i;b[i] = sum;}for (i=n-1;i>=0;i--){sum = b[i];for (j=i+1;j<n;j++) sum -= a[i][j] * b[j];b[i] = sum / a[i][i];}}。
C语言求逆矩阵案例详解
C语⾔求逆矩阵案例详解⼀般求逆矩阵的⽅法有两种，伴随阵法和初等变换法。
但是这两种⽅法都不太适合编程。
伴随阵法的计算量⼤，初等变换法⼜难以编程实现。
适合编程的求逆矩阵的⽅法如下：1. 对可逆矩阵A进⾏QR分解：A=QR2. 求上三⾓矩阵R的逆矩阵3. 求出A的逆矩阵：A^(-1)=R^(-1)Q^(H)以上三步都有具体的公式与之对应，适合编程实现。
C语⾔实现代码：#include <stdio.h>#include <math.h>#define SIZE 8double b[SIZE][SIZE]={0};//应该读作“贝尔塔”，注释中⽤B表⽰double t[SIZE][SIZE]={0};//求和的那项double Q[SIZE][SIZE]={0};//正交矩阵double QH[SIZE][SIZE]={0};//正交矩阵的转置共轭double R[SIZE][SIZE]={0};//double invR[SIZE][SIZE]={0};//R的逆矩阵double invA[SIZE][SIZE]={0};//A的逆矩阵，最终的结果//={0};//double matrixR1[SIZE][SIZE]={0};double matrixR2[SIZE][SIZE]={0};//double init[3][3]={3,14,9,6,43,3,6,22,15};double init[8][8]={0.0938 , 0.5201 , 0.4424 , 0.0196 , 0.3912 , 0.9493 , 0.9899 , 0.8256,0.5254 , 0.3477 , 0.6878 , 0.3309 , 0.7691 , 0.3276 , 0.5144 , 0.7900,0.5303 , 0.1500 , 0.3592 , 0.4243 , 0.3968 , 0.6713 , 0.8843 , 0.3185,0.8611 , 0.5861 , 0.7363 , 0.2703 , 0.8085 , 0.4386 , 0.5880 , 0.5341,0.4849 , 0.2621 , 0.3947 , 0.1971 , 0.7551 , 0.8335 , 0.1548 , 0.0900,0.3935 , 0.0445 , 0.6834 , 0.8217 , 0.3774 , 0.7689 , 0.1999 , 0.1117,0.6714 , 0.7549 , 0.7040 , 0.4299 , 0.2160 , 0.1673 , 0.4070 , 0.1363,0.7413 , 0.2428 , 0.4423 , 0.8878 , 0.7904 , 0.8620 , 0.7487 , 0.6787};/*/函数名:int main()输⼊:输出:功能:求矩阵的逆 pure C language⾸先对矩阵进⾏QR分解之后求上三⾓矩阵R的逆阵最后A-1=QH*R-1,得到A的逆阵。
C语言求矩阵的逆
#include<stdio.h>#include<math.h>void jiafa(){int m,n;float a[20][20],b[20][20],c[20][20]; int i,j;printf("请输入矩阵行数：");scanf("%d",&m);printf("请输入矩阵列数：");scanf("%d",&n);printf("请输入第一个矩阵："); for(i=0;i<m;i++)for(j=0;j<n;j++)scanf("%f",&a[i][j]);printf("请输入第二个矩阵："); for(i=0;i<m;i++)for(j=0;j<n;j++)scanf("%f",&b[i][j]);printf("矩阵相加的结果为：");for(i=0;i<m;i++){ for(j=0;j<n;j++){c[i][j]=a[i][j]+b[i][j];printf("%4f ",c[i][j]); }printf("\n");}}void jianfa(){int m,n;float a[20][20],b[20][20],c[20][20]; int i,j;printf("请输入矩阵行数：");scanf("%d",&m);printf("请输入矩阵列数：");scanf("%d",&n);printf("请输入第一个矩阵："); for(i=0;i<m;i++)for(j=0;j<n;j++)scanf("%f",&a[i][j]);printf("请输入第二个矩阵："); for(i=0;i<m;i++)for(j=0;j<n;j++)scanf("%f",&b[i][j]);printf("矩阵相减的结果为：");for(i=0;i<m;i++){ for(j=0;j<n;j++){c[i][j]=a[i][j]-b[i][j];printf("%4f ",c[i][j]); }printf("\n");}}void chengfa(){int m,n;float s;float a[20][20],b[20][20],c[20][20]; int i,j,k;printf("请输入矩阵行数：");scanf("%d",&m);printf("请输入矩阵列数：");scanf("%d",&n);printf("请输入第一个矩阵："); for(i=0;i<m;i++)for(j=0;j<n;j++)scanf("%f",&a[i][j]);printf("请输入第二个矩阵："); for(i=0;i<n;i++)for(j=0;j<m;j++)scanf("%4f",&b[i][j]);for(i=0;i<m;i++){for(j=0;j<m;j++){s=0;for(k=0;k<n;k++){s=s+a[i][k]*b[k][j];c[i][j]=s;}}}for(i=0;i<m;i++){for(j=0;j<m;j++){printf("%4f ",c[i][j]);}printf("\n");}}void zhuanzhi(){int m,n;float a[20][20],b[20][20];int i,j;printf("请输入矩阵行数："); scanf("%d",&m);printf("请输入矩阵列数："); scanf("%d",&n);printf("请输入一个矩阵："); for(i=0;i<m;i++)for(j=0;j<n;j++)scanf("%f",&a[i][j]);for(i=0;i<m;i++){for(j=0;j<n;j++){b[i][j]=a[j][i];printf("%4f ",b[i][j]);}printf("\n");}}void qiuni(){int N;printf("输入矩阵的阶数N:\n");scanf("%d",&N);float a[10][10],b[10][20],c[10][10],t;int i,j,m;printf("请输入行列式不为0的矩阵A(%d阶):\n",N); //矩阵A的各元素存入二维数组a中。
矩阵求逆标准算法
矩阵求逆标准算法矩阵求逆标准算法(VB源码2006-11-29 13:49 类别：默认本程序依据矩阵初等变换的基本原理编写，算法较为繁琐，但易于理解适合VB初学者。
本程序适合任何(n*n)的矩阵求逆，对于不可逆矩阵有提示信息，并结束程序本程序在XP, VB6.0下调试通过本程序由本人原创，请慎用。
如有疑问，或调试有误，请联系本人QQ 30360126本程序可在VB6.0内任何地方用call jzqn(qa(),na())) 语句调用其中qa()是输入的矩阵数组，调用此函数后na()为返回的逆矩阵数组注意：调用本程序前不要声明na()的维数，仅用dim na()即可。
请不要试图对一个病态矩阵求逆、否则计算结果未必是你想要的病态矩阵是指行列式计算结果极其接近于零的矩阵Public Sub jzqn( qa(), n a())Dim a()n = UBou nd(qa, 1)ReDim na(n, n)ReDim a(n, 2 * n)For i = 1 To nForj = 1 To na(i, j) = qa(i, j)Next jNext iFor i = 1 To nFor j = n + 1 To 2 * nIf j - i = n The na(i, j) = 1Elsea(i, j) = 0End IfNext jNext iFor i = 1 To nIf a(i, i) = 0 The nFor q = i To nIf a(q, i) <> 0 The nFor w = i To 2 * nzj = a(i, w)a(i, w) = a(q, w)a(q, w) = zjNext wExit ForEnd IfNext qIf q > n The n MsgBox " 此矩阵不可逆"：Exit SubEnd IfFor k = 2 * n To i Step -1a(i, k) = a(i, k) / a(i, i)Next kFor j = i + 1 To nIf a(j, i) <> 0 The nFor k = 2 * n To i Step -1 a(j, k) = a(j, k) / a(j, i) - a(i, k) Next k End IfNext jNext iFor i = n To 1 Step -1If a(i, i) = 0 The nFor q = i - 1 To 1 Step -1If a(q, i) <> 0 The nFor w = i To 2 * n zj = a(i, w) a(i, w) = a(q, w) a(q, w) = zjNext wExit ForEnd IfNext qEnd IfFor k = 2 * n To i Step -1a(i, k) = a(i, k) / a(i, i)Next kFor j = i - 1 To 1 Step -1If a(j, i) <> 0 The nxxx = a(j, i)For k = 2 * n To 1 Step -1a(j, k) = a(j, k) / xxx - a(i, k)Next kEnd IfNext jNext iFor i = 1 To nForj = 1 To nn a(i, j) = a(i, j + n)Next jNext iEnd Sub调用示例：下面代码随机产生一个10*10的矩阵，并求逆，打印于窗体Private Sub Comma nd1_Click()Dim a(10, 10), b()CisRan domizeFor i = 1 To 10For j = 1 To 10 a(i, j) = In t(R nd * 100)Print a(i, j);Next jPrintNext iPrintCall jzqn(a(), b())For i = 1 To 10For j = 1 To 10Print Format(b(i, j), "0.000"),Next jPrintNext iEnd Sub矩阵运算是数值运算中经常碰到的，砖头”抛岀多天，尚未引岀玉来”，我自己再来个补充吧！矩阵求逆上面给出的程序，虽然可以使用，但远不完善，更不精炼。
c语言矩阵求逆
C语言矩阵求逆简介矩阵求逆是线性代数中的重要概念和计算方法之一。
矩阵求逆的结果可以用于解线性方程组、计算行列式和求矩阵的伴随等操作。
在C语言中，我们可以通过编写代码来实现矩阵求逆的算法。
本文将介绍C语言矩阵求逆的原理、实现步骤以及代码示例。
原理矩阵的逆是指对于一个n阶方阵A，存在一个n阶方阵B，使得AB=BA=I（单位矩阵）。
具体地，对于一个可逆矩阵A，其逆矩阵可以通过以下公式计算得到：A^-1 = 1/|A| * adj(A)其中，|A|表示矩阵A的行列式，adj(A)表示矩阵A的伴随矩阵。
实现步骤要实现C语言矩阵求逆的算法，可以按照以下步骤进行：步骤1：输入矩阵首先，需要在程序中输入待求逆的矩阵。
可以通过从用户获取输入或者在代码中直接指定矩阵的方式来完成。
步骤2：计算行列式根据上述原理公式，需要首先计算矩阵的行列式。
可以通过递归的方式来计算行列式，或者使用高斯消元法进行计算。
步骤3：计算伴随矩阵根据原理公式，需要计算矩阵的伴随矩阵。
伴随矩阵的元素可以通过余子式和代数余子式的方式计算得到。
步骤4：计算逆矩阵根据原理公式，可以利用行列式和伴随矩阵来计算逆矩阵。
步骤5：输出结果最后，将计算得到的逆矩阵输出到屏幕上，或者保存到文件中。
示例代码下面是一个简单的C语言矩阵求逆的示例代码：#include <stdio.h>#define N 3typedef struct {int data[N][N];} Matrix;// 计算行列式的函数int determinant(Matrix mat) {// 实现行列式计算的代码// ...}// 计算伴随矩阵的函数Matrix adjoint(Matrix mat) {Matrix adj;// 实现伴随矩阵计算的代码// ...return adj;}// 计算逆矩阵的函数Matrix inverse(Matrix mat) {Matrix inv;// 实现逆矩阵计算的代码// ...return inv;}// 输出矩阵的函数void printMatrix(Matrix mat) {// 实现输出矩阵的代码// ...}int main() {Matrix mat;// 获取用户输入或者指定矩阵的代码// ...int det = determinant(mat);if (det == 0) {printf("矩阵不可逆！\n");return 0;}Matrix adj = adjoint(mat);Matrix inv = inverse(mat);printf("原矩阵：\n");printMatrix(mat);printf("行列式： %d\n", det);printf("伴随矩阵：\n");printMatrix(adj);printf("逆矩阵：\n");printMatrix(inv);return 0;}上述代码中，通过定义一个Matrix结构体来表示矩阵，包含一个二维数组来存储矩阵的元素。
初等变换求逆矩阵 matlab代码
初等变换求逆矩阵 Matlab代码在线性代数中，矩阵的逆矩阵是一种非常重要的概念。
矩阵A的逆矩阵记作A^-1，是一个能与A相乘得到单位矩阵I的矩阵。
而要求一个矩阵的逆矩阵，一个重要的方法就是使用初等变换。
初等变换是针对矩阵进行的行变换，包括交换两行、将某一行乘以一个非零常数、将某一行的倍数加到另一行上。
在Matlab中，我们可以通过编写简单的代码来求解矩阵的逆矩阵。
接下来，我将通过深入的探讨和具体的例子，介绍如何使用初等变换求逆矩阵的Matlab代码。
让我们来看一个简单的例子。
假设我们有一个2x2的矩阵A，如下所示：A = [2 1; 4 3]我们的目标是求解矩阵A的逆矩阵。
根据矩阵求逆的方法，我们可以列出一个增广矩阵，将A和单位矩阵拼接在一起，并通过初等变换将A转化为单位矩阵。
具体的步骤如下：1. 将矩阵A与单位矩阵拼接在一起：[A, I] = [2 1 1 0; 4 3 0 1]其中I表示2x2的单位矩阵。
2. 接下来，通过初等变换，将矩阵A转化为单位矩阵：通过将第一行乘以1/2，得到：[1 1/2 1/2 0]然后将第一行的倍数加到第二行上，得到：[1 1/2 1/2 0; 0 1 2 1]通过将第二行减去2倍的第一行，得到：[1 0 1 -1; 0 1 2 1]3. 最后得到的矩阵就是单位矩阵，而原始矩阵A经过相同的初等变换，所得到的就是A的逆矩阵：A^-1 = [1 -1; 2 1]接下来，我们将使用Matlab来实现上述过程，求解矩阵的逆矩阵。
在Matlab中，我们可以使用以下代码来实现：```matlabA = [2 1; 4 3];I = eye(2);B = [A, I];[r, c] = size(B);for j = 1:rB(j, :) = B(j, :) / B(j, j);for i = 1:rif i ~= jB(i, :) = B(i, :) - B(i, j) * B(j, :);endendendA_inverse = B(:, c+1:end);disp('A的逆矩阵为：');disp(A_inverse);```以上代码首先定义了原始矩阵A，然后创建了一个单位矩阵I，将A和I拼接成增广矩阵B。
利用初等行变换求矩阵的逆运算的代码
/**************reverse matrix************************///利用的是AX=B，X=A’B,这里B=E；进行初等行变换求解，把左边化为单位阵，右边就是A矩阵的逆矩阵；void swap(double *a,int i,int line,int n) // exchange line//交换行位置，i控制行号，line也是行号，//n是矩阵列数{int j;double temp;for(j=0;j<n;j++){temp=a[i*n+j];a[i*n+j]=a[line*n+j];a[line*n+j]=temp;}}void calculate(double *p,double *q,int n) //形成上三角阵{int i,j,k,m,line;double max,temp,mmul;for(i=0;i<n;i++){max=fabs(p[i*n+i]);temp=p[i*n+i];line=i;for(j=i+1;j<n;j++) //选出每一列中最大值，并且用line记录行号,//用temp记录该最大值，用j来控制行号{if(fabs(p[j*n+i])>max){max=fabs(p[j*n+i]);temp=p[j*n+i];line=j;}}if(max<=1e-5){printf("no inverse array\n");return;}if(line!=i){swap(p,i,line,n);//将每一列中最大行换到i行swap(q,i,line,n);}for(k=0;k<n;k++){p[i*n+k]/=temp;//将i行的每个数都除以i行i列的值，将i行i列化为1q[i*n+k]/=temp;}for(k=i+1;k<n;k++)//将i列i行下面其它行的值都化为0{mmul=p[k*n+i];for(m=0;m<n;m++){p[k*n+m]-=p[i*n+m]*mmul;//每一行都减去Ak0*i行对应列的值q[k*n+m]-=q[i*n+m]*mmul;}}}}void backcalculate(double*p,double*q,int n)//形成单位矩阵{int i,j,k;double mmul;for(i=n-1;i>0;i--){for(j=i-1;j>=0;j--)//从下往上每一行进行计算，与前面相反{mmul=p[j*n+i];p[j*n+i]-=p[i*n+i]*mmul;for(k=0;k<n;k++){q[j*n+k]-=q[i*n+k]*mmul;}}}}void unitmatrix(double *q,int n) //形成单位矩阵，矩阵q是一个单位阵{int i,j;for(i=0;i<n;i++){for(j=0;j<n;j++){if(i==j){q[i*n+j]=1;}elseq[i*n+j]=0;}}}void MatrixInverse(double *A,double *C,int n)//矩阵求逆，A为要求的矩阵，C为求得的逆矩阵{unitmatrix(C,n);//将C初始化为单位阵calculate(A,C,n);//将A化为了上三角阵backcalculate(A,C,n); //将A化为了单位阵，这时C即为所求}友情提示：范文可能无法思考和涵盖全面，供参考!最好找专业人士起草或审核后使用，感谢您的下载！。
详解用java描述矩阵求逆的算法
详解⽤java描述矩阵求逆的算法今天很开⼼把困扰⼏天的问题解决了，在学习线性代数这门课程的时候。
想通过程序实现⾥⾯的计算⽅法，⽐如矩阵求逆，⽤java代码该如何描述呢？⾸先，咱们先⽤我们所交流语⾔描述⼀下算法思路:1.求出⼀个矩阵A对应的⾏列式在第i，j（i表⽰⾏，j表⽰列）位置的余⼦式（余⼦式前⾯乘以-1^（i+j）即得代数余⼦式）；2.根据代数余⼦式求得矩阵A⾏列式的值。
（⾏列式展开法）；3.根据代数余⼦式和⾏列式的值求出伴随矩阵；4.由伴随矩阵和矩阵⾏列式值求逆矩阵。
(A^-1 = A* / |A|)。
了解上述算法思路后，废话少说，上代码。
1.求出⼀个矩阵A对应的⾏列式在第i，j（i表⽰⾏，j表⽰列）位置的余⼦式（余⼦式前⾯乘以-1^（i+j）即得代数余⼦式）；/*** 求矩阵在i,j处余⼦式* @param mat* @param i* @param j* @return*/public static Matrix getComplementMinor(Matrix mat, int i, int j) {//创建⼀个新的矩阵⽤于接收表⽰该余⼦式，需删除本⾏本列的数值Matrix m = new Matrix(mat.getRow()-1,mat.getCol()-1);//⽤于遍历新矩阵m的变量int row =0 ,col=0;/** 遍历原矩阵的数据，j2表⽰⾏,k表⽰列*/for (int j2 = 0; j2 < mat.getRow(); j2++) {//在第i⾏除的数据省略if(j2 == i) continue;for (int k = 0; k < mat.getCol(); k++) {//在第j列的数据省略if(k == j) continue;//赋值m.setValue(row, col,mat.getValue(j2, k));//遍历新矩阵的变量col++;if(col >= m.getCol() ) {col = 0;row++;}}}return m;}A⾏列式的值。
python矩阵求逆算法
python矩阵求逆算法
矩阵求逆是线性代数中的一个重要问题，可以在多种应用中得到应用，比如图像处理、机器学习等。
Python提供了许多库来解决矩阵求逆的问题，比如NumPy、SciPy等。
NumPy库中提供了linalg.inv()函数来求矩阵的逆，使用方法如下：
import numpy as np
# 定义一个2x2的矩阵
matrix = np.array([[2, 3], [4, 5]])
# 求矩阵的逆
inv_matrix = np.linalg.inv(matrix)
print(inv_matrix)
输出结果为：
[[-1.66666667 1.33333333]
[ 1.33333333 -0.66666667]]
如果矩阵不可逆，则会抛出LinAlgError异常。
除了NumPy库，还有一些其他的Python库也提供了矩阵求逆的方法，比如SciPy库中的linalg库、SymPy库中的Matrix库等。
需要根据自己的需求选择合适的库来解决问题。
总之，Python提供了丰富的工具来解决矩阵求逆的问题，我们只需要根据自己的需求选择适合的库和方法即可。
- 1 -。
数值计算 求矩阵逆 fortran源代码
!此法利用LU分解然后再利用上三角矩阵求逆方法其中利用矩阵乘法以及转置估计精度不敢保证，不过对于低阶矩阵，精度可以达到要求。
program inverse_matrix !利用上三角矩阵逆矩阵的求法构造两个三角矩阵再分开求逆再求乘积implicit noneinteger i,nreal*8,allocatable::a(:,:),l(:,:),u(:,:),lt(:,:),inverse_lt(:,:),inverse _l(:,:),inverse_u(:,:),inverse_a(:,:)write(*,*) 'Please input the order of Matrix A:'read(*,*) nallocate(a(n,n),l(n,n),u(n,n),lt(n,n),inverse_lt(n,n),inverse_l(n, n),inverse_u(n,n),inverse_a(n,n))do i=1,nwrite(*,"('The ',i2,' row of the matrix a is:')") iread(*,*) a(i,:)end docall LU_break(a,n,l,u)call inverse_uptri_matrix(u,n,inverse_u)call transpose_matrix(l,n,n,lt)call inverse_uptri_matrix(lt,n,inverse_lt)call transpose_matrix(inverse_lt,n,n,inverse_l)call multiply_matrix(inverse_u,n,n,inverse_l,n,inverse_a)do i=1,nwrite(*,"('The ',i2,' row of the inverse of matrix a is:')") iwrite(*,*) inverse_a(i,:)end dostopendsubroutine LU_break(A,n,L,U) !普通LU分解，目的是为了便于求解逆矩阵implicit noneinteger k,i,j,t,nreal*8::A(n,n),L(n,n),U(n,n)real*8 sum1,sum2do k=1,ndo j=k,nsum1=0do t=1,k-1sum1=sum1+L(k,t)*U(t,j)end doU(k,j)=A(k,j)-sum1end dodo i=k+1,nsum2=0do t=1,k-1sum2=sum2+L(i,t)*U(t,k)end doL(i,k)=(A(i,k)-sum2)/U(k,k)end doend dodo j=1,nL(j,j)=1end doreturnendsubroutine transpose_matrix(A,n,m,B) !求矩阵转置implicit noneinteger i,j,n,mreal*8 A(n,m),B(m,n),tdo i=1,mdo j=1,nB(i,j)=A(j,i)end doend doreturnendsubroutine multiply_matrix(A,n,m,B,l,C) !矩阵间乘法implicit noneinteger i,j,k,l,n,mreal*8 sumreal*8 A(n,m),B(m,l),C(n,l)do i=1,ndo j=1,lsum=0do k=1,msum=sum+A(i,k)*B(k,j)end doC(i,j)=sumend doreturnendsubroutine inverse_uptri_matrix(A,n,inverse_A) !上三角矩阵的逆矩阵函数implicit noneinteger i,j,k,nreal*8 sumreal*8 A(n,n),inverse_A(n,n)do i=1,ninverse_A(i,i)=1/A(i,i)end dodo i=1,ndo j=1,nif(i<j) thensum=0do k=i,j-1sum=sum+inverse_A(i,k)*A(k,j)end doinverse_A(i,j)=-sum/A(j,j)end doend do returnend。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
for(j=0;j<n;j++)
{
if(i==j)
{
q[i*n+j]=1;
}
else
q[i*n+j]=0;
}
}
}
void MatrixInverse(double *A,double *C,int n)//矩阵求逆，A为要求的矩阵，C为求得的逆矩阵
{
unitmatrix(C,n);//将C初始化为单位阵
calculate(A,C,n);//将A化为了上三角阵
backcalculate(A,C,n);//将A化为了单位阵，这时C即为所求
}
{
max=fabs(p[j*n+i]);
temp=p[j*n+i];
line=j;
}
}
if(max<=1e-5)
{
printf("no inverse array\n");
return;
}
if(line!=i)
{
swap(p,i,line,n);//将每一列中最大行换到i行
swap(q,i,line,n);
double max,temp,mmul;
for(i=0;i<n;i++)
{
max=fabs(p[i*n+i]);
temp=p[i*n+i];
line=i;
for(j=i+1;j<n;j++) //选出每一列中最大值，并且用line记录行号,
//用temp记录该最大值，用j来控制行号
{
if(fabs(p[j*n+i])>max)
}
for(k=0;k<n;k++)
{
p[i*n+k]/=temp;//将i行的每个数都除以i行i列的值，将i行i列化为1
q[i*n+k]/=temp;
}
for(k=i+1;k<n;k++)//将i列i行下面其它行的值都化为0
{
mmul=p[k*n+i];
for(m=0;m<n;m++)
{
p[k*n+m]-=p[i*n+m]*mmul;//每一行都减去Ak0*i行对应列的值
/**************reverse matrix************************/
//利用的是AX=B，X=A’B,这里B=E；进行初等行变换求解，把左边化为单位阵，右边就是A矩阵的逆矩阵；
void swap(double *a,int i,int line,int n) // exchange line//交换行位置，i控制行号，line也是行号，//n是矩阵列数
{
int j;
double temp;
for(j=0;j<n;j++)
{
temp=a[i*n+j];
a[i*n+j]=a[line*n+j];
a[line*n+j]=temp;
}
}
void calculate(double *p,double *q,int n) //形成上三角阵
{
int i,j,k,m,line;
{
mmul=p[j*n+i];
p[j*n+i]-=p[i*n+i]*mmul;
for(k=0;k<n;k++)
{
q[j*n+k]-=q[i*n+k]*mmul;
}
}
}
}
void unitmatrix(double *q,int n) //形成单位矩阵，矩阵q是一个单位阵
{
int i,j;
for(i=0;i<n;i++)
q[k*n+m]-=q[i*n+m]*mmul;
}
}
}
}
void backcalculate(double*p,double*q,int n)//形成单位矩阵
{
int i,j,Байду номын сангаас;
double mmul;
for(i=n-1;i>0;i--)
{
for(j=i-1;j>=0;j--)//从下往上每一行进行计算，与前面相反