复数矩阵求逆的 C 语言程序

最新推荐文章于 2024-03-12 15:11:21 发布
最新推荐文章于 2024-03-12 15:11:21 发布
阅读量7.1k 收藏 44
点赞数 8
文章标签： 复数矩阵求逆 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangxunweihua/article/details/90369914
版权

关于复数矩阵求逆，如果使用 MATLAB，就非常简单。我们先用一个 MATLAB 的例子来说明，等会要将 C 语言的程序和 MATLAB 的程序进行对比。

close all;
clear all;
clc;

%定义矩阵a为复数矩阵
a = [[4+2*i,3+1*i,4+3*i,5+5*i];
    [1+7*i,8+2*i,2+2*i,9+3*i];
    [4+4*i,5+6*i,1+7*i,7+2*i];
    [6+1*i,7+8*i,1+4*i,2+5*i]];

a_real = real(a); %求矩阵实部
a_imag = imag(a); %求矩阵虚部
a_inv = inv(a);   %求矩阵的逆

可以看到 a_inv 是这样的：
MATLAB求解a_inv
下面列出 C 语言的矩阵求逆的代码。由于VS2012中不能使用 complex.h，我们在这里将复数矩阵的实部和虚部分开定义，数值和上面定义的 a 一样。

a_real[0][0] = 4; a_real[0][1] = 3; a_real[0][2] = 4; a_real[0][3] = 5;
a_real[1][0] = 1; a_real[1][1] = 8; a_real[1][2] = 2; a_real[1][3] = 9;
a_real[2][0] = 4; a_real[2][1] = 5; a_real[2][2] = 1; a_real[2][3] = 7;
a_real[3][0] = 6; a_real[3][1] = 7; a_real[3][2] = 1; a_real[3][3] = 2;

a_imag[0][0] = 2; a_imag[0][1] = 1; a_imag[0][2] = 3; a_imag[0][3] = 5;
a_imag[1][0] = 7; a_imag[1][1] = 2; a_imag[1][2] = 2; a_imag[1][3] = 3;
a_imag[2][0] = 4; a_imag[2][1] = 6; a_imag[2][2] = 7; a_imag[2][3] = 2;
a_imag[3][0] = 1; a_imag[3][1] = 8; a_imag[3][2] = 4; a_imag[3][3] = 5;

完整代码及其注释如下：

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

#define N 4
#define DEBUG 1         //debug label，0即不打印相关结果，非0打印相关输出结果

//计算实数矩阵的逆
void matrix_inverse_LU(double a[][N],double a_inverse[N][N])
{
    double  l[N][N], u[N][N];
    double  l_inverse[N][N], u_inverse[N][N];
    //double  a_inverse[N][N];
    int i, j, k;
    double  s, t;

    memset(l, 0, sizeof(l));
    memset(u, 0, sizeof(u));
    memset(l_inverse, 0, sizeof(l_inverse));
    memset(u_inverse, 0, sizeof(u_inverse));
    memset(a_inverse, 0, sizeof(u_inverse));


    for (i = 0; i < N;i++)       //计算l矩阵对角线
    {
        l[i][i] = 1;
    }

    for (i = 0;i < N;i++)
    {
        for (j = i;j < N;j++)
        {
            s = 0;
            for (k = 0;k < i;k++)
            {
                s += l[i][k] * u[k][j];
            }
            u[i][j] = a[i][j] - s;      //按行计算u值
        }

        for (j = i + 1;j < N;j++)
        {
            s = 0;
            for (k = 0; k < i; k++)
            {
                s += l[j][k] * u[k][i];
            }
            l[j][i] = (a[j][i] - s) / u[i][i];      //按列计算l值
        }
    }

    for (i = 0;i < N;i++)        //按行序，行内从高到低，计算l的逆矩阵
    {
        l_inverse[i][i] = 1;
    }
    for (i= 1;i < N;i++)
    {
        for (j = 0;j < i;j++)
        {
            s = 0;
            for (k = 0;k < i;k++)
            {
                s += l[i][k] * l_inverse[k][j];
            }
            l_inverse[i][j] = -s;
        }
    }


#if DEBUG
    printf("test l_inverse:\n");
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
            s = 0;
            for (k = 0; k < N; k++)
            {
                s += l[i][k] * l_inverse[k][j];
            }

            printf("%f ", s);
        }
        putchar('\n');
    }
