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

合集下载

c语言实现矩阵的相关操作

算法分析与设计课程论文—通过C语言实现矩阵的相关操作一．摘要本文在Microsoft Visual Studio 2010的编译环境下，通过C语言进行一些矩阵的基本操作，包括矩阵的设置，加减乘除，数乘运算。

求矩阵的逆等操作。

关键词矩阵 C语言逆矩阵二．正文1.引言矩阵的相关知识只是是高等数学的基础，但是其庞大的运算量和纷繁的步骤让人却步。

虽然有Matlab等软件可以实现矩阵的相关操作，但是我校一些专业并不学习数学实验，故通过C语言实现矩阵的操作也是一种可行的方法，本文列举的了一些矩阵的加减乘除等基本运算规则，还有对矩阵进行转置，也有矩阵求逆的相关操作。

同时，还介绍了行列式的计算，通过运行该程序，可以大大简化行列式的计算量。

2.算法分析矩阵的初始化相关概念在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合，最早来自于方程组的系数及常数所构成的方阵。

这一概念由19世纪英国数学家凯利首先提出。

矩阵是高等代数学中的常见工具，也常见于统计分析等应用数学学科中。

在物理学中，矩阵于电路学、力学、光学和量子物理中都有应用；计算机科学中，三维动画制作也需要用到矩阵。

矩阵的运算是数值分析领域的重要问题。

将矩阵分解为简单矩阵的组合可以在理论和实际应用上简化矩阵的运算。

对一些应用广泛而形式特殊的矩阵，例如稀疏矩阵和准对角矩阵，有特定的快速运算算法。

理论分析在C语言中，可以使用二维数组来描绘一个矩阵。

值得注意的是，在二维数组中，必须标明列数，否则编译器就会报错。

故二维极其多维数组使用时要注意数组下标。

代码实现#include<stdio.h>int main(){int juzheng [100][100];int i , j , a , b ;printf("请输入矩阵的行数a 列数b \n") ;scanf ("%d %d",&a,&b);for (i = 0;i < a ;i++){for (j = 0;j < b ;j++){scanf ("%d",&juzheng[i][j]);}}printf ("你所输入的矩阵是：\n");for (i = 0;i < a ;i++){for (j = 0;j < b ;j++){printf("%d ",juzheng[i][j]);}printf ("\n");}return 0;}矩阵的相加相关概念加法矩阵的加法满足下列运算律(A，B，C都是同型矩阵)：A+B=B+AA+B+C=A+(B+C）应该注意的是只有同型矩阵之间才可以进行加法理论分析：矩阵相加就是将两个矩阵的相同位置的元素相加，相加的值输出，通过循环语句，可以很好的实现该过程，如果要改成减法的话，就可以改成printf(“%d”,juzhen1[i][j]-juzhen2[i][j])。

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

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

高斯-约旦法（全选主元）求逆的步骤如下：首先，对于 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语言实现矩阵的加减乘除求逆运算

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

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语言矩阵求逆方法讲解C语言矩阵求逆方法讲解引言:在线性代数中，矩阵的逆是一个非常重要的概念，它在解线性方程组、计算特征值和特征向量等方面具有广泛的应用。

在C语言中，我们可以通过使用一些算法和方法来实现矩阵的求逆。

本文将详细介绍C语言中常用的矩阵求逆方法，并对其实现原理进行讲解。

一、代数余子式和伴随矩阵方法：代数余子式和伴随矩阵方法是求解矩阵逆的传统方法之一。

它们利用了矩阵的代数余子式和伴随矩阵的性质来进行计算。

具体步骤如下：1. 计算矩阵的伴随矩阵：对于一个n阶方阵A，它的伴随矩阵记作Adj(A)，其中的元素(adjA)ij是A的代数余子式乘以(-1)^(i+j)。

2. 计算矩阵的行列式：对于一个n阶方阵A，它的行列式记作det(A)，行列式的计算是通过对A的每一行或每一列进行展开得到的。

3. 判断行列式是否为零：如果det(A)等于零，则表示A不可逆，无法得到逆矩阵；如果det(A)不等于零，则表示A可逆。

