矩阵求逆c代码

合集下载

c语言三阶矩阵求逆

c语言三阶矩阵求逆矩阵求逆是线性代数中的重要概念之一，也是许多科学和工程应用中必不可少的计算方法之一。

在本文中，我们将介绍使用C语言编写三阶矩阵求逆的方法。

我们需要了解什么是矩阵求逆。

矩阵求逆是指对于一个n阶方阵A，寻找另一个n阶方阵B，使得AB=BA=I（其中I为单位矩阵）。

如果这样的矩阵B存在，那么我们称矩阵A是可逆的，B为A的逆矩阵。

矩阵求逆的应用非常广泛，例如在计算机图形学、物理学、统计学等领域都有广泛的应用。

接下来，我们将介绍使用C语言编写三阶矩阵求逆的方法。

我们假设已知一个3x3的矩阵A，我们的目标是求出其逆矩阵B。

我们需要计算矩阵A的行列式。

矩阵的行列式是一个标量值，其计算方法可以通过对矩阵的行列式进行展开得到。

对于一个3x3的矩阵A，其行列式的计算公式为：det(A) = a11(a22a33 - a32a23) - a12(a21a33 - a31a23) + a13(a21a32 - a31a22)其中，a11、a12、a13、a21、a22、a23、a31、a32、a33分别代表矩阵A中的元素。

在C语言中，我们可以使用二维数组来表示矩阵，例如：float A[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};接下来，我们可以使用以下代码来计算矩阵A的行列式：float det = A[0][0]*(A[1][1]*A[2][2] - A[2][1]*A[1][2]) - A[0][1]*(A[1][0]*A[2][2] - A[2][0]*A[1][2]) + A[0][2]*(A[1][0]*A[2][1] - A[2][0]*A[1][1]);接下来，我们需要计算矩阵A的伴随矩阵。

矩阵的伴随矩阵是指将矩阵A的元素取代数余子式后得到的矩阵的转置矩阵。

对于一个3x3的矩阵A，其伴随矩阵的计算公式为：adj(A) = {{a22a33 - a23a32, a13a32 - a12a33, a12a23 - a13a22}, {a23a31 - a21a33, a11a33 - a13a31, a13a21 - a11a23}, {a21a32 - a22a31, a12a31 - a11a32, a11a22 - a12a21}}在C语言中，我们可以使用以下代码来计算矩阵A的伴随矩阵：float adj[3][3] = {{A[1][1]*A[2][2] - A[2][1]*A[1][2], A[0][2]*A[2][1] - A[0][1]*A[2][2], A[0][1]*A[1][2] - A[0][2]*A[1][1]}, {A[1][2]*A[2][0] - A[1][0]*A[2][2], A[0][0]*A[2][2] - A[0][2]*A[2][0], A[1][0]*A[0][2] - A[0][0]*A[1][2]}, {A[1][0]*A[2][1] - A[2][0]*A[1][1], A[2][0]*A[0][1] - A[0][0]*A[2][1], A[0][0]*A[1][1] -A[1][0]*A[0][1]}};我们可以使用以下代码来计算矩阵A的逆矩阵B：float B[3][3];for(int i=0; i<3; i++){for(int j=0; j<3; j++){B[i][j] = adj[j][i] / det;}}至此，我们就完成了使用C语言编写三阶矩阵求逆的过程。

C语言计算逆矩阵

C语⾔计算逆矩阵花了4天写的，不过三天在重学线代。

