矩阵求逆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;}。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

叫做下三角矩阵.[2]
2、逆矩阵的概念
定义：设 A 是数域 P 上的一个 n 阶方阵，如果存在 P 上的 n 阶方阵 B，使得 AB = BA = E，则称 A 是可逆的，又称 B 为 A 的逆矩阵.当矩阵 A 可逆时，逆矩阵由 A 惟一确定，记为 A-1. [3]
2
本科课程设计报告
2、矩阵的初等变换
4、矩阵的秩
前面给出了利用矩阵行列式 A 判别方阵 A 是否可逆的方法，除了这种方法外，还可以利用矩阵 A 的特征之一——矩阵的秩来判别方阵 A 的可逆性. 矩阵的秩是线性代数中非常有用的一个概念，它不仅与讨论可逆矩阵的问题
3
本科课程设计报告
有密切关系，而且在讨论线性方程组的解的情况中也有重要应用. 在给出矩阵的秩的概念之前，先要定义矩阵的子式. 定义：在矩阵 A 中，位于任意选定的 k 行、k 列交叉点上的 k 2 个元素，按原来次序组成的 k 阶子阵的行列式，称为 A 的一个 k 阶子式.如果子式的值不为零.就称为非零子式. 定义：矩阵 A 的非零子式的最高阶数称为矩阵 A 的秩，即秩(A ) . 规定：零矩阵 O 的秩为零,R(A)=0 定理：设 A 为 m n 矩阵，则 R(A)= k 的充分必要条件为：通过初等行变换能将 A 化为具有 k 个非零行的阶梯阵. 定理：矩阵经过初等行变换后，其秩不变. 定理：给了我们求矩阵的秩的一种简便方法，即利用初等行变换将一个矩阵 A 化成阶梯阵，然后算出矩阵 A 的秩.
-1
5、逆矩阵的性质
设 A，B 是 n 阶可逆矩阵，则（1）（A-1）-1 = A；（2）若 k ≠ 0，则 kA 可逆，且（kA）-1 = （3）AB 可逆，且（AB）-1 = B-1 A-1；（4）AT 可逆，且（AT）-1 = （A-1）T；（5）Ak 可逆，且（Ak）-1 = （A-1）k；（6）| A-1 | = | A |-1；（7）如果 A 是 m×n 矩阵，P 是 m 阶可逆矩阵，Q 是 n 阶可逆矩阵，则 r（A）= r （PA）= r（AQ）= r（PAQ）. 1 -1 A ； k
课程设计报告
学班学
院：级：号：
自动化学院 09011006 2010302184 胡晓杰杨峰 2013 年 6 月
学生姓名：指导教师：时间：
课程设计任务书
一、设计内容
掌握矩阵求逆的概念的原理，以及矩阵求逆的计算。编写程序完成矩阵求逆计算。要处理的数据由自己选择。
二、主要技术指标
初等行变换 E A 1 A E
通过对原矩阵进行初等行列变换求逆矩阵的方法也被称为高斯-约旦法。此方法比较适合于高阶矩阵求逆,但因为没有统一的算法可遵循,所以不太适合计算机编程。初等行列变化法包括初等行变换,初等列变换以及行列混合变换,后两种方法在求广义逆矩阵的时候经常能用到。而对于某些矩阵,先求其拟逆矩阵会比直接求逆矩阵要容易,而所求得的拟逆矩阵又可以利用行列互换原则再变回原矩阵的逆矩阵注： ①对于阶数较高（n≥3）的矩阵，采用初等行变换法求逆矩阵一般比用伴随矩阵法简便.在用上述方法求逆矩阵时，只允许施行初等行变换. ②也可以利用
2
2A 2 - 3A + 5E = 0 2A 2 - 3A = - 5E 2 3 - A 2 - A =E 5 5 2 3 2 3 A (- A - E) = - A - E = E 5 5 5 5 2 3 A可逆且 A -1 = - A - E 5 5
啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊啊方法 2 初等变换法 [6]
0 0 1 2 1 1
①+③(-1) ②+③(-1)
①+②
所以
所求逆矩阵是否正确，可以通过计算乘积矩阵 A 进行验证. 对给定的 n 阶矩阵 A，用上述方法也可以判断 A 是否可逆.即在对矩阵[ A , I ] 进行初等行变换的过程中，如果[ A , I ]中的左边的方阵出现零行，说明矩阵 A 是奇异的，即 A 0 ，可以判定 A 不可逆；如果[ A , I ]中的左边的方阵被化成了单位阵 I，说明 A 是非奇异的，可以判定 A 是可逆的，而且这个单位矩阵 I 右边的方阵就是 A 的逆矩阵，它是由单位矩阵 I 经过同样的初等行变换得到的.
（2）掌握矩阵求逆的概念的原理，以及矩阵求逆的计算。（3）用 C 或者 C++实现矩阵求逆（4）处理结果与 Matlab 求逆结果对比（5）阅读矩阵求逆方面文献 10 篇以上
三、进度要求
两周完成设计任务，写 5000 字以上的小论文。附参考文献并在论文中进行标注。
学
生

