复数矩阵乘法C语言实现

最新推荐文章于 2023-12-30 15:56:55 发布
最新推荐文章于 2023-12-30 15:56:55 发布
阅读量4.1k 收藏 6
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gtatcs/article/details/8887082
版权

下面代码参考TI的实现：

/* NAME                                                                    */
/*     DSPF_dp_mat_mul_cplx -- Complex matrix multiplication                    */
/*                                                                         */
/*  USAGE                                                                   */
/*                                                                          */
/*       This routine has the following C prototype:                        */
/*                                                                          */
/*       void DSPF_dp_mat_mul_cplx(                                              */
/*                              const double* x,                            */
/*                              int r1,                                     */
/*                              int c1,                                     */
/*                              const double* y,                            */
/*                              int c2,                                     */
/*                              double* restrict r                          */
/*                           )                                              */
/*                                                                          */
/*            x[2*r1*c1]:   Input matrix containing r1*c1 complex           */
/*                          floating point numbers having r1 rows and c1    */
/*                          columns of complex numbers.                     */
/*            r1        :   No. of rows in matrix x.                        */
/*            c1        :   No. of columns in matrix x.                     */
/*                          Also no. of rows in matrix y.                   */
/*            y[2*c1*c2]:   Input matrix containing c1*c2 complex           */
/*                          floating point numbers having c1 rows and c2    */
/*                          columns of complex numbers.                     */
/*            c2        :   No. of columns in matrix y.                     */
/*            r[2*r1*c2]:   Output matrix of c1*c2 complex floating         */
/*                          point numbers having c1 rows and c2 columns of  */
/*                          complex numbers.                                */
/*                                                                          */
/*                          Complex numbers are stored consecutively with   */
/*                          real values stored in even positions and        */
/*                          imaginary values in odd positions.              */
/*                                                                          */
/*  DESCRIPTION                                                             */
/*                                                                          */
/*        This function computes the expression "r = x * y" for the         */
/*        matrices x and y. The columnar dimension of x must match the row  */
/*        dimension of y. The resulting matrix has the same number of rows  */
/*        as x and the same number of columns as y.                         */
/*                                                                          */
/*        Each element of the matrix is assumed to be complex numbers with  */
/*        Real values are stored in even positions and imaginary            */
/*        values in odd positions.                                          */
/*                                                                          */
/*  TECHNIQUES                                                              */
/*                                                                          */
/*        1. Innermost loop is unrolled twice.                              */
/*        2. Outermost loop is executed in parallel with innner loops.      */
/*                                                                          */
/*  ASSUMPTIONS                                                             */
/*                                                                          */
/*        1. r1,r2>=1,c1 should be a multiple of 2 and >=2.                 */
/*        2. x should be padded with 6 words                                */
/*                                                                          */
/*                                                                          */
/*  C CODE                                                                  */
/*                                                                          */
void DSPF_dp_mat_mul_cplx(const double* x, int r1, int c1, 
						  const double* y, int c2, double* r)
{                                                                 
	double real, imag;                                            
	int i, j, k;                                                  
													  
	for(i = 0; i < r1; i++)                                      
	{                                                             
		for(j = 0; j < c2; j++)                                     
		{                                                           
			real=0;                                                   
			imag=0;                                                   
															   
			for(k = 0; k < c1; k++)                                   
			{                                                         
				real += (x[i*2*c1 + 2*k]*y[k*2*c2 + 2*j]                  
				-x[i*2*c1 + 2*k + 1] * y[k*2*c2 + 2*j + 1]);              
																   
				imag+=(x[i*2*c1 + 2*k] * y[k*2*c2 + 2*j + 1]             
				+ x[i*2*c1 + 2*k + 1] * y[k*2*c2 + 2*j]);              
			}                                                         
			r[i*2*c2 + 2*j] = real;                                  
			r[i*2*c2 + 2*j + 1] = imag;  
		}
	}
}  
/*  NOTES                                                                   */
/*                                                                          */
/*        1. Real values are stored in even word positions and imaginary    */
/*           values in odd positions.                                       */
/*        2. Endian: This code is LITTLE ENDIAN.                            */
/*        3. Interruptibility: This code is interrupt tolerant but not      */
/*           interruptible.                                                 */
/*                                                                          */
/*  CYCLES                                                                  */
/*                                                                          */
/*        8*r1*c1*c2'+ 18*(r1*c2)+40 WHERE c2'=2*ceil(c2/2)                 */
/*        When r1=3, c1=4, c2=4, cycles = 640                               */
/*        When r1=4, c1=4, c2=5, cycles = 1040                              */
/*                                                                          */
/*  CODESIZE                                                                */
/*                                                                          */
/*        832 bytes                                                         */
/* ------------------------------------------------------------------------ */
/*            Copyright (c) 2004 Texas Instruments, Incorporated.           */
/*                           All Rights Reserved.                           */
/* ======================================================================== */
#ifndef DSPF_DP_MAT_MUL_CPLX_H_
#define DSPF_DP_MAT_MUL_CPLX_H_ 1