1 #include<stdio.h>2 #include<stdlib.h> // 操作内存3 #include<math.h> // pow()函数,计算-1的n次⽅，可以不⽤这个函数，偷懒使⽤现成的45/*6显⽰矩阵7 matrix: 矩阵8 order: 阶数9*/10void showMatrix(float** matrix, int order)11 {12for (int i = 0; i < order; i++) {13for (int j = 0; j < order; j++) {14 printf(" %f ", matrix[i][j]);15 }16 printf("|\n");17 }18 }1920/*21交换两⾏22⼀开始想使⽤初等⾏变换计算，此函数可以删除，⽤不到23 x1:调换第⼀⾏24 x2:调换第⼆⾏25 order:矩阵阶数26 matrix:矩阵27*/28void replaceRow(int x1, int x2, int order, float **matrix)29 {30float temp;31 x1 -= 1;32 x2 -= 1;33for (int i = 0; i < order; i++) {34 temp = matrix[x1][i];35 matrix[x1][i] = matrix[x2][i];36 matrix[x2][i] = temp;37 }38 }3940/*41转置矩阵42 matrix: 矩阵43 order: 阶数44*/45void transposeMatrix(float** matrix, int order)46 {47float temp;48for (int i = 0; i < order; i++) {49for (int j = 0; j < i; j++) {50 temp = matrix[i][j];51 matrix[i][j] = matrix[j][i];52 matrix[j][i] = temp;53 }54 }55 }5657/*58获取除了某⾏某列的矩阵59 oldmatrix: 原本矩阵60 newmatrix: 新矩阵61 row: 要删除⾏62 col: 要删除列63 order: 阶数64*/65void get(float** oldmatrix, float** newmatrix, int row, int col, int order)66 {67// 删除了⼀⾏⼀列，所以新矩阵⾏列均⽐原矩阵少168int a = 0, b = 0;69int x, y, z = 0, w = 0;70// i,j循环原矩阵71for (int i = 0; i < order - 1; i++) {72for (int j = 0; j < order - 1; j++) {73// z,w代表⾏列的是否加⼀状态，防⽌多次加⼀，+1只需要1次74if (i >= row && z == 0) { a += 1; z = 1; }75if (j >= col && w == 0) { b += 1; w = 1; }7677 newmatrix[i][j] = oldmatrix[i+a][j+b];78 }79 a = 0;b = 0;80 z = 0;w = 0;81 }82 }8384/*85计算⾏列式86 matrix: 矩阵87 order: 阶数88*/89float calc(float** matrix, int order)90 {91// 递归求⾏列式值92float num=0;93int i, j;94if (order == 2) {95// 如果是⼆阶直接获取值96 num = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];97 }98else {99// 创建更⼩⼆维数组100 order -= 1;101float** matrixlow = (float**)malloc(sizeof(float*) * order);102for (i = 0; i < order; i++) {103 matrixlow[i] = (float*)malloc(sizeof(float) * order);104 }105 order += 1;106107// 循环展开第⼀⾏108for (j = 0; j < order; j++) {109110get(matrix, matrixlow, 0, j, order);111// 此处开始递归，调⽤⾃⾝函数112 num += matrix[0][j] * pow(-1, j) * calc(matrixlow, order - 1); 113 }114115// 释放内存116for (i = 0; i < order-1; ++i)free(*(matrixlow + i));117 }118119return num;120 }121122123/*124主函数125*/126int main()127 {128int order; // 矩阵阶数129int i, j;130float det;131132// 获取矩阵阶133 printf("输⼊矩阵阶：");134 scanf("%d", &order);135136 printf("输⼊的阶是：%d\n\n", order);137138// 申请⼆维数组内存139float** matrix = (float**)malloc(sizeof(float*) * order);140for (i = 0; i < order; i++) {141 matrix[i] = (float*)malloc(sizeof(float) * order);142 }143144// 获取输⼊145for (i = 0; i < order; i++) {146for (j = 0; j < order; j++) {147 printf("位置：( %d , %d)请输⼊数据：",i + 1,j + 1);148 scanf("%f", &matrix[i][j]);149 }150 }151152// 计算并显⽰det153 det = calc(matrix, order);154 printf("\ndet值为：%f",det);155// 0不能做除数156if (det == 0)157 printf("\n矩阵接近奇异值，结果可能不准确！");158 printf("\n\n");159160// 显⽰输⼊矩阵161 printf("\n输⼊的矩阵是：\n\n");162 showMatrix(matrix, order);163164// 申请⼆维数组存储结果165float** Rmatrix = (float**)malloc(sizeof(float*) * order);166for (i = 0; i < order; i++) {167 Rmatrix[i] = (float*)malloc(sizeof(float) * order);168 }169170171// 开始计算172if (order == 2) {173// 阶数为⼆直接运⾏公式174float n = 1 / (matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]);175 Rmatrix[0][0] = n * matrix[1][1];176 Rmatrix[0][1] = -n * matrix[0][1];177 Rmatrix[1][0] = -n * matrix[1][0];178 Rmatrix[1][1] = n * matrix[0][0];179 }180else {181// 转置矩阵并显⽰182 transposeMatrix(matrix, order);183 printf("\n\n转置后为:\n\n");184 showMatrix(matrix, order);185186// 循环求i，j位的代数余⼦式187for (i = 0; i < order; i++) {188for (j = 0; j < order; j++) {189// 申请⼆维数组190 order -= 1;191float** matrixlow = (float**)malloc(sizeof(float*) * order);192for (int t = 0; t < order; t++) {193 matrixlow[t] = (float*)malloc(sizeof(float) * order);194 }195 order += 1;196197// 获取除了i，j⾏的值组成⾏列式198get(matrix, matrixlow, i, j, order);199// 计算⾏列式值除以det200 Rmatrix[i][j] = pow(-1, i + j) * calc(matrixlow, order - 1) / det; 201202// 释放内存203for (int t = 0; t < order-1; ++t)free(*(matrixlow + t));204 }205 }206207 }208209// 显⽰逆矩阵210 printf("\n\n逆矩阵为：\n\n");211 showMatrix(Rmatrix, order);212213214//// 释放⼆维数组215for (i = 0; i < order; ++i)free(*(matrix + i));216for (i = 0; i < order; ++i)free(*(Rmatrix + i));217218return0;219 }。