4. 计算矩阵的逆：如果A可逆，则逆矩阵A^(-1)可以通过公式A^(-1) = (1/det(A)) * Adj(A)来计算得到。

二、高斯-约当消元法：高斯-约当消元法是一种基于矩阵的行变换和初等行变换的方法，通过将原矩阵转化为行简化阶梯形矩阵，然后再通过回代的方式求解矩阵的逆。

具体步骤如下：1. 增广矩阵变换：将原矩阵与单位矩阵进行组合构成增广矩阵，即(A|I)。

2. 初等行变换：利用初等行变换将增广矩阵转化为行简化阶梯形矩阵。

行简化阶梯形矩阵的特点是主对角线上的元素为1，主对角线以下的元素为0。

3. 回代求解逆矩阵：通过回代的方式求解矩阵的逆矩阵。

回代的步骤为：从行简化阶梯形矩阵的最后一行开始，逐行进行回代计算，将每一行的元素变为1，同时将主对角线以下的元素变为0。

最终得到的矩阵即为原矩阵的逆。

三、实现原理和注意事项：1. 代数余子式和伴随矩阵方法的实现原理比较简单，只需要对矩阵进行一系列的计算即可得到逆矩阵。

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#矩阵类代码(实现相加,转置,求逆功能)

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

可逆阵求逆可逆矩阵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矩阵基本运算代码

C#矩阵的运算代码#region 矩阵运算/// <summary>/// 矩阵对应行列式的值/// </summary>/// <param ></param>/// <returns></returns>private double MatrixValue(double[,] MatrixList){int Level = MatrixList.GetLength(1);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];}}int sign = 1;for (int i = 0, j = 0; i < Level && j < Level; i++, j++){//判断改行dMatrix[i, j]是否为0，若是，则寻找i后的行（m,m>i，切dMatrix[m, j]!=0)进行交换if (dMatrix[i, j] == 0){if (i == Level - 1){return 0;}int m = i + 1;//获取一个dMatrix[m, j]不为为0的行for (; dMatrix[m, j] == 0; m++){if (m == Level - 1){return 0;}}//判断是否达到矩阵的最大行，若是，则返回0//把i行和m行调换double temp;for (int n = j; n < Level; n++){temp = dMatrix[i, n];dMatrix[i, n] = dMatrix[m, n];dMatrix[m, n] = temp;}sign *= (-1);}//把当前行以后的行所对应的列变成0double tmp;for (int s = Level - 1; s > i; s--){tmp = dMatrix[s, j];//j行后面的所有行for (int t = j; t < Level; t++){dMatrix[s, t] -= dMatrix[i, t] * (tmp / dMatrix[i, j]);}}}double result = 1;for (int i = 0; i < Level; i++){if (dMatrix[i, i] != 0){result *= dMatrix[i, i];}else{return 0;}}return sign * result;}/// <summary>/// 矩阵减法/// </summary>/// <param ></param>/// <param ></param>/// <param ></param>/// <param ></param>private double[] SubMatrix(double[] A1, double[] A2) {//判断矩阵的长短是否一致int a1 = A1.GetLength(0);int a2 = A2.GetLength(0);if (a1 != a2){return null;}//矩阵相减double[] B = new double[a1];for (int i = 0; i < a1; i++){B[i] = A1[i] - A2[i];}return B;}/// <summary>/// 矩阵乘法/// </summary>/// <param ></param>/// <param ></param>/// <returns></returns>private double[,] MultiplyMatrix(double[,] firstMatrix, double[,] secondMatrix){double[,] resultMatrix = new double[firstMatrix.GetLength(0), secondMatrix.GetLength(1)]; //判断相乘矩阵是否合法，即第一个矩阵的列要等于第二个矩阵的行if (firstMatrix.GetLength(1) != secondMatrix.GetLength(0)){return null;}//求结果矩阵for (int rowIndex = 0; rowIndex < firstMatrix.GetLength(0); rowIndex++){for (int colIndex = 0; colIndex < secondMatrix.GetLength(1); colIndex++){//初始化结果矩阵的元素resultMatrix[rowIndex, colIndex] = 0;for (int i = 0; i < firstMatrix.GetLength(1); i++){//求结果矩阵的元素值resultMatrix[rowIndex, colIndex] += firstMatrix[rowIndex, i] * secondMatrix[i, colIndex];}}}return resultMatrix;}/// <summary>/// 求逆矩阵/// </summary>/// <param ></param>/// <returns></returns>private double[,] Athwart(double[,] dMatrix){//获取矩阵的行数int Level = dMatrix.GetLength(1);double[,] dReverseMatrix = new double[Level, 2 * Level]; //初始化矩阵Level×(2*Level)for (int i = 0; i < Level; i++){for (int j = 0; j < 2 * Level; j++){if (j < Level){dReverseMatrix[i, j] = dMatrix[i, j];}else{if (j - Level == i){dReverseMatrix[i, j] = 1;}else{dReverseMatrix[i, j] = 0;}}}}for (int i = 0, j = 0; i < Level && j < Level; i++, j++){if (dReverseMatrix[i, j] == 0){if (i == Level - 1){return null;}int m = i + 1;for (; dMatrix[m, j] == 0; m++){if (m == Level - 1){return null;}if (m == Level){return null;}else{//把i行和m行相加for (int n = j; n < 2 * Level; n++){dReverseMatrix[i, n] += dReverseMatrix[m, n];}}}double temp = dReverseMatrix[i, j];if (temp != 1){//把i行数据，变成以1开始的一行数据for (int n = j; n < 2 * Level; n++){if (dReverseMatrix[i, n] != 0){dReverseMatrix[i, n] /= temp;}}}//把i行后的所有行的j列变成0for (int s = Level - 1; s > i; s--){temp = dReverseMatrix[s, j];for (int t = j; t < 2 * Level; t++){dReverseMatrix[s, t] -= (dReverseMatrix[i, t] * temp);}}}//把矩阵Level×(2*Level)前Level×Level转变为单位矩阵for (int i = Level - 2; i >= 0; i--){for (int j = i + 1; j < Level; j++){if (dReverseMatrix[i, j] != 0)double tmp = dReverseMatrix[i, j];for (int n = j; n < 2 * Level; n++){dReverseMatrix[i, n] -= (tmp * 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];}}return dReturn;}#endregion第二份：1using System;2using System.IO;3using System.Diagnostics;456namespace Adjust7{8///<summary>9///Matrix 的摘要说明。