#endif


    for (i = 0;i < N;i++)                    //按列序，列内按照从下到上，计算u的逆矩阵
    {
        u_inverse[i][i] = 1 / u[i][i];
    }
    for (i = 1;i < N;i++)
    {
        for (j = i - 1;j >=0;j--)
        {
            s = 0;
            for (k = j + 1;k <= i;k++)
            {
                s += u[j][k] * u_inverse[k][i];
            }
            u_inverse[j][i] = -s / u[j][j];
        }
    }


#if DEBUG
    printf("test u_inverse:\n");
    for (i = 0;i < N;i++)
    {
        for (j = 0;j < N;j++)
        {
            s = 0;
            for (k = 0;k < N;k++)
            {
                s += u[i][k] * u_inverse[k][j];
            }

            printf("%f ",s);
        }
        putchar('\n');
    }
#endif

    for (i = 0;i < N;i++)            //计算矩阵a的逆矩阵
    {
        for (j = 0;j < N;j++)
        {
            for (k = 0;k < N;k++)
            {
                a_inverse[i][j] += u_inverse[i][k] * l_inverse[k][j];
            }
        }
    }

#if DEBUG
    printf("test a:\n");
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
            s = 0;
            for (k = 0; k < N; k++)
            {
                s += a[i][k] * a_inverse[k][j];
            }

            printf("%f ", s);
        }
        putchar('\n');
    }
#endif
}

//矩阵乘法，由于这里计算的是长度N的方阵，所以实际上ROW,MID,COL的值都是N
void MulMatrix(const double (*arr1)[N], const double (*arr2)[N], int ROW, int MID, int COL, double (*arr3)[N])
{
	double sum=0.0;
	int i,j,m;
    for (i = 0; i<ROW; i++)
	{
		for (j = 0; j<COL; j++)
		{
			sum = 0.0;
			for (m = 0; m<MID; m++)
			{
				sum = sum + arr1[i][m] * arr2[m][j];
			}
			arr3[i][j] = sum;
		}
	}
}

//矩阵加法
void PlusMatrix(const double (*arr1)[N], const double (*arr2)[N], int ROW, int COL, double (*arr3)[N])
{
	int i,j;
    for(i=0;i<N;i++)//控制行
    {
        for(j=0;j<N;j++)
        {
            arr3[i][j]=arr1[i][j]+arr2[i][j];
        }
    }
}

//矩阵减法
void MinusMatrix(const double (*arr1)[N], const double (*arr2)[N], int ROW, int COL, double (*arr3)[N]) 
{
	int i,j;
    for(i=0;i<N;i++)//控制行
    {
        for(j=0;j<N;j++)
        {
            arr3[i][j]=arr1[i][j]-arr2[i][j];
        }
    }
}