void DSPF_dp_mat_mul_cplx(
                       const double* x,
                       int r1,
                       int c1,
                       const double* y,
                       int c2,
                       double* restrict r
                    );

#endif
/* ======================================================================== */
/*  End of file:  DSPF_dp_mat_mul_cplx.h                                         */
/* ------------------------------------------------------------------------ */


测试程序如下：
（说明：下面代码分别包含了三个矩阵相乘的函数）
#include <stdio.h>
#include <stdlib.h>
#include "complex.h"

void matrix_mul(
					 const double* x,
					 int r1,
					 int c1,
					 const double* y,
					 int c2,
					 double* r
                    )
{
	int i,j,k;
	for(i=0;i<r1;++i)
	{
		for(j=0;j<c2;++j)
		{
			for(k=0;k<c1;++k)
			{
				//r[i*r1 + j] =r[i*r1 + j] + x[i*r1 + k] * y[k*c1 + j];
				r[i*c2 + j] =r[i*c2 + j] + x[i*c1 + k] * y[k*c2 + j];
			}
		}
	}
}

void matrix_mul_cplx(
				const Complex* x,
				int r1,
				int c1,
				const Complex* y,
				int c2,
				Complex* r
				)
{
	int i,j,k;
	Complex temp;
	temp.real = 0;
	temp.image = 0;
	for(i=0;i<r1;++i)
	{
		for(j=0;j<c2;++j)
		{
			for(k=0;k<c1;++k)
			{
				//r[i*r1 + j] =r[i*r1 + j] + x[i*r1 + k] * y[k*c1 + j];
				temp = complex_mul(x[i*c1 + k], y[k*c2 + j]);
				r[i*c2 + j] =complex_add(r[i*c2 + j], temp);
			}
		}
	}
}

void DSPF_dp_mat_mul_cplx(const double* x, int r1, int c1, 
						  const double* y, int c2, double* r)
{                                                                 
	double real, imag;                                            
	int i, j, k;                                                  
													  
	for(i = 0; i < r1; i++)                                      
	{                                                             
		for(j = 0; j < c2; j++)                                     
		{                                                           
			real=0;                                                   
			imag=0;                                                   
															   
			for(k = 0; k < c1; k++)                                   
			{                                                         
				real += (x[i*2*c1 + 2*k]*y[k*2*c2 + 2*j]                  
				-x[i*2*c1 + 2*k + 1] * y[k*2*c2 + 2*j + 1]);              
																   
				imag+=(x[i*2*c1 + 2*k] * y[k*2*c2 + 2*j + 1]             
				+ x[i*2*c1 + 2*k + 1] * y[k*2*c2 + 2*j]);              
			}                                                         
			r[i*2*c2 + 2*j] = real;                                  
			r[i*2*c2 + 2*j + 1] = imag;  
		}
	}
}     
		