求任意可逆矩阵的逆矩阵

#include"stdio.h"#include"stdlib.h"main(){{printf("\t程序功能：输出任意阶可逆矩阵的逆矩阵(原则上是10阶以下)\n");float a[10][10],b[10][10],w,e,c;int i,j,k,m,h,t,n=0,g,s,qw=0;printf("输入大于1的n阶矩阵,n=");scanf("%d",&s);while(s<2){printf("输入错误，输入大于1的n阶矩阵!,n=");scanf("%d",&s);}for(i=0;i<s;i++){for(j=0;j<s;j++){if(i==j)b[i][j]=1;elseb[i][j]=0;}}printf("输入%d阶矩阵的%d个元素(输一个元素按一个回车键)\n",s,s*s);for(i=0;i<s;i++)/*输入数据*/{for (j=0;j<s;j++){qw++;printf("\t输入第%d个元素: ",qw);scanf("%f",&a[i][j]);}}printf("原%d阶矩阵为\n",s);for(i=0;i<s;i++){for(j=0;j<s;j++){printf("%8.2f",b[i][j]);n++;if(n%s==0)printf("\n");}}for(i=0;i<s;i++)/* 使对角线上的元素为1,，同时使对应行的元素保持同步，并使同一列的元素为零*/{if(a[i][i]==0)/*不使主对角线上的元素为0 */{for(t=i+1;t<s;t++){if(a[t][i]!=0){c=a[i][i];a[i][i]=a[t][i];a[t][i]=c;c=b[i][i];b[i][i]=b[t][i];b[t][i]=c;for(g=i+1;g<s;g++){c=a[i][g];a[i][g]=a[t][g];a[t][g]=c;c=b[i][g];b[i][g]=b[t][g];b[t][g]=c;}}}if(a[i][i]==0){printf("不存在逆矩阵!");return 0;}}w=a[i][i];/*保存变量*/a[i][i]=a[i][i]*(1.0/a[i][i]);for(m=0;m<s;m++)/*使同一行的元素同步*/{b[i][m]=b[i][m]*(1.0/w);if(m!=i){a[i][m]=a[i][m]*(1.0/w);}}for(j=0;j<s;j++)/*使行数为1的元素所在列的其他元素为0，并保同一行上的元素同步*/{if(j!=i)/*行指标*/{h=0;/*保存变量*/for(k=0;k<s;k++)/*列指标*/{if(h==0)e=-a[j][i];a[j][k]=a[i][k]*e+a[j][k];b[j][k]=b[i][k]*e+b[j][k];h++;}}}}printf("\n 逆矩阵为\n");for(i=0;i<s;i++){for(j=0;j<s;j++){printf("%8.2f",b[i][j]);n++;if(n%s==0)printf("\n");}}}system("pause");return 0;}。