矩阵的逆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语言矩阵求逆程序(高斯-约旦法)

C语言矩阵求逆程序（高斯-约旦法）高斯-约旦法根据代数里面的知识，可以使用伴随矩阵也可以使用初等行变换来解求解，但是这样如果矩阵的维数较大的时候，使用这种方法，矩阵的维数变大时，计算量急剧的变大，计算时间和使用内存也会按着指数急剧上升，这样的算法的生命力不行。

使用以下这种算法的计算量和使用内存不会发生急剧的变化，特别是矩阵在维数大的时候。

高斯-约旦法（全选主元）求逆的步骤如下：首先，对于 k 从 0 到 n - 1 作如下几步：从第 k 行、第 k 列开始的右下角子阵中选取绝对值最大的元素，并记住次元素所在的行号和列号，在通过行交换和列交换将它交换到主元素位置上。

这一步称为全选主元。

m(k, k) = 1 / m(k, k)m(k, j) = m(k, j) * m(k, k)，j = 0, 1, ..., n-1；j != km(i, j) = m(i, j) - m(i, k) * m(k, j)，i, j = 0, 1, ..., n-1；i, j != km(i, k) = -m(i, k) * m(k, k)，i = 0, 1, ..., n-1；i != k最后，根据在全选主元过程中所记录的行、列交换的信息进行恢复，恢复的原则如下：在全选主元过程中，先交换的行（列）后进行恢复；原来的行（列）交换用列（行）交换来恢复。

