C语言实现(不同阶数的)矩阵求逆（已用350个2-8阶的矩阵测试）

已于 2023-02-16 20:10:11 修改
阅读量913 收藏 10
点赞数
文章标签： c语言 矩阵 开发语言 线性代数 算法
于 2022-10-30 23:19:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46664080/article/details/127607066
版权

1、生成测试文件的代码

测试文件：

fp = fopen("Array_Test_Document.txt","r");

文件名为Array_Test_Document.txt  ，如果想要更换自己测试数据，仅需要在同一个目录下生成一个名为Array_Test_Document.txt 的文件，在文件中写入矩阵数据，每行为一个矩阵，每个元素之间用空格隔开。

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<math.h>

//该代码是创建了一个文件，文件的内容是2-8阶的可逆矩阵，每个阶数的矩阵各50个。
//文件的每一行都是一个矩阵，每个矩阵的元素之间用空格分开。


void Write_to_file(FILE *fp);
float HlsCalculate(float **x,const int row,const int column);
int main(){
	FILE *fp;
	int i,j,k;

	//设置随机数
	srand((unsigned)time(NULL));
	
	fp = fopen("Array_Test_Document.txt","w");
	if (fp != NULL){
		Write_to_file(fp);
    	}else{
		printf("文件打开失败：\n");
	}

    fclose(fp);
    return 0;
}



//求行列式
float HlsCalculate(float **x,const int row,const int column){
	float hls = 0;
	float **c;
	int i,j,k;


	//动态分配二维数组
	c = (float **)malloc(sizeof(float *) * row);
	//分配列数
	for(j = 0;j < row;j++){
		c[j] = (float *)malloc(sizeof(float) * column);
	}

	//1阶2阶行列式计算
	if(row == 1){
		return x[0][0];
	}
	if(row == 2){
		float z = x[0][0]*x[1][1] - x[0][1]*x[1][0];
		//printf("2dimention hls= %f\n",k);
		return z;
	}



	//3阶以上求行列式
	for(j = 0;j < row ;j++){
		for(i = 0 ; i < column - 1;i++){
			for(k = 0 ; k < row - 1;k++){
				if(k<j)c[i][k] = (float)x[i+1][k];
				if(k>=j)c[i][k] = (float)x[i+1][k+1];
			}
		}
		hls += pow(-1,j)*x[0][j]*HlsCalculate(c,row-1,column-1);
	}
	//printf("原矩阵的行列式 = %f\n",hls);
	return hls;
}


//将行列式不为0的矩阵写入文件
void Write_to_file(FILE *fp){


	int i,j,k;
	i = 0;
	
	//矩阵的阶数
	int matrix_size;

	//接受随机数值的临时变量
	int  a;

	//count 用于记录每个维度的矩阵写入文件的个数
	int count;
	count = 0;


	do{
		//int matrix_size;
		//设置生成矩阵的维度
		matrix_size = 2;
		matrix_size += count / 50;
		
		 if(matrix_size == 9){
			break;
		}
		

		//动态分配一个二维数组
		float **p1;
		//分配行数
	        p1 = (float **)malloc(sizeof(float *) * matrix_size);
		//分配列数
		for(j = 0;j < matrix_size;j++){
			p1[j] = (float *)malloc(sizeof(float) * matrix_size);
		}
			
		//给数组中放入随机值
		for(j = 0;j < matrix_size;j++){
			for(k = 0;k < matrix_size;k++){
				//rand()%10 是设置数组中元素的值为0-10之间
				a = rand()%10;
				p1[j][k] = a;
			}
		}


		//求矩阵的行列式，如果行列式的绝对值在1 - pow(10,matrix_size)之间则将该数据写入文件
		//determinant 用于接受矩阵的行列式值
		float determinant;
		determinant = HlsCalculate(p1,matrix_size,matrix_size);
		if((determinant >= -pow(10,matrix_size) && determinant <= -1) ||
			(determinant <= pow(10,matrix_size) && determinant >= 1)){
			count ++;
			for(j = 0;j < matrix_size;j++){
				for(k = 0 ; k < matrix_size;k++){
					fprintf(fp,"%.2f",p1[j][k]);
					fprintf(fp," ");
				}
			}
			fputc('\n',fp);
		}
		free(p1);

	// matrix_size < 9 是指写入的可逆矩阵维度在2-8之间
	}while(matrix_size  < 9);  
    	
	


}

2、部分测试文件截图

3、C代码实现矩阵求逆，用生成的测试文件测试代码