矩阵的运算程序(C语言版)

#include<stdio.h>#define M 20#define N 20float A[M][N];float B[M][N];float C[M][N];int i,j,m,n,p,q;float y=1.0;void main(){printf(" ###########################################\n");printf(" ##### 欢迎您使用矩阵函数包系统。

######\n");printf(" ##### 系统功能: ######\n");printf(" ##### 计算两个矩阵相加,相减; ######\n");printf(" ##### 数乘矩阵；矩阵转置;求逆 ######\n");printf(" ##### 矩阵 ######\n");printf(" ###########################################\n");printf("请选择您需要的运算，按回车键结束\n");printf("************************************************************* *****\n");printf("1，矩阵相加\n");printf("2，矩阵相减\n");printf("3，数乘矩阵\n");printf("4，矩阵转置\n");printf("5，逆矩阵 \n");printf("6，退出 \n");printf("************************************************************* *****\n");int x;scanf("%d",&x);switch (x){case 1:{printf("请输入矩阵A的行数和列数(用逗号隔开):");scanf("%d,%d",&i,&j);printf("请输入矩阵B的行数和列数(用逗号隔开):") ;scanf("%d,%d",&m,&n);if(i!=m||j!=n)printf("***对不起，您输入的两个矩阵不能相加，请重试.***\n");else printf("请输入矩阵A:\n");for(p=0;p<i;p++)for(q=0;q<j;q++)scanf("%f",&A[p][q]);printf("输出矩阵A：\n");for(p=0;p<i;p++)for(q=0;q<j;q++){printf("%10.2f",A[p][q]);if((q+1)%j==0)printf("\n");}printf("请输入矩阵B：\n");for(p=0;p<i;p++)for(q=0;q<j;q++)scanf("%f",&B[p][q]);printf("输出矩阵B：\n");for(p=0;p<i;p++)for(q=0;q<j;q++){printf("%10.2f",B[p][q]);if((q+1)%j==0)printf("\n");}printf("矩阵A+矩阵B为:\n"); //计算两个矩阵相加for(p=0;p<i;p++)for(q=0;q<j;q++)C[p][q]=A[p][q]+B[p][q];for(p=0;p<i;p++)for(q=0;q<j;q++){printf("%10.2f",C[p][q]);if((q+1)%j==0)printf("\n");}};break;case 2:{printf("请输入矩阵A的行数和列数(用逗号隔开):");scanf("%d,%d",&i,&j);printf("请输入矩阵B的行数和列数(用逗号隔开):") ;scanf("%d,%d",&m,&n);if(i!=m||j!=n)printf("***对不起，您输入的两个矩阵不能相减，请重试.***\n"); else printf("请输入矩阵A:\n");for(p=0;p<i;p++)for(q=0;q<j;q++)scanf("%f",&A[p][q]);printf("输出矩阵A:\n");for(p=0;p<i;p++)for(q=0;q<j;q++){printf("%10.2f",A[p][q]);if((q+1)%j==0)printf("\n");}printf("请输入矩阵B：\n");for(p=0;p<i;p++)for(q=0;q<j;q++)scanf("%f",&B[p][q]);printf("输出第矩阵B:\n");for(p=0;p<i;p++)for(q=0;q<j;q++){printf("%10.2f",B[p][q]);if((q+1)%j==0)printf("\n");}printf("矩阵A-矩阵B为：\n"); //计算两个矩阵相减for(p=0;p<i;p++)for(q=0;q<j;q++)C[p][q]=A[p][q]-B[p][q];for(p=0;p<i;p++)for(q=0;q<j;q++){printf("%10.2f",C[p][q]);if((q+1)%j==0)printf("\n");}};break;case 3:{float k;printf("请输入矩阵A的行数和列数(用逗号隔开):"); scanf("%d,%d",&i,&j);printf("请输入矩阵A\n");for(p=0;p<i;p++)for(q=0;q<j;q++)scanf("%f",&A[p][q]);printf("输出矩阵A\n");for(p=0;p<i;p++)for(q=0;q<j;q++){printf("%10.2f",A[p][q]);if((q+1)%j==0)printf("\n");}printf("请输入一个实数:\n");scanf("%f",&k);for(p=0;p<i;p++) //数乘矩阵for(q=0;q<j;q++)B[p][q]=k*A[p][q];printf("输出k乘矩阵A的结果\n");for(p=0;p<i;p++)for(q=0;q<j;q++){printf("%10.2f",B[p][q]);if((q+1)%j==0)printf("\n");}};break;case 4:{printf("请输入矩阵A的行数和列数(用逗号隔开):"); scanf("%d,%d",&i,&j);printf("请输入矩阵A:\n");for(p=0;p<i;p++)for(q=0;q<j;q++)scanf("%f",&A[p][q]);printf("输出矩阵A\n");for(p=0;p<i;p++)for(q=0;q<j;q++){printf("%10.2f",A[p][q]);if((q+1)%j==0)printf("\n");}for(p=0;p<i;p++) //转置for(q=0;q<j;q++)B[q][p]=A[p][q];printf("输出矩阵A的转置矩阵:\n");for(p=0;p<j;p++)for(q=0;q<i;q++){printf("%10.2f",B[p][q]);if((q+1)%i==0)printf("\n");}};break;case 5:float a[M][2*M];float b[N][2*N];float t,x;int k,T;printf("输入方阵的维数：\n"); //请输入方阵，即行和列相等的矩阵。

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