#include"stdio.h"#include"malloc.h"#include"math.h"//数学函数void main(){ int inv(double *p,int n);double a[4][4]={{1,2,0,0},{2,5,0,0},{0,0,3,0},{0,0,0,1}},*ab;ab=a[0];int n=4,i=0,j;i=inv(ab,n);//调用矩阵求逆if(i!=0)//如果返回值不是0for(i=0;i<n;i++)//输出结果{ putchar('\n');for(j=0;j<n;j++)printf("%f",a[i][j]);}}int inv(double *p,int n){void swap(double *a,double *b); int *is,*js,i,j,k,l;for(i=0;i<n;i++){ putchar('\n');for(j=0;j<n;j++)printf("%f",*(p+i*n+j));}puts("\n\n\n\n");double temp,fmax;is=(int *)malloc(n*sizeof(int));js=(int *)malloc(n*sizeof(int));for(k=0;k<n;k++){fmax=0.0;for(i=k;i<n;i++)for(j=k;j<n;j++){ temp=fabs(*(p+i*n+j));//找最大值if(temp>fmax){ fmax=temp;is[k]=i;js[k]=j;}}if((fmax+1.0)==1.0){free(is);free(js);printf("no inv");return(0);}if((i=is[k])!=k)for(j=0;j<n;j++)swap(p(k*n+j),p(i*n+j));//交换指针if((j=js[k])!=k)for(i=0;i<n;i++)swap(p(i*n+k),p(i*n+j));//交换指针p[k*n+k]=1.0/p[k*n+k];for(j=0;j<n;j++)if(j!=k)p[k*n+j]*=p[k*n+k];for(i=0;i<n;i++)if(i!=k)for(j=0;j<n;j++)if(j!=k)p[i*n+j]=p[i*n+j]-p[i*n+k]*p[k*n+j]; for(i=0;i<n;i++)if(i!=k)p[i*n+k]*=-p[k*n+k];}for(k=n-1;k>=0;k--){if((j=js[k])!=k)for(i=0;i<n;i++)swap((p+j*n+i),(p+k*n+i));if((i=is[k])!=k)for(j=0;j<n;j++)swap((p+j*n+i),(p+j*n+k);}free(is);free(js);return 1;}void swap(double *a,double *b) {double c;c=*a;*a=*b;*b=c;}。