int main()
{
	//matrix_mul test
	/*
	double x[9] = {1,2,3,4,5,6,7,8,9};	//矩阵按行存放
	int r1 = 3, c1 = 3,c2 = 1;
	double y[3] = {10,11,12};
	double r[3] = {0};
	int i,j;
	//printf("r  :  %lf\n%lf\n",r[0],r[1]);

	printf("r = : \n");
	for(i=0;i<r1;++i)
	{
		for(j=0;j<c2;++j)
		{
			//printf("%lf\t",r[i*r1 + j]);
			printf("%lf\t",r[i*c2 + j]);
		}
		printf("\n");
	}

	matrix_mul(x,r1,c1,y,c2,r);
	printf("x*y = : \n");
	for(i=0;i<r1;++i)
	{
		for(j=0;j<c2;++j)
		{
			printf("%lf\t",r[i*c2 + j]);
		}
		printf("\n");
	}
*/
	/*
	//matrix_mul_cplx test
	Complex x[4] = {{1,2}, {3,4}, {5,6}, {7,8}};	//矩阵按行存放
	int r1 = 2, c1 = 2,c2 = 1;
	Complex y[2] = {{1,2}, {3,4}};
	Complex r[2] = {{0,0}, {0,0}};
	int i,j;
	//printf("r  :  %lf\n%lf\n",r[0],r[1]);
	
	printf("r = : \n");
	for(i=0;i<r1;++i)
	{
		for(j=0;j<c2;++j)
		{
			printf("%lf + j*%lf\t",r[i*c2 + j].real , r[i*c2 + j].image);
		}
		printf("\n");
	}
	
	matrix_mul_cplx(x,r1,c1,y,c2,r);
	printf("x*y = : \n");
	for(i=0;i<r1;++i)
	{
		for(j=0;j<c2;++j)
		{
			printf("%lf + j*%lf\t",r[i*c2 + j].real , r[i*c2 + j].image);
		}
		printf("\n");
	}
	*/
	//DSPF_dp_mat_mul_cplx test
	Complex x[4] = {{1,2}, {3,4}, {5,6}, {7,8}};	//矩阵按行存放
	int r1 = 2, c1 = 2,c2 = 1;
	Complex y[2] = {{1,2}, {3,4}};
	Complex r[2] = {{0,0}, {0,0}};
	int i,j;
	//printf("r  :  %lf\n%lf\n",r[0],r[1]);
	
	printf("r = : \n");
	for(i=0;i<r1;++i)
	{
		for(j=0;j<c2;++j)
		{
			printf("%lf + j*%lf\t",r[i*c2 + j].real , r[i*c2 + j].image);
		}
		printf("\n");
	}
	
	DSPF_dp_mat_mul_cplx((double*)x, r1,c1, (double*)y, c2,  (double*)r);

	printf("x*y = : \n");
	for(i=0;i<r1;++i)
	{
		for(j=0;j<c2;++j)
		{
			printf("%lf + j*%lf\t",r[i*c2 + j].real , r[i*c2 + j].image);
		}
		printf("\n");
	}

	return 0;
}


























                

        

        

    




    

      

        

            

              
                
                  gtatcs
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    6
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
使用C语言实现复数矩阵的求逆的源代码

				
			

			

				

					05-20
				

			

		

		

			
				
使用 C 语言实现复数矩阵的求逆，可以运行，使用 VS2012 软件编写。

			
		

	



                

              
                



	

		

			

				
					
如何在C++中实现复数矩阵运算

				
			

			

				

					qq_45518377的博客
				

				

					10-12
					
					1365
					
				

			

		

		

			
				
C++实现复数矩阵

			
		

	



                


  
              

                


	

		

			

				
					
【复数矩阵相乘】

				
			

			

				

					qq_45449625的博客
				

				

					09-13
					
					990
					
				

			

		

		

			
				
【代码】【复数矩阵相乘】

			
		

	





	

		

			

				
					
C语言实现任意复数矩阵相乘

				
			

			

				

					苟
				

				

					03-18
					
					2259
					
				

			

		

		

			
				
这里借鉴了TI官方的dsp函数库中的矩阵处理函数