for (i=0; i<k; i++)
for (j=0; j<n; j++)
r.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.pm = malloc(n*sizeof(double*));
for (i=0; i<n; i++)
m.pm[i] = malloc(n*sizeof(double));
m.n = n;
for (i=0; i<n; i++)
for (j=0; j<n; j++)
fscanf(fp, "%lf", &m.pm[i][j]);
return m;
}
void output(matrix m)
{
int i, j;
for (i=0; i<m.n; i++)
{
for (j=0; j<m.n; j++)
printf("%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; i<n; i++)
r.pm[i] = malloc(n*sizeof(double));
for (i=0; i<n; i++)
for (j=0; j<n; j++)
{
if (i==j)
r.pm[i][j] = 1.0;
else
r.pm[i][j] = 0.0;
}
//将第k行的第一个非零元单位化；并将第k+1至最后一行的第k列化为零;得到行阶梯型
tmp = m.pm[k][k];
for (j=0; j<n; j++)
{
m.pm[k][j] /= tmp;
r.pm[k][j] /= tmp;
}
//将第k+1至最后一行的第k列化为零
for (i=k+1; i<n; i++)
{
double tmp = m.pm[i][k];
#include <stdio.h>
#include <stdlib.h>
typedef struct _matrix
{
int n;
double** pm;
} matrix;
matrix input(FILE* fp)
{
int i, j, n;
matrix m;
fscanf(fp, "%d", &n);
for (j=0; j<n; 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--)
{
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;
}
m = input(fp);
output(m);printf("\n");
output(rev(m));
printf("\n");
// output(Байду номын сангаас);
return 0;
}
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<n; j++)