void main()
{
    int i, j, k;
    double a[N][N]; //N表示矩阵维度，为4
    double a_real[N][N];
    double a_imag[N][N];
	double Ainv[N][N],Binv[N][N],BAinv[N][N],BAinvB[N][N],A_P_BAinvB[N][N],A_P_BAinvB_inv[N][N],AinvB[N][N],AinvB_A_P_BAinvB[N][N],AinvB_A_P_BAinvB_inv[N][N];

	//将a矩阵的实部和虚部分开定义
	a_real[0][0] = 4;a_real[0][1] = 3;a_real[0][2] = 4;a_real[0][3] = 5;
    a_real[1][0] = 1;a_real[1][1] = 8;a_real[1][2] = 2;a_real[1][3] = 9;
	a_real[2][0] = 4;a_real[2][1] = 5;a_real[2][2] = 1;a_real[2][3] = 7;
    a_real[3][0] = 6;a_real[3][1] = 7;a_real[3][2] = 1;a_real[3][3] = 2;

	a_imag[0][0] = 2;a_imag[0][1] = 1;a_imag[0][2] = 3;a_imag[0][3] = 5;
    a_imag[1][0] = 7;a_imag[1][1] = 2;a_imag[1][2] = 2;a_imag[1][3] = 3;
    a_imag[2][0] = 4;a_imag[2][1] = 6;a_imag[2][2] = 7;a_imag[2][3] = 2;
    a_imag[3][0] = 1;a_imag[3][1] = 8;a_imag[3][2] = 4;a_imag[3][3] = 5;

	//这些计算公式来源于这里：https://wenku.baidu.com/view/2de4c1bc284ac850ad024244.html
    matrix_inverse_LU(a_real,Ainv);
    matrix_inverse_LU(a_imag,Binv);
    MulMatrix(a_imag,Ainv,N,N,N,BAinv);
    MulMatrix(BAinv,a_imag,N,N,N,BAinvB);
    PlusMatrix(a_real,BAinvB,N,N,A_P_BAinvB);
    matrix_inverse_LU(A_P_BAinvB,A_P_BAinvB_inv);
    MulMatrix(Ainv,a_imag,N,N,N,AinvB);
    MulMatrix(AinvB,A_P_BAinvB_inv,N,N,N,AinvB_A_P_BAinvB_inv);

	//最后一步要把AinvB_A_P_BAinvB_inv每个数都求相反数，也是上面链接的文献里说的
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
             AinvB_A_P_BAinvB_inv[i][j] = -AinvB_A_P_BAinvB_inv[i][j];
        }
    }

	//输出a的逆矩阵的实部矩阵
    printf("test a_inv_real:\n");
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
             printf("%f ", A_P_BAinvB_inv[i][j]);
        }
        printf("\n");
    }

	//输出a的逆矩阵的虚部矩阵
	printf("test a_inv_imag:\n");
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < N; j++)
        {
             printf("%f ", AinvB_A_P_BAinvB_inv[i][j]);
        }
        printf("\n");
    }

	//使得窗口不要关闭
	getchar();
}

最后输出结果如下：
C语言输出结果
通过对比，可以发现该结果中的实部和虚部与 MATLAB 输出的结果是一致的。这证明我们的程序是正确的。