胡晓杰
指导教师
杨峰
本科课程设计报告 1. 设计内容
②(1/2) ③+② ②+①(-1) ③+①(-2)
1 1 1 1 0 0 0 2 2 1 1 0 0 1 0 2 0 1 7 1 1 0 2 0 1 0 2 5 0 0 1 2 1 2 0 1 2 1 1 1
3 、有关矩阵求逆的定义定理
定义 1 n 级方阵 A 称为可逆的，如果 n 级方阵 B，使得 AB=BA=E 这里 E 是 n 级单位矩阵。定义 2 定理 1 定理 2 如果 B 适合（1），那么 B 就称为 A 的逆矩阵，记作 A 。如果 A 有逆矩阵，则逆矩阵是唯一的。矩阵 A 可逆的充分必要条件是 A 0 ，并且当 A 可逆时,有
形如
1
本科课程设计报告
a11 0 0 0 a22 0 0 0 ann
的 n 阶方阵，即主对角线以外的元素都是零的方阵称为对角矩阵或对角方阵，记作
a1 diag (a1 , a2 , , a n ) a2 . an
主对角线下方的元素都是零的方阵
a11 0 0 a12 a1n a22 a2 n 0 ann
叫做上三角矩阵. 主对角线上方的元素都是零的方阵
a11 a 21 an1 0 a22 an 2 0 0 ann
矩阵的初等行变换是指对矩阵进行下列三种变换： (1) 将矩阵中某两行对换位置； (2) 将某一行遍乘一个非零常数 k； (3) 将矩阵的某一行遍乘一个常数 k 加至另一行. 并称(1)为对换变换，称(2)为倍乘变换，称(3)为倍加变换. （4）矩阵 A 经过初等行变换后变为 B，用 A B 表示，并称矩阵 B 与 A 是等价的
1
（1）
A 1
1 A *。 A
定理证明见. 定理 2 不仅给出了判断一个矩阵是否可逆的一种方法，并且给出了求逆矩阵的一种方法，但是这种方法主要用在理论上以及 2 级或 3 级矩阵的情形，如果阶数较大，那么使用此方法计算量太大。由定理 2 逆矩阵判定的方法还有：推论 2.1 推论 2.2 推论 2.3 n 级矩阵 A 可逆的充要条件是矩阵 A 的秩为 n。矩阵 A 可逆的充要条件是它的特征值都不为 0。 n 级矩阵 A 可逆的充分必要条件是它的行 ( 或列 ) 向量组线性无关。[4]
i 1, 2, , m ， j 1, 2, , n ，则称矩阵 A 与 B 相等，记作 A B 或 (aij ) mn (bij ) mn .[1]
当 m 1 时，矩阵 A (a1 , a2 , , an ) 称为行矩阵或行向量.
b1 b 当 n 1 时，，矩阵 A 2 称为列矩阵或列向量. bm
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.
5、求矩阵逆的方法
4
本科课程设计报告
方法 1 定义法 [5] 设 A 是数域 P 上的一个 n 阶方阵，如果存在 P 上的 n 阶方阵 B，使得 AB = BA = E，则称 A 是可逆的，又称 B 为 A 的逆矩阵.当矩阵 A 可逆时，逆矩阵由 A 惟一确定，记为 A-1. 例 1：设 A 为 n 阶矩阵，且满足 2A - 3A + 5E = 0 ，求 A-1. 【解】
称为 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 ，
掌握矩阵求逆的概念的原理，以及矩阵求逆的计算。编写程序完成矩阵求逆计算。要处理的数据由自己选择。
2. 设计过程
1、
矩阵的定义
由 m n 个数 aij (i 1, 2, , m; j 1, 2, , n) 排列成 m 个行 n 个列的数表
a11 a A 21 am1 a12 a22 am 2 a14 a1n amn
5
本科课程设计报告
1 1 1 例 2. 设矩阵 A = 1 1 3 2 3 2