#include<stdio.h>
#include<math.h>
#include<stdlib.h>

void inverseArr(float **inverse,float **result,int N);
float HlsCalculate(float **x,const int row,const int column);

void mulMatrix(float **a,float **b,const int row);

int main(){

        
	int i,j,k,count;	

	//打开文件
	FILE *fp;
	fp = fopen("Array_Test_Document.txt","r");
	if(fp == NULL){
		printf("文件打开失败：");
		return -1;
	}

	count =0;
	while(++count <= 350){
	
		int row = 2 + (count-1)/50;
		int column = 2 + (count-1)/50;
		int i,j,k;


		//(0000000)动态分配一个二维数组,增广矩阵
		float **inverse;
        	//分配行
		inverse = (float **)malloc(sizeof(float *) * row); 
		//分配列数                 
		for(j = 0;j < row;j++){
	        	inverse[j] = (float *)malloc(sizeof(float)
			       	* column * 2);
		}
		

		//(1111111)动态分配一个二维数组,用于保存计算得到的逆矩阵
		float **ni_matrix;
        	//分配行
		ni_matrix = (float **)malloc(sizeof(float *) * row); 
		//分配列数                 
		for(j = 0;j < row;j++){ 
        		ni_matrix[j] = (float *)malloc(sizeof(float)* column );
		}


		//(2222222)动态分配一个二维数组,用于保存测试文件中的矩阵元素
		float **a;
        	//分配行
		a = (float **)malloc(sizeof(float *) * row); 
		//分配列数                 
		for(j = 0;j < row;j++){ 
        		a[j] = (float *)malloc(sizeof(float)* column );
		}


		//读取文件中的数据
		for(i = 0 ; i < row;i++){
			for(j = 0;j < column; j++){
				fscanf(fp,"%f",&a[i][j]);
			}
		}



		//打印原矩阵
		printf("第 %d 个矩阵\n",count);
		printf("==========原矩阵==========\n");
		for( i = 0; i < row ;i++){
			for(j = 0 ; j < column ; j++){
				printf("%6.2f ",a[i][j]);
			}
			printf("\n");
		}



		//求原矩阵的行列式,判断是否可逆
		//if行列式==0 则不可逆
		float  hls;
		hls = HlsCalculate(a,row,column);
		//printf("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&7&&&&行列式 = %.2f\n",hls);
		if(hls == 0){
			printf("该方阵的行列式==0，不可逆\n");
			continue;
		}


		//初始化增广矩阵
		//float inverse[N][2*N] = {0};
		for(i = 0 ; i < row;i++){
			for(j = 0 ; j < 2 * column;j++){
				if(i < row && j < row){
					inverse[i][j] = a[i][j];
				}else if(i + row== j){
					inverse[i][j] = 1.00;
				}else {
				
					inverse[i][j] = 0.00;
				}
			}
		}
	


		//求逆矩阵，并打印
		inverseArr(inverse,ni_matrix,row);

		//打印
		printf("==========逆矩阵==========\n");
		for( i = 0; i < row ;i++){
			for(j = 0 ; j < row ; j++){
				printf("%6.2f ",ni_matrix[i][j]);
			}
			printf("\n");
		}

		//原矩阵与逆矩阵的乘法运算,并输出结果矩阵
		mulMatrix(a,ni_matrix,row);

		free(a);
		free(inverse);
		free(ni_matrix);

		}
	
}


//矩阵乘法

void mulMatrix(float **a,float **b,const int row){
	int k ,i,j,p;
	k = row;
	int len = 0;

	//value1 用于保存矩阵的某一行和一列元素的相乘积的和
	float value1 = 0;

	//动态分配一个二维数组,用于保存矩阵乘法的结果
	float **c;
        //分配行
	c = (float **)malloc(sizeof(float *) * row); 
	//分配列数                 
	for(j = 0;j < row;j++){ 
        	c[j] = (float *)malloc(sizeof(float)* row );
		}
/*
	for(i = 0 ; i < k ;i++){
	
		for(j = 0 ;j < k ;j++){
		
			c[i][j] = 0;
		}
	}

	*/
	for( i = 0; i < k;i++){
		for( j = 0;j < k ;j++){
			for( p = 0 ; p < k;p++){
			value1 += a[i][p] * b[p][j];
			}
			c[i][len++] = value1;
			value1 = 0;
			if(len == k){
				len =0;
			} 
		}	
	}	

	//打印矩阵乘法的结果
	printf("====================原矩阵与逆矩阵的乘积================\n");
	for(int i = 0; i < k;i++){
		for(int j = 0;j < k ;j++){
			printf("%6.2f ",c[i][j]);
		} 
		printf("\n");
		
	}

	free(c);
}