时人莫之许也
关注
  • 8
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
复数矩阵求逆
07-11
使用C代码编写的复数矩阵求逆的Ｃ代码。已经和matlab结果做出对比，无误
27. 复数矩阵，快速傅里叶转换
最新发布
scar2016的博客
05-22 994
当矩阵A为实对称矩阵的时候，其特征值为实数，当特征值为复数的时候，其特征向量也就变成了复数向量，组成复数矩阵。傅里叶矩阵是目前最重要的复矩阵。也有关于傅里叶矩阵的快速傅里叶变换。通常对于一个n行n列的两个方阵来说，我们要进行两个方阵的相乘，按照常规思路来说需要进行。我们只是进行了简单的矩阵变换，但是对于矩阵乘法来说，大大降低了运算次数，大大提高了运算速度。次运算，但是我们经过快速傅里叶变换后，我们再重新相乘两个矩阵,其乘法运算需要。
复数矩阵求逆c/c++实现
06-03
支持任意阶的复数矩阵求逆，a是复数矩阵的实属部分，b是虚数部分，c、d分别是输出实属和虚数部分
复数矩阵求逆的C语言程序
m0_37043496的博客
10-16 1063
https://blog.csdn.net/wangxunweihua/article/details/90369914
C语言十进制、复数、矩阵计算器实现
12-09
在C语言中实现一个功能丰富的计算器，包括十进制、复数和矩阵的运算，是一项具有挑战性的任务，它涉及到基础的数据类型、算术运算符、控制结构以及自定义数据结构的设计。以下是对这个项目的一些关键知识点的详细...
test_矩阵计算小程序_
10-03
如果A是m×n矩阵，B是n×p矩阵，则它们可以相乘得到一个m×p的矩阵C。每个元素C[i][j]的值由A的第i行与B的第j列对应元素的乘积之和构成。 3. **转置**：将矩阵的行变成列，列变成行，得到一个新的矩阵，即矩阵的...
复数矩阵 解方程组 C++源代码
10-16
标题 "复数矩阵 解方程组 C++源代码" 描述了这个项目是用C++编程语言实现的一个功能，用于解决复数矩阵的线性方程组问题。在这个项目中，用户可以输入一个复数矩阵A和一个复数向量B，程序将计算出满足AX=B的解X。...
矩阵运算库自实现(c语言)
10-07
C语言是一种底层、高效且广泛使用的编程语言，适用于实现这样的库。本篇将详细讲解如何使用C语言自实现一个矩阵运算库。 一、基础知识 1. 矩阵：矩阵是由按顺序排列的复数或实数构成的矩形阵列。在数学中，矩阵...
矩阵运算C语言实现
04-15
在本主题“矩阵运算C语言实现”中，我们将深入探讨如何使用C语言来执行基本的矩阵运算，包括加法、减法、乘法、求逆以及转置。这些操作在图像处理、科学计算、机器学习等多个领域都有广泛应用。 首先，我们要理解...
使用C语言实现复数矩阵的求逆的源代码
05-20
使用 C 语言实现复数矩阵的求逆，可以运行，使用 VS2012 软件编写。
复数矩阵求逆运算
10-12
复数矩阵求逆运算C++代码，可以准确的求其结果！
复数逆矩阵
06-29
复数逆矩阵的求法，适合FPGA算法，将复数矩阵分成实部矩阵和虚部矩阵分开处理！效率很高
c语言编程求矩阵的逆
07-15
c语言求矩阵的逆的代码，可以得到二维矩阵的逆矩阵
用初等变换求复数矩阵的逆矩阵
05-22
复数矩阵求逆，用了STL中的vector表示矩阵，用了complex类表示复数，求逆矩阵使用了初等变换求逆矩阵的方法
C语言实现复数矩阵基本操作+LU分解求逆
qq_43756950的博客
03-13 3732
C语言实现（复数）矩阵运算 代码并不是很严谨，没有考虑内存释放之类的问题，初次尝试还有待完善，希望能够帮助到有需要的同学。 1.首先创建复数类型结构体 typedef struct { float real; float imag; }Complex_F; 结构体Complex_F中定义了复数的实部与虚部，这里我使用Complex_F *A或者Complex_F A[row*col]来表示一个矩阵，由于是行排列，所以没有使用二维数组，只需知道A[i][j]=A[i*col+j]即可。 下面
C++实现复数矩阵求逆 matlab inv
srg1011的博客
07-06 7237
C++实现复数矩阵求逆 matlab inv一、引言二、原理2.1 实数矩阵求逆2.2 复数矩阵求逆三、代码四、测试 一、引言 之前偶尔一次有用到将matlab转为C++语言的需求，其中matlab有一个inv函数可以非常方便的求矩阵的逆，甚至是复数矩阵。而C++中没有类似的函数。在csdn上有一个matlab2c的库的博客（github地址第80行开始），但是只有实数矩阵求逆的代码，而我又在百度上搜到一篇文献中写到将复数矩阵转为两个实数矩阵然后在进行求解。然后我就将两个代码一结合，就实现了复数矩阵求逆。经
verilog实现四阶复数矩阵求逆
Karoski的博客
03-12 1128
国科大高等数字集成电路大作业，利用Verilog实现四阶复数矩阵求逆，采用分块矩阵法对四阶常数矩阵求逆，再利用公式完成对复数矩阵的求逆，里面包括二阶矩阵求逆，求积，三级矩阵求行列式，四阶矩阵求积，求逆，求行列式和四阶复矩阵求逆的代码。代码附在txt文档中，请自行复制到程序中
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值