矩阵求逆函数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语言求逆矩阵

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;//初等变换时系数，设初值为1
MatEnhanced[k] = MatEnhanced[i];
MatEnhanced[i] = temp;
}
//初等变换
for(j=0;j<num;j++)//对其他行的所有列进行计算
{
if(j != i)//本行不参与计算
{
if(MatEnhanced[j][i] != 0)//只有当其不为零时进行计算，否则不计算
//////////////////////////////////////////////////////////////////////////////////////////
//应用矩阵初等变换的方法求逆矩阵
//参数说明：
// naturalmat原矩阵
// num矩阵的阶数
// InvMat求解结果，逆矩阵
for(i=0;i<num;i++) //增广矩阵赋值，前半部分
{
for(j=0;j<num;j++)
MatEnhanced[i][j] = n=0;i<num;i++) //增广矩阵赋值，后半部分
{
for(j=num;j<2*num;j++)
MatEnhanced[i][j] = 0;//先将后半部分全部赋值为0

可逆阵求逆可逆矩阵C语言代码

可逆阵求逆可逆矩阵C语言代码#include#includetypedef struct _matrix{int n;double** pm;} matrix;matrix input(FILE* fp){int i, j, n;matrix m;fscanf(fp, "%d", &n);m.pm = malloc(n*sizeof(double*));for (i=0; im.pm[i] = malloc(n*sizeof(double));m.n = n;for (i=0; ifor (j=0; jfscanf(fp, "%lf", &m.pm[i][j]);return m;}void output(matrix m){int i, j;for (i=0; i{for (j=0; jprintf("%4.2f ", m.pm[i][j]);printf("\n");}}matrix rev(matrix m){matrix r;int i, j, k, n;n = r.n = m.n;r.pm = malloc(n*sizeof(double*));for (i=0; ir.pm[i] = malloc(n*sizeof(double));for (i=0; ifor (j=0; j{if (i==j)r.pm[i][j] = 1.0;elser.pm[i][j] = 0.0;}//将第k行的第一个非零元单位化；并将第k+1至最后一行的第k列化为零;得到行阶梯型for (k=0; k<2; k++){//在第k列中选非零元double tmp;i = k;while ( ( m.pm[i][i] < 0.00001) && ( -m.pm[i][i] < 0.00001) ) i++;for (j=0; j{double tmp;tmp = m.pm[i][j]; m.pm[i][j] = m.pm[k][j]; m.pm[k][j] = tmp; tmp = r.pm[i][j]; r.pm[i][j] = r.pm[k][j]; r.pm[k][j] = tmp;}tmp = m.pm[k][k];for (j=0; j{m.pm[k][j] /= tmp;r.pm[k][j] /= tmp;}//将第k+1至最后一行的第k列化为零for (i=k+1; i{double tmp = m.pm[i][k];for (j=0; j{m.pm[i][j] -= tmp * m.pm[k][j];r.pm[i][j] -= tmp * r.pm[k][j];}}}//将行阶梯型化为行最简形(只关心逆矩阵)/**/for (k=n-1; k>0; k--)for (i=0; ifor (j=0; jr.pm[i][j] -= m.pm[i][k]*r.pm[k][j];return r;}int main(){FILE* fp;matrix m;fp = fopen("matrix.txt", "r");m = input(fp);output(m);printf("\n");output(rev(m));printf("\n");// output(m);return 0;}。

矩阵求逆c代码

叫做下三角矩阵.[2]
2、逆矩阵的概念
定义：设 A 是数域 P 上的一个 n 阶方阵，如果存在 P 上的 n 阶方阵 B，使得 AB = BA = E，则称 A 是可逆的，又称 B 为 A 的逆矩阵.当矩阵 A 可逆时，逆矩阵由 A 惟一确定，记为 A-1. [3]
2
本科课程设计报告
2、矩阵的初等变换
4、矩阵可逆的条件
（1）n 阶方阵 A 可逆的充分必要条件是| A | ≠ 0（也即 r（A）= n）；（2） n 阶方阵 A 可逆的充分必要条件是 A 可以通过初等变换（特别是只通过初等行（列）变换）化为 n 阶单位矩阵；（3）n 阶方阵 A 可逆的充分必要条件是 A 可以写成一些初等矩阵的乘积；（4）n 阶方阵 A 可逆的充分必要条件是 A 的 n 个特征值不为零；（5）对于 n 阶方阵 A，若存在 n 阶方阵 B 使得 AB = E（或 BA = E），则 A 可逆，且 A =B.
3 、有关矩阵求逆的定义定理
定义 1 n 级方阵 A 称为可逆的，如果 n 级方阵 B，使得 AB=BA=E 这里 E 是 n 级单位矩阵。定义 2 定理 1 定理 2 如果 B 适合（1），那么 B 就称为 A 的逆矩阵，记作 A 。如果 A 有逆矩阵，则逆矩阵是唯一的。矩阵 A 可逆的充分必要条件是 A 0 ，并且当 A 可逆时,有
称为 m n 矩阵，其中数 aij 称为矩阵 A 的 (i, j ) 元. 当 m n 时，称 A 为 n 阶矩阵或 n 方阵. 元素全为零的矩阵称为零矩阵，记作 Omn 或简记为 O . 两个矩阵 A (aij ) mn ， B (bij ) st ，如果 m s ， n t ，则称矩阵 A 与 B 为同型矩阵. 如果两个同型矩阵 A (aij ) 与 B (bij ) 的对应元素相等，即 aij bij ，

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 <math.h>#include <malloc.h>#include <iomanip.h>#define N 10 //定义方阵的最大阶数为10//函数的声明部分float MatDet(float *p, int n); //求矩阵的行列式float Creat_M(float *p, int m, int n, int k); //求矩阵元素A(m, n)的代数余之式void print(float *p, int n); //输出矩阵n*nbool Gauss(float A[][N], float B[][N], int n); //采用部分主元的高斯消去法求方阵A的逆矩阵Bint main(){float *buffer, *p; //定义数组首地址指针变量int row, num; //定义矩阵的行数和矩阵元素个数int i, j;float determ; //定义矩阵的行列式float a[N][N], b[N][N];int n;cout << "采用逆矩阵的定义法求矩阵的逆矩阵!\n";cout << "请输入矩阵的行数: ";cin >> row;num = 2 * row * row;buffer = (float *)calloc(num, sizeof(float)); //分配存单元p = buffer;if (NULL != p){for (i = 0; i < row; i++){cout << "Please input the number of " << i+1 << " row: ";for (j = 0; j < row; j++){cin >> *p++;}}}else{cout << "Can't distribute memory\n";}cout << "The original matrix : \n";print(buffer, row); //打印该矩阵determ = MatDet(buffer, row); //求整个矩阵的行列式p = buffer + row * row;if (determ != 0){cout << "The determinant of the matrix is " << determ << endl;for (i = 0; i < row; i++) //求逆矩阵{for (j = 0; j < row; j++){*(p+j*row+i) = Creat_M(buffer, i, j, row)/determ;}}cout << "The inverse matrix is: " << endl;print(p, row); //打印该矩阵}else{cout << "The determinant is 0, and there is no inverse matrix!\n"; }free(buffer); //释放存空间cout << "采用部分主元的高斯消去法求方阵的逆矩阵!\n";cout << "请输入方阵的阶数: ";cin >> n;cout << "请输入" << n << "阶方阵: \n";//输入一个n阶方阵for (i = 0; i < n; i++){for (j = 0; j < n; j++){cin >> a[i][j];}}//运用高斯消去法求该矩阵的逆矩阵并输出if (Gauss(a, b, n)){cout << "该方阵的逆矩阵为: \n";for (i = 0; i < n; i++){cout << setw(4);for (j = 0; j < n; j++){cout << b[i][j] << setw(10);}cout << endl;}}return 0;}//----------------------------------//功能: 求矩阵(n*n)的行列式//入口参数: 矩阵的首地址，矩阵的行数//返回值: 矩阵的行列式值//----------------------------------float MatDet(float *p, int n){int r, c, m;int lop = 0;float result = 0;float mid = 1;if (n != 1){lop = (n == 2) ? 1 : n; //控制求和循环次数,若为2阶，则循环1次，否则为n次for (m = 0; m < lop; m++){mid = 1; //顺序求和, 主对角线元素相乘之和for (r = 0, c = m; r < n; r++, c++){mid = mid * (*(p+r*n+c%n));}result += mid;}for (m = 0; m < lop; m++){mid = 1; //逆序相减, 减去次对角线元素乘积for (r = 0, c = n-1-m+n; r < n; r++, c--){mid = mid * (*(p+r*n+c%n));}result -= mid;}}elseresult = *p;return result;}//------------------------------------------------------//功能: 求k*k矩阵中元素A(m, n)的代数余之式//入口参数: k*k矩阵的首地址，矩阵元素A的下标m,n,矩阵行数k//返回值: k*k矩阵中元素A(m, n)的代数余之式//-------------------------------------------------------float Creat_M(float *p, int m, int n, int k){int len;int i, j;float mid_result = 0;int sign = 1;float *p_creat, *p_mid;len = (k-1)*(k-1); //k阶矩阵的代数余之式为k-1阶矩阵p_creat = (float*)calloc(len, sizeof(float)); //分配存单元p_mid = p_creat;for (i = 0; i < k; i++){for (j = 0; j < k; j++){if (i != m && j != n) //将除第i行和第j列外的所有元素存储到以p_mid为首地址的存单元{*p_mid++ = *(p+i*k+j);}}}sign = (m+n)%2 == 0 ? 1 : -1; //代数余之式前面的正、负号mid_result = (float)sign*MatDet(p_creat, k-1);free(p_creat);return mid_result;}//----------------------//功能: 打印n*n矩阵//入口参数: n*n矩阵的首地址,矩阵的行数n//返回值: 无返回值void print(float *p, int n){for (i = 0; i < n; i++){cout << setw(4);for (j = 0; j < n; j++){cout << setiosflags(ios::right) << *p++ << setw(10);}cout << endl;}}//----------------------------------------------//功能: 采用部分主元的高斯消去法求方阵A的逆矩阵B//入口参数: 输入方阵，输出方阵，方阵阶数//返回值: true or false//----------------------------------------------bool Gauss(float A[][N], float B[][N], int n){int i, j, k;float max, temp;float t[N][N]; //临时矩阵//将A矩阵存放在临时矩阵t[n][n]中for (i = 0; i < n; i++){for (j = 0; j < n; j++){t[i][j] = A[i][j];}}//初始化B矩阵为单位阵for (i = 0; i < n; i++){for (j = 0; j < n; j++){B[i][j] = (i == j) ? (float)1 : 0;}}for (i = 0; i < n; i++){//寻找主元max = t[i][i];k = i;for (j = i+1; j < n; j++)if (fabs(t[j][i]) > fabs(max)){max = t[j][i];k = j;}}//如果主元所在行不是第i行，进行行交换if (k != i){for (j = 0; j < n; j++){temp = t[i][j];t[i][j] = t[k][j];t[k][j] = temp;//B伴随交换temp = B[i][j];B[i][j] = B[k][j];B[k][j] = temp;}}//判断主元是否为0, 若是, 则矩阵A不是满秩矩阵,不存在逆矩阵if (t[i][i] == 0){cout << "There is no inverse matrix!";return false;}//消去A的第i列除去i行以外的各行元素temp = t[i][i];for (j = 0; j < n; j++){t[i][j] = t[i][j] / temp; //主对角线上的元素变为1B[i][j] = B[i][j] / temp; //伴随计算}for (j = 0; j < n; j++) //第0行->第n行{if (j != i) //不是第i行{temp = t[j][i];for (k = 0; k < n; k++) //第j行元素- i行元素*j列i行元素{t[j][k] = t[j][k] - t[i][k]*temp;B[j][k] = B[j][k] - B[i][k]*temp;}}}}return true; }。

矩阵的逆c++语言

在C++中，计算矩阵的逆需要使用线性代数库。

其中，Eigen库是一个广泛使用的C++线性代数库，它提供了计算矩阵逆的功能。

以下是一个使用Eigen库计算矩阵逆的示例代码：```c++#include <iostream>#include <Eigen/Dense>using namespace Eigen;int main() {MatrixXd A(2, 2); // 声明一个2x2的矩阵AA(0, 0) = 1;A(0, 1) = 2;A(1, 0) = 3;A(1, 1) = 4;std::cout << "矩阵A：" << std::endl << A << std::endl;MatrixXd A_inv = A.inverse(); // 计算矩阵A的逆矩阵std::cout << "矩阵A的逆矩阵：" << std::endl << A_inv << std::endl;return 0;}```在上面的代码中，我们首先声明一个2x2的矩阵A，并初始化它的元素。

然后，我们使用`inverse()`函数计算矩阵A的逆矩阵，并将结果存储在`A_inv`变量中。

最后，我们输出矩阵A和它的逆矩阵。

需要注意的是，不是所有的矩阵都有逆矩阵。

如果一个矩阵不可逆（即，它的行列式为0），那么它的逆矩阵就不存在。

在这种情况下，使用`inverse()`函数将导致运行时错误。

因此，在实际应用中，我们需要先检查矩阵是否可逆，然后再计算它的逆矩阵。

C#矩阵类代码(实现相加,转置,求逆功能)

using System;class Matrix{double [,] matrix;public int row=0, col=0;//int i=0,j=0;//int count=1;//定义三个不同情况下的构造函数public Matrix(){}public Matrix(int row){matrix = new double[row, row];}public Matrix(int row, int col){this.row = row;this.col = col;matrix = new double[row, col];}//复制构造函数public Matrix(Matrix m){int row = m.row;int col = m.col;matrix = new double[row, col];for (int i = 0; i < row; i++)for (int j = 0; j < col; j++)matrix[i, j] = m.getNum(i, j);}//输入相应的值，对矩阵进行设置public void SetNum(int i,int j, double num){matrix[i, j] = num;}//得到相应的矩阵某个数public double getNum(int i,int j){return matrix[i, j];}//输出矩阵public void OutputM(){Console.WriteLine("矩阵为：");for (int p = 0; p < row; p++){for (int q = 0; q < col; q++){Console.Write("\t"+matrix[p,q]);}Console.Write("\n");}}//输入矩阵具体数字实现public void InputM(int Row, int Col){for (int a = 0; a < Col; a++){for (int b = 0; b < Col; b++){Console.WriteLine("第{0}行，第{1}列", a + 1, b + 1);double value = Convert.ToDouble(Console.ReadLine());this.SetNum(a, b, value);}}}//得到matrixpublic double[,] Detail{get { return matrix; }set { matrix = value; }}//矩阵转置实现public Matrix Transpose(){Matrix another = new Matrix(row, col);for (int i = 0; i < row; i++){for (int j = 0; j < col; j++){another.SetNum(j, i, matrix[i, j]);}}return another;}//矩阵相加实现public static Matrix Add(Matrix lm,Matrix rm){//行出错if (lm.row != rm.row){System.Exception e = new Exception("相加的两个矩阵的行数不等");throw e;}//列出错if (lm.col != rm.col){System.Exception e = new Exception("相加的两个矩阵的列数不等");throw e;}Matrix another=new Matrix(lm.row,lm.col);for(int i=0;i<lm.row;i++){for(int j=0;j<lm.col;j++){double temp=lm.getNum(i,j)+rm.getNum(i,j);another.SetNum(i, j, temp);}}return another;}//矩阵求逆实现public static Matrix Inverse(Matrix M){int m = M.row;int n = M.col;if (m != n){Exception myException = new Exception("求逆的矩阵不是方阵");throw myException;}Matrix ret = new Matrix(m, n);double[,] a0 = M.Detail;double[,] a = (double[,])a0.Clone();double[,] b = ret.Detail;int i, j, row, k;double max, temp;//单位矩阵for (i = 0; i < n; i++){b[i, i] = 1;}for (k = 0; k < n; k++){max = 0; row = k;//找最大元，其所在行为rowfor (i = k; i < n; i++){temp = Math.Abs(a[i, k]);if (max < temp){max = temp;row = i;}}if (max == 0){Exception myException = new Exception("该矩阵无逆矩阵");throw myException;}//交换k与row行if (row != k){for (j = 0; j < n; j++){temp = a[row, j];a[row, j] = a[k, j];a[k, j] = temp;temp = b[row, j];b[row, j] = b[k, j];b[k, j] = temp;}}//首元化为1for (j = k + 1; j < n; j++) a[k, j] /= a[k, k];for (j = 0; j < n; j++) b[k, j] /= a[k, k];a[k, k] = 1;//k列化为0//对afor (j = k + 1; j < n; j++){for (i = 0; i < k; i++) a[i, j] -= a[i, k] * a[k, j];for (i = k + 1; i < n; i++) a[i, j] -= a[i, k] * a[k, j];}//对bfor (j = 0; j < n; j++){for (i = 0; i < k; i++) b[i, j] -= a[i, k] * b[k, j];for (i = k + 1; i < n; i++) b[i, j] -= a[i, k] * b[k, j];}for (i = 0; i < n; i++) a[i, k] = 0;a[k, k] = 1;}return ret;}//主函数public static void Main(){int Row, Col, choice;Console.WriteLine("请输入想要的矩阵行数与列数");Row = Convert.ToInt32(Console.ReadLine());Col = Convert.ToInt32(Console.ReadLine());Matrix m = new Matrix(Row, Col);Console.WriteLine("输入矩阵数据");m.InputM(Row, Col);m.OutputM();do{Console.WriteLine("请选择你想要进行的运算：\n（1）转置；\n（2）输入另一矩阵并相加；\n（3）求逆；(0)停止；");choice = Convert.ToInt32(Console.ReadLine());switch (choice){case 1:Matrix n = m.Transpose();n.OutputM();break;case 2:Console.WriteLine("请输入第二个矩阵行数与列数");Row = Convert.ToInt32(Console.ReadLine());Col = Convert.ToInt32(Console.ReadLine());Matrix m2 = new Matrix(Row, Col);Console.WriteLine("输入矩阵数据");m2.InputM(Row, Col);Console.WriteLine("第二个矩阵为：");m2.OutputM();Matrix result = Add(m, m2);result.OutputM();break;case 3:Matrix m3 = Inverse(m);m3.OutputM();break;case 0:break;}}while (choice != 0);Console.Write("请按任意键继续");Console.ReadLine();}}。

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中。

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结构体来表示矩阵，包含一个二维数组来存储矩阵的元素。