//求行列式
float HlsCalculate(float **x,const int row,const int column){
	float hls = 0;

	int i ,j , k ;
	//动态分配一个二维数组
	float **c;
	c = (float **)malloc(sizeof(float *) * row); 
	for(j = 0;j < row;j++){
        	c[j] = (float *)malloc(sizeof(float)
			       	* column);
	}

	if(row == 1){
		return x[0][0];
	}
	if(row == 2){
		float k = x[0][0]*x[1][1] - x[0][1]*x[1][0];
		//printf("2dimention hls= %f\n",k);
		return k;
	}
	//求行列式
	for(j = 0;j < row ;j++){
		for(i = 0 ; i < column - 1;i++){
			for(k = 0 ; k < row - 1;k++){
				if(k<j)c[i][k] = x[i+1][k];
				if(k>=j)c[i][k] = x[i+1][k+1];
			}
		}
		hls += pow(-1,j)*x[0][j]*HlsCalculate(c,row-1,column-1);
	}
	//printf("原矩阵的行列式 = %f\n",hls);
	free(c);
	return hls;
}




//求逆
void inverseArr(float **inverse,float **result,int N){
	int i , j ,k;
	//float temp[2*N] ={0};
	for(i = 0 ;i < N ;i++){
		if(inverse[i][i] == 0){
			for(j = i + 1 ;j < N ;j++){
				if(inverse[j][i] != 0){
					break;
				}
			}
			for(k = 0; k < 2*N;k++){
				inverse[i][k] += inverse[j][k]; 
			}
		}
		float tmp = inverse[i][i];
		//
	       if(inverse[i][i] != 1){
	       		for(k = 0;k<2*N;k++){inverse[i][k] /= tmp;}
	       }
		//化为上三角矩阵
	       for(j=i+1;j<N;j++)
		{
			float tem_2 = inverse[j][i];
			for(k=i;k<2*N;k++)
			{
				inverse[j][k] = inverse[j][k] - tem_2 *
				       	inverse[i][k];
			}
		}
	}



	//将前部分矩阵化为E
	for(i = N-1 ; i >=0 ; i--){
		for(j = N - 1;j>i;j--){	
			if(inverse[i][j] == 0){continue;}
			float tmp = inverse[i][j];
			for(k = j;k< 2*N;k++){inverse[i][k] -= inverse[j][k]*tmp;}
		
		}
	}
	//保存在结果数组中
	for( i = 0; i < N ;i++){
		for(j = 0 ; j < N ; j++){
			result[i][j] = inverse[i][j+N];
		}
	}


}

4、代码环境Linux

5、部分实验结果截图

 

 gitee路径：

C语言: 0-1，C语言学习路程 - Gitee.com