void mat_mul_cplx(const float *x1, int r1, int c1, const float *x2,
	int c2, float *y)
{
	float real, imag;
	int i, j, k;

	for (i = 0; i < r1; i++)
	for (j = 0; j < c...

			
		

	



		

			
		



	

		

			

				
					
实现复数矩阵的加减乘除

				
			

			

				

					sky_48的博客
				

				

					07-15
					
					2070
					
				

			

		

		

			
				
被应付的作业们实现复数矩阵的加减乘除大一非计算机类程序设计作业
实现复数矩阵的加减乘除
大一非计算机类程序设计作业
要求：
（1）使用+与-号实现两个复数矩阵的加减法；
（2）使用*实现两个复数矩阵的乘法；
（3）使用！实现复数矩阵的共轭转置操作；
（4）使用<<与>>实现复数矩阵的输出与输入；
（5）要求兼容实数矩阵运算
其实：；兼容矩阵运算也可以使用转换构造函数，但是我...

			
		

	





	

		

			

				
					
OpenCV：复数矩阵相乘

				
			

			

				

					weixin_43865692的博客
				

				

					07-27
					
					2208
					
				

			

		

		

			
				
本文章基于：Allen101zhang的CSDN博客https://blog.csdn.net/Allen101zhang/article/details/88918952



在VS2017中，利用Mat矩阵实现复数矩阵相乘。

在此，Mat矩阵为双通道浮点数据(CV_32FC2)，通道1存放复数的实部，通道2存放复数的虚部。



复数点乘原理：a=x1+y1i,b=x2+y2;a*b=（x1*x2-y1*y2）+(x1*y2+x2*y1)i


//对复数矩阵进行分离为实数矩阵和虚数矩阵
void.

			
		

	





	

		

			

				
					
C语言：计算两个复数的乘积

				
			

			

				

					夏的博客
				

				

					04-12
					
					1万+
					
				

			

		

		

			
				
复数结构定义如下：


struct Complex
{
	float real;
	float image;
};


计算复数函数原型为：struct Complex complex_prod(struct Complex c1, struct Complex c2)

在主函数中输入两个复数，利用该函数，计算两个复数的乘积；

代码如下：


void chapter1::testCompl...

			
		

	





	

		

			

				
					
 几个常用的矩阵运算--相乘、相加、共轭、转置等c的源代码

				
			

			

				

					09-19
				

			

		

		

			
				
常用的矩阵运算，复数矩阵的乘法、相加、共轭等，去掉复数的修饰‘’_Complex‘’，即为实数的相关运算

			
		

	





	

		

			

				
					
你必须知道的495个C语言问题

				
			

			

				

					05-08
				

			

		

		

			
				
2.4　在C语言中用什么方法实现抽象数据类型最好?  *2.5　在C语言中是否有模拟继承等面向对象程序设计特性的好方法？  2.6　为什么声明externf(structx*p);给我报了一个晦涩难懂的警告信息？  2.7　我遇到这样声明...

			
		

	





	

		

			

				
					
复数矩阵求逆c/c++实现

				
			

			

				

					06-03
				

			

		

		

			
				
支持任意阶的复数矩阵求逆，a是复数矩阵的实属部分，b是虚数部分，c、d分别是输出实属和虚数部分

			
		

	





	

		

			

				
					
ComplexMatrixMathLab(C++复数矩阵数学库，含源代码和DLL)

				
			

			

				

					11-17
				

			

		

		

			
				
采用C++开发的复矩阵数学库，含复数类CMyComplex、矩阵类CMatrix、修正贝塞尔函数类等，可进行各种复数和复矩阵运算，具体包括：实矩阵求逆的全选主元高斯－约当法、复矩阵求逆的全选主元高斯－约当法、对称正定矩阵的求逆、托伯利兹矩阵求逆的埃兰特方法、求行列式值的全选主元高斯消去法
求矩阵秩的全选主元高斯消去法、对称正定矩阵的乔里斯基分解与行列式的求值、矩阵的三角分解 、一般实矩阵的QR分解、一般实矩阵的奇异值分解 、求广义逆的奇异值分解法、约化对称矩阵为对称三对角阵的豪斯荷尔德变换法、实对称三对角阵的全部特征值与特征向量的计算、约化一般实矩阵为赫申伯格矩阵的初等相似变换法、求赫申伯格矩阵全部特征值的QR方法、求实对称矩阵特征值与特征向量的雅可比法、求实对称矩阵特征值与特征向量的雅可比过关法等，内容十分丰富完善。

			
		

	





	

		

			

				
					
累积 2x2 复数矩阵乘法：这需要一个 2x2xm 矩阵并计算沿第 3 个维度的累积矩阵乘法。-matlab开发

				
			

			

				

					06-01
				

			

		

		

			
				
此函数计算输入复矩阵 A(2,2,m) 的累积矩阵乘法此函数应使用 Maltab Mex 函数进行编译。 米 = 1000; % 矩阵数A = rand(2,2,m) + 1i * rand(2,2,m); % 示例矩阵； B = cM(A); % B 是一个 2x2 矩阵
此函数比等效的 for 循环快 180 倍。
 B = 眼睛（2）； 对于 ii = 1 : 1000 B = B * A(:,:,ii); 结尾

			
		

	





	

		

			

				
					
浙江大学C语言上机练习题附答案

				
			

			

				

					10-02
				

			

		

		

			
				
浙江大学C语言上机练习题&答案 第2周（M2） 2 20011求华氏温度100°F对应的摄氏温度。 2 20012 求华氏温度 150°F 对应的摄氏温度。 3 20013求摄氏温度26°C对应的华氏温度。 3 20015当n为152时，分别求出n的个位...

			
		

	





	

		

			

				
					
116.复矩阵乘法

				
			

			

				

					C语言与CPP编程的博客
				

				

					05-04
					
					1565
					
				

			

		

		

			
				
#include "stdio.h"
#define MAX 255

void CMatrixMul(ar,ai,br,bi,m,n,k,cr,ci) /*复矩阵相乘*/
int m,n,k; /*m是矩阵A的行数，n是矩阵B的行数，k是矩阵B的列数*/
/*ar,br,cr分别是矩阵A,B,C的实部，ai,bi,ci分别是矩阵A,B, C的虚部*/
double ar[],ai[],br[],bi[],cr[],ci[];
{
	int i,j,l,u,v,w;
    	double p,q,s;
.

			
		

	





	

		

			

				
					
复数的加减乘除C语言实现

					
热门推荐

				
			

			

				

					zf111212的博客
				

				

					10-23
					
					1万+
					
				

			

		

		

			
				
思路：
1复数的表示：用结构体实现
2复数的加减法：实部虚部分别相加减
复数的乘法：（a+bi)(c+di)=ac-bd+(ad+cb)i
复数的除法：(a+bi)(c+di)=(ac+bd)(cc+dd)+(bc-ad)(cc+d*d)
考虑分母为0的情况
3用switch语句由用户自己选择要进行的操作
4用do…while循环实现多次运算
代码实现
#include<stdio.h>
#include<math.h>
//用结构体表示复数
typedef struct
{
   

			
		

	





	

		

			

				
					
C语言实现复数之积

					
最新发布

				
			

			

				

					qq_53049142的博客
				

				

					12-30
					
					524
					
				

			

		

		

			
				
根据上述公式，我们可以使用结构体和函数来进行计算。在C语言中，我们首先定义了一个表示复数的结构体。函数中，我们首先读取用户输入的两个复数的实部和虚部。函数中，我们按照公式计算两个复数的乘积。，其中包含实部和虚部。然后，我们定义了一个函数。结构体的实部和虚部，并将结果返回给调用函数。函数计算它们的乘积，并将结果打印出来。类型的参数，并返回它们的乘积。然后，我们将这两部分分别赋给。

			
		

	





	

		

			

				
					
C语言实现实数和复数矩阵及其各种运算（一）

				
			

			

				

					学术垃圾制造者的博客
				

				

					08-15
					
					4916
					
				

			

		

		

			
				
一、前言
   最近在企业实习，花了三个星期的时间肝了一个室内定位算法（雏形，还未优化），实现matlab和C的联写、联调，其难点我认为在于矩阵的各种运算，C++中有Eigen库可用，以前在学slam和做课题时候在Ubuntu下用过一段时间的Eigen，功能强大，提供了各种典型的matrix计算接口，但是在C中，需要我们自己编写每个功能模块。算法核心代码matlab只有大概100行，但是C我写了大概有1500多行。谨以此连载文档记录一下算法开发的关键--复数矩阵运算。
   网上关于C语言实现矩阵运算的de

			
		

	





	

		

			

				
					
vivado HLS复数矩阵乘法

				
			

			

				

					09-18
				

			

		

		

			
				
复数矩阵乘法在Vivado HLS中可以通过以下步骤实现：

1. 定义数据类型：首先，你需要定义一个复数数据类型来表示矩阵中的元素。例如，你可以使用C++中的std::complex数据类型或自定义的复数结构。

2. 设计顶层函数：创建一个顶层函数来执行复数矩阵乘法。该函数将接受两个复数矩阵作为输入，并返回一个结果矩阵。你可以在函数内部使用循环和复数乘法运算来实现矩阵乘法。

3. 指定优化指令：通过使用pragma指令来指定优化选项，以实现高性能的硬件加速。例如，你可以使用array_partition指令将矩阵分区到不同的存储区域，以使并行计算更加高效。

4. 进行综合和实现：使用Vivado HLS工具对设计进行综合和实现。这将生成一个RTL（Register-Transfer Level）设计，可以在FPGA上实现。

下面是一个简单的示例代码片段，展示了使用Vivado HLS进行复数矩阵乘法的实现：

```
#include <complex>

typedef std::complex<float> ComplexType;

void matrix_multiply(ComplexType A[N][N], ComplexType B[N][N], ComplexType C[N][N]) {
  #pragma HLS array_partition variable=A,B,C dim=1 complete
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < N; j++) {
      ComplexType sum = 0;
      for (int k = 0; k < N; k++) {
        sum += A[i][k] * B[k][j];
      }
      C[i][j] = sum;
    }
  }
}
```

请注意，这只是一个简化的示例，你可以根据你的具体需求进行更改和扩展。



			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值