平常心-辉
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于HLS的Cholesky分解矩阵求逆算法的设计_韩文俊.caj
12-10
论文，使用Xilinx HLS工具利用FPGA实现矩阵求逆算法，讲述了基于HLS的FPGA设计方法以及设计方案
矩阵违逆的求法
qq_29468403的博客
04-03 1062
① 直接求解： 求导，令导数为0，结果如下: InvA=(ATA)-1AT % 直接求伪逆 InvA = inv(A'*A)*A';   ② SVD求解 %% SVD分解求伪逆 % 原理和公式：1. SVD分解得到的矩阵:U和V是正交阵，S是对角阵 % 2. 正交阵的逆=转置 % 3. 对角阵的逆=非...
C#计算伪逆矩阵（PseudoInverse）
jemi_A的博客
07-20 811
我们用的是MathNet.Numerics命名空间里面的Matrix.PseudoInverse()方法计算伪逆，跟Python的numpy.linalg.pinv或者Matlab的pinv是一样的。 double[,] xEX = { { 1.0, 0,0 ,0,0,6.0}, { 0, -1,0 ,0,0,17.0}, { 0, 0,1 ,-6,17,0},
使用malloc函数分配空间
qq_46227775的博客
08-30 5613
1.使用malloc函数分配空间 malloc函数的原型是: void *malloc(unsigned int size); 函数的作用 : 在内存的动态储存区中分配一个长度为size的连续空间,并返回所分配第一个字节的地址. 看一下malloc的使用例子: float *f = (float *)malloc(4); char *c = (char *)malloc(1); 上面两个这种分配空间方式没有什么问题,分配长度为4的连续空间, 将函数原型的返回类型void *强制转换为float */c
求二阶逆矩阵
diji2219的博客
10-23 7551
给定的二阶矩阵(2*2)，求其逆矩阵。 输入 输入大小为2*2的距阵。 输出 输出一个大小为2*2的距阵，矩阵每一行相邻的的两个数字之间由一个空格隔开。具体的请详见 Sample Output 。 样例输入 2 0 1 1 样例输出 0.500000 0.000000 -0.500000 1.000000 #include<s...
C语言实现矩阵求逆
06-08
本人使用C语言编写使用初等行变换的方法，求出矩阵的逆矩阵。
c语言编程求矩阵的逆
07-15
c语言求矩阵的逆的代码，可以得到二维矩阵的逆矩阵
c语言实现矩阵求逆程序
04-21
c实现矩阵求逆程序。希望对大家有所帮助。
C语言矩阵求逆
qq_36691249的博客
03-16 8419
采用高斯消去法求逆 直接上代码 void Matrix_inverse(double arc[6][6], int n, double ans[6][6])//计算矩阵的逆 { int i, j, k;//列 double max, tempA, tempB, P; int max_num; double arcs[6][6]; memcpy(arcs, arc, 288); f...
c语言中的矩阵求逆程序,C语言矩阵求逆
weixin_28475533的博客
05-18 3523
根据代数里面的知识，可以使用伴随矩阵也可以使用初等行变换来解求解，但是这样如果矩阵的维数较大的时候，使用这种方法，矩阵的维数变大时，计算量急剧的变大，计算时间和使用内存也会按着指数急剧上升，这样的算法的生命力不行。使用以下这种算法的计算量和使用内存不会发生急剧的变化，特别是矩阵在维数大的时候。高斯-约旦法(全选主元)求逆的步骤如下：首先，对于 k 从 0 到 n - 1 作如下几步：从第 k 行、...
C语言计算逆矩阵的函数
10-27
函数入口: int inv(double *p,int n) 参数说明： double *p-----指向所求矩阵a[n][n]的第一行a[0],所以，当函数返回时，逆矩阵将存储在a[n][n]中，将覆盖原矩阵。一定要记得备份原矩阵。 int n---------矩阵维数
矩阵求逆算法c语言编程
03-04
因为矩阵AA-1=E，于是可以利用AX＝E来求A-1。 程序先初始化两个n维矩阵p[],q[],,p[]用来存放要求逆的矩阵，通过高斯列主元消元法变成上三角矩阵，q[]与p[]同时变换。通过追赶法解出每一行的解存放在q[]中
C语言矩阵求逆（源代码）
05-22
C语言中这样求其逆矩阵，矩阵求逆的源代码。非常实用。
C语言实现矩阵的乘加求逆运算
07-01
C语言求逆
矩阵运算C代码（含求逆）
03-31
C语言开发的单精度浮点的复数矩阵的基本运算，包括矩阵求逆（LU分解法和Gauss消去法两种），矩阵乘法、加法、协方差等。可通过C或C++直接调用。
juzhenqiuni.zip_C语言求逆_求逆矩阵C语言_矩阵求逆_逆矩阵
09-21
本程序运用C语言对任意阶数矩阵实现求逆运算，读者只需改动相应数，即可实现求逆！
C实现任意阶矩阵求逆矩阵
12-14
C语言实现任意阶数的矩阵求逆矩阵运算，将结果输出到控制台。 在该程序中，将参与运算的矩阵的阶数用变量n代替。对于不同阶数的矩阵的运算，修改该n变量即可。
用c语言实现任意阶数的矩阵转置的子函数
06-26
此程序用指针实现任意矩阵的转置的子函数，先动态的开辟一段内存空间用以存放转置后的矩阵
c语言求任意阶矩阵乘法
03-27
c语言求任意阶矩阵乘法，初学者或者学线性代数的可以用用。
用C语言编写一个矩阵求逆函数
最新发布
09-05
### 回答1： 矩阵求逆是一个非常常见的数学问题，可以使用C语言编写程序来解决。 以下是一个简单的矩阵求逆函数的代码实现，该实现使用了高斯-约旦消元法来计算矩阵的逆： ```c #include <stdio.h> #include <stdlib.h> #define N 3 int main() { double matrix[N][2*N]; double temp; int i, j, k; // 读取输入矩阵 printf("请输入一个 %d x %d 的矩阵：\n", N, N); for (i = 0; i < N; i++) { for (j = 0; j < N; j++) { scanf("%lf", &matrix[i][j]); } for (j = N; j < 2*N; j++) { if (i == j - N) { matrix[i][j] = 1.0; } else { matrix[i][j] = 0.0; } } } // 高斯-约旦消元 for (i = 0; i < N; i++) { temp = matrix[i][i]; for (j = i; j < 2*N; j++) { matrix[i][j] /= temp; } for (j = 0; j < N; j++) { if (i != j) { temp = matrix[j][i]; for (k = i; k < 2*N; k++) { matrix[j][k] -= temp * matrix[i][k]; } } } } // 输出矩阵逆 printf("该矩阵的逆为：\n"); for (i = 0; i < N; i++) { for (j = N; j < 2*N; j++) { printf("%lf ", matrix[i][j]); } printf("\n"); } return 0; } ``` 此程序使用了一个3x3的矩阵作为示例输入，可以根据需要更改矩阵的大小和输入方式。程序首先读取输入矩阵，然后使用高斯-约旦消元来计算矩阵的逆，并输出结果。 ### 回答2： 编写一个矩阵求逆的函数，需要先理解矩阵的求逆原理。矩阵求逆是指找到一个与原矩阵相乘得到单位矩阵的逆矩阵。以下是用C语言编写矩阵求逆的函数的示例： ```c #include <stdio.h> // 定义矩阵的维度 #define N 3 // 矩阵求逆函数的实现 void matrix_inverse(float A[N][N], float inv[N][N]) { // 计算矩阵的行列式 float det = A[0][0] * (A[1][1] * A[2][2] - A[1][2] * A[2][1]) - A[0][1] * (A[1][0] * A[2][2] - A[1][2] * A[2][0]) + A[0][2] * (A[1][0] * A[2][1] - A[1][1] * A[2][0]); // 检查矩阵是否可逆 if (det == 0) { printf("矩阵不可逆\n"); return; } // 计算伴随矩阵并求得逆矩阵 for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { inv[i][j] = (A[(j + 1) % N][(i + 1) % N] * A[(j + 2) % N][(i + 2) % N] - A[(j + 1) % N][(i + 2) % N] * A[(j + 2) % N][(i + 1) % N]) / det; } } } int main() { float A[N][N] = {{2, 1, 3}, {1, 2, 2}, {3, 1, 4}}; float inv[N][N]; matrix_inverse(A, inv); // 打印逆矩阵 printf("逆矩阵：\n"); for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { printf("%f ", inv[i][j]); } printf("\n"); } return 0; } ``` 运行以上代码，将输出矩阵A的逆矩阵。请注意，该实现假设矩阵A是一个3x3矩阵。对于不同维度的矩阵，需要相应调整代码中的 N 定义，并确保矩阵可逆。 ### 回答3： 要用C语言编写一个矩阵求逆函数，需要以下步骤： 1. 首先，定义一个二维数组来表示矩阵。可以使用二维数组来存储矩阵的元素。例如，可以使用`float`类型的二维数组来表示一个浮点数矩阵。 2. 编写一个函数来读取矩阵的元素。可以使用循环来依次读取矩阵的每个元素并将其存储在二维数组中。 3. 编写一个函数来计算矩阵的行列式。可以使用递归的方法来计算行列式的值。若矩阵的阶数为1，则行列式的值为矩阵中唯一的元素；若矩阵的阶数大于1，则可以选择一行或一列，计算每个元素对应的代数余子式，然后依次递归计算每个代数余子式的行列式并将其相加。 4. 编写一个函数来计算矩阵的伴随矩阵。伴随矩阵即将矩阵的每个元素转置后乘以其代数余子式并取负。可以使用循环依次计算每个元素的代数余子式并将其存储在新的二维数组中。 5. 编写一个函数来计算矩阵的逆矩阵。逆矩阵可以通过将伴随矩阵除以矩阵的行列式得到。可以使用循环依次计算每个元素的值并将其存储在新的二维数组中。 6. 最后，编写一个主函数来依次调用上述函数。在主函数中，先读取用户输入的矩阵，然后计算行列式并判断是否为0（若为0，则无逆矩阵），接着计算伴随矩阵和逆矩阵，并将结果输出。 这样就实现了一个用C语言编写的矩阵求逆函数。在实际应用中，可以根据需要对其进行调整和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值