复数矩阵乘法C语言实现

最新推荐文章于 2022-03-13 22:58:23 发布
最新推荐文章于 2022-03-13 22:58:23 发布
阅读量2.4k 收藏 1
点赞数 1
分类专栏： C

来至http://blog.csdn.net/gtatcs/article/details/8887082；

下面代码参考TI的实现：

[cpp]  view plain copy
  1. <span style="font-size:14px;">/* NAME                                                                    */  
  2. /*     DSPF_dp_mat_mul_cplx -- Complex matrix multiplication                    */  
  3. /*                                                                         */  
  4. /*  USAGE                                                                   */  
  5. /*                                                                          */  
  6. /*       This routine has the following C prototype:                        */  
  7. /*                                                                          */  
  8. /*       void DSPF_dp_mat_mul_cplx(                                              */  
  9. /*                              const double* x,                            */  
  10. /*                              int r1,                                     */  
  11. /*                              int c1,                                     */  
  12. /*                              const double* y,                            */  
  13. /*                              int c2,                                     */  
  14. /*                              double* restrict r                          */  
  15. /*                           )                                              */  
  16. /*                                                                          */  
  17. /*            x[2*r1*c1]:   Input matrix containing r1*c1 complex           */  
  18. /*                          floating point numbers having r1 rows and c1    */  
  19. /*                          columns of complex numbers.                     */  
  20. /*            r1        :   No. of rows in matrix x.                        */  
  21. /*            c1        :   No. of columns in matrix x.                     */  
  22. /*                          Also no. of rows in matrix y.                   */  
  23. /*            y[2*c1*c2]:   Input matrix containing c1*c2 complex           */  
  24. /*                          floating point numbers having c1 rows and c2    */  
  25. /*                          columns of complex numbers.                     */  
  26. /*            c2        :   No. of columns in matrix y.                     */  
  27. /*            r[2*r1*c2]:   Output matrix of c1*c2 complex floating         */  
  28. /*                          point numbers having c1 rows and c2 columns of  */  
  29. /*                          complex numbers.                                */  
  30. /*                                                                          */  
  31. /*                          Complex numbers are stored consecutively with   */  
  32. /*                          real values stored in even positions and        */  
  33. /*                          imaginary values in odd positions.              */  
  34. /*                                                                          */  
  35. /*  DESCRIPTION                                                             */  
  36. /*                                                                          */  
  37. /*        This function computes the expression "r = x * y" for the         */  
  38. /*        matrices x and y. The columnar dimension of x must match the row  */  
  39. /*        dimension of y. The resulting matrix has the same number of rows  */  
  40. /*        as x and the same number of columns as y.                         */  
  41. /*                                                                          */  
  42. /*        Each element of the matrix is assumed to be complex numbers with  */  
  43. /*        Real values are stored in even positions and imaginary            */  
  44. /*        values in odd positions.                                          */  
  45. /*                                                                          */  
  46. /*  TECHNIQUES                                                              */  
  47. /*                                                                          */  
  48. /*        1. Innermost loop is unrolled twice.                              */  
  49. /*        2. Outermost loop is executed in parallel with innner loops.      */  
  50. /*                                                                          */  
  51. /*  ASSUMPTIONS                                                             */  
  52. /*                                                                          */  
  53. /*        1. r1,r2>=1,c1 should be a multiple of 2 and >=2.                 */  
  54. /*        2. x should be padded with 6 words                                */  
  55. /*                                                                          */  
  56. /*                                                                          */  
  57. /*  C CODE                                                                  */  
  58. /*                                                                          */  
  59. void DSPF_dp_mat_mul_cplx(const double* x, int r1, int c1,   
  60.                           const double* y, int c2, double* r)  
  61. {                                                                   
  62.     double real, imag;                                              
  63.     int i, j, k;                                                    
  64.                                                         
  65.     for(i = 0; i < r1; i++)                                        
  66.     {                                                               
  67.         for(j = 0; j < c2; j++)                                       
  68.         {                                                             
  69.             real=0;                                                     
  70.             imag=0;                                                     
  71.                                                                  
  72.             for(k = 0; k < c1; k++)                                     
  73.             {                                                           
  74.                 real += (x[i*2*c1 + 2*k]*y[k*2*c2 + 2*j]                    
  75.                 -x[i*2*c1 + 2*k + 1] * y[k*2*c2 + 2*j + 1]);                
  76.                                                                      
  77.                 imag+=(x[i*2*c1 + 2*k] * y[k*2*c2 + 2*j + 1]               
  78.                 + x[i*2*c1 + 2*k + 1] * y[k*2*c2 + 2*j]);                
  79.             }                                                           
  80.             r[i*2*c2 + 2*j] = real;                                    
  81.             r[i*2*c2 + 2*j + 1] = imag;    
  82.         }  
  83.     }  
  84. }    
  85. /*  NOTES                                                                   */  
  86. /*                                                                          */  
  87. /*        1. Real values are stored in even word positions and imaginary    */  
  88. /*           values in odd positions.                                       */  
  89. /*        2. Endian: This code is LITTLE ENDIAN.                            */  
  90. /*        3. Interruptibility: This code is interrupt tolerant but not      */  
  91. /*           interruptible.                                                 */  
  92. /*                                                                          */  
  93. /*  CYCLES                                                                  */  
  94. /*                                                                          */  
  95. /*        8*r1*c1*c2'+ 18*(r1*c2)+40 WHERE c2'=2*ceil(c2/2)                 */  
  96. /*        When r1=3, c1=4, c2=4, cycles = 640                               */  
  97. /*        When r1=4, c1=4, c2=5, cycles = 1040                              */  
  98. /*                                                                          */  
  99. /*  CODESIZE                                                                */  
  100. /*                                                                          */  
  101. /*        832 bytes                                                         */  
  102. /* ------------------------------------------------------------------------ */  
  103. /*            Copyright (c) 2004 Texas Instruments, Incorporated.           */  
  104. /*                           All Rights Reserved.                           */  
  105. /* ======================================================================== */  
  106. #ifndef DSPF_DP_MAT_MUL_CPLX_H_  
  107. #define DSPF_DP_MAT_MUL_CPLX_H_ 1  
  108.   
  109. void DSPF_dp_mat_mul_cplx(  
  110.                        const double* x,  
  111.                        int r1,  
  112.                        int c1,  
  113.                        const double* y,  
  114.                        int c2,  
  115.                        double* restrict r  
  116.                     );  
  117.   
  118. #endif  
  119. /* ======================================================================== */  
  120. /*  End of file:  DSPF_dp_mat_mul_cplx.h                                         */  
  121. /* ------------------------------------------------------------------------ */</span>  
[cpp]  view plain copy
  1. <span style="font-size:14px;">  
  2. </span>  
[cpp]  view plain copy
  1. <span style="font-size:14px;">测试程序如下：</span>  
[cpp]  view plain copy
  1. <span style="font-size:14px;">（说明：下面代码分别包含了三个矩阵相乘的函数）</span>  
[cpp]  view plain copy
  1. <pre name="code" class="cpp"><span style="font-size:14px;">#include <stdio.h></span></pre><pre name="code" class="cpp"><span style="font-size:14px;">#include <stdlib.h>  
  2. #include "complex.h"  
  3.   
  4. void matrix_mul(  
  5.                      const double* x,  
  6.                      int r1,  
  7.                      int c1,  
  8.                      const double* y,  
  9.                      int c2,  
  10.                      double* r  
  11.                     )  
  12. {  
  13.     int i,j,k;  
  14.     for(i=0;i<r1;++i)  
  15.     {  
  16.         for(j=0;j<c2;++j)  
  17.         {  
  18.             for(k=0;k<c1;++k)  
  19.             {  
  20.                 //r[i*r1 + j] =r[i*r1 + j] + x[i*r1 + k] * y[k*c1 + j];  
  21.                 r[i*c2 + j] =r[i*c2 + j] + x[i*c1 + k] * y[k*c2 + j];  
  22.             }  
  23.         }  
  24.     }  
  25. }  
  26.   
  27. void matrix_mul_cplx(  
  28.                 const Complex* x,  
  29.                 int r1,  
  30.                 int c1,  
  31.                 const Complex* y,  
  32.                 int c2,  
  33.                 Complex* r  
  34.                 )  
  35. {  
  36.     int i,j,k;  
  37.     Complex temp;  
  38.     temp.real = 0;  
  39.     temp.image = 0;  
  40.     for(i=0;i<r1;++i)  
  41.     {  
  42.         for(j=0;j<c2;++j)  
  43.         {  
  44.             for(k=0;k<c1;++k)  
  45.             {  
  46.                 //r[i*r1 + j] =r[i*r1 + j] + x[i*r1 + k] * y[k*c1 + j];  
  47.                 temp = complex_mul(x[i*c1 + k], y[k*c2 + j]);  
  48.                 r[i*c2 + j] =complex_add(r[i*c2 + j], temp);  
  49.             }  
  50.         }  
  51.     }  
  52. }  
  53.   
  54. void DSPF_dp_mat_mul_cplx(const double* x, int r1, int c1,   
  55.                           const double* y, int c2, double* r)  
  56. {                                                                   
  57.     double real, imag;                                              
  58.     int i, j, k;                                                    
  59.                                                         
  60.     for(i = 0; i < r1; i++)                                        
  61.     {                                                               
  62.         for(j = 0; j < c2; j++)                                       
  63.         {                                                             
  64.             real=0;                                                     
  65.             imag=0;                                                     
  66.                                                                  
  67.             for(k = 0; k < c1; k++)                                     
  68.             {                                                           
  69.                 real += (x[i*2*c1 + 2*k]*y[k*2*c2 + 2*j]                    
  70.                 -x[i*2*c1 + 2*k + 1] * y[k*2*c2 + 2*j + 1]);                
  71.                                                                      
  72.                 imag+=(x[i*2*c1 + 2*k] * y[k*2*c2 + 2*j + 1]               
  73.                 + x[i*2*c1 + 2*k + 1] * y[k*2*c2 + 2*j]);                
  74.             }                                                           
  75.             r[i*2*c2 + 2*j] = real;                                    
  76.             r[i*2*c2 + 2*j + 1] = imag;    
  77.         }  
  78.     }  
  79. }       
  80.           
  81. int main()  
  82. {  
  83.     //matrix_mul test  
  84.     /* 
  85.     double x[9] = {1,2,3,4,5,6,7,8,9};  //矩阵按行存放 
  86.     int r1 = 3, c1 = 3,c2 = 1; 
  87.     double y[3] = {10,11,12}; 
  88.     double r[3] = {0}; 
  89.     int i,j; 
  90.     //printf("r  :  %lf\n%lf\n",r[0],r[1]); 
  91.  
  92.     printf("r = : \n"); 
  93.     for(i=0;i<r1;++i) 
  94.     { 
  95.         for(j=0;j<c2;++j) 
  96.         { 
  97.             //printf("%lf\t",r[i*r1 + j]); 
  98.             printf("%lf\t",r[i*c2 + j]); 
  99.         } 
  100.         printf("\n"); 
  101.     } 
  102.  
  103.     matrix_mul(x,r1,c1,y,c2,r); 
  104.     printf("x*y = : \n"); 
  105.     for(i=0;i<r1;++i) 
  106.     { 
  107.         for(j=0;j<c2;++j) 
  108.         { 
  109.             printf("%lf\t",r[i*c2 + j]); 
  110.         } 
  111.         printf("\n"); 
  112.     } 
  113. */  
  114.     /* 
  115.     //matrix_mul_cplx test 
  116.     Complex x[4] = {{1,2}, {3,4}, {5,6}, {7,8}};    //矩阵按行存放 
  117.     int r1 = 2, c1 = 2,c2 = 1; 
  118.     Complex y[2] = {{1,2}, {3,4}}; 
  119.     Complex r[2] = {{0,0}, {0,0}}; 
  120.     int i,j; 
  121.     //printf("r  :  %lf\n%lf\n",r[0],r[1]); 
  122.      
  123.     printf("r = : \n"); 
  124.     for(i=0;i<r1;++i) 
  125.     { 
  126.         for(j=0;j<c2;++j) 
  127.         { 
  128.             printf("%lf + j*%lf\t",r[i*c2 + j].real , r[i*c2 + j].image); 
  129.         } 
  130.         printf("\n"); 
  131.     } 
  132.      
  133.     matrix_mul_cplx(x,r1,c1,y,c2,r); 
  134.     printf("x*y = : \n"); 
  135.     for(i=0;i<r1;++i) 
  136.     { 
  137.         for(j=0;j<c2;++j) 
  138.         { 
  139.             printf("%lf + j*%lf\t",r[i*c2 + j].real , r[i*c2 + j].image); 
  140.         } 
  141.         printf("\n"); 
  142.     } 
  143.     */  
  144.     //DSPF_dp_mat_mul_cplx test  
  145.     Complex x[4] = {{1,2}, {3,4}, {5,6}, {7,8}};    //矩阵按行存放  
  146.     int r1 = 2, c1 = 2,c2 = 1;  
  147.     Complex y[2] = {{1,2}, {3,4}};  
  148.     Complex r[2] = {{0,0}, {0,0}};  
  149.     int i,j;  
  150.     //printf("r  :  %lf\n%lf\n",r[0],r[1]);  
  151.       
  152.     printf("r = : \n");  
  153.     for(i=0;i<r1;++i)  
  154.     {  
  155.         for(j=0;j<c2;++j)  
  156.         {  
  157.             printf("%lf + j*%lf\t",r[i*c2 + j].real , r[i*c2 + j].image);  
  158.         }  
  159.         printf("\n");  
  160.     }  
  161.       
  162.     DSPF_dp_mat_mul_cplx((double*)x, r1,c1, (double*)y, c2,  (double*)r);  
  163.   
  164.     printf("x*y = : \n");  
  165.     for(i=0;i<r1;++i)  
  166.     {  
  167.         for(j=0;j<c2;++j)  
  168.         {  
  169.             printf("%lf + j*%lf\t",r[i*c2 + j].real , r[i*c2 + j].image);  
  170.         }  
  171.         printf("\n");  
  172.     }  
  173.   
  174.     return 0;  
  175. }  
  176. </span></pre><pre name="code" class="cpp"></pre><span style="font-size:14px"><br>  
  177. </span><p></p>  
  178. <pre></pre>  
  179. <span style="font-size:14px"><br>  
  180. </span>  
  181. <p></p>  
  182. <p><span style="font-size:14px"><br>  
  183. </span></p>  
  184. <p><br>  
  185. </p>  
yangyme
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现实数和复数矩阵及其各种运算（三）
学术垃圾制造者的博客
08-16 3132
一、前言 本章开始，开始详细讲解实数和复数矩阵的转置、复制、行列式、代数余子式、逆等运算，并给出函数和测试demo的C代码，以及与matlab计算的结果； 并且，本章出现了我在编写函数、后期与matlab联调跑数据时候出现的几个坑，读者稍微留意一下。 二、复制运算 复制运算，即对矩阵进行复制操作，将一个已知的矩阵原样赋值给另一个矩阵，且原矩阵内容不变： /* Copy: Complex matrixA = Complex matrixB */ void CopyMatrix..
C语言实现实数和复数矩阵及其各种运算（五）
学术垃圾制造者的博客
08-17 3311
一、前言 本章开始，笔者将详细讲解矩阵的QR分解、特征值、特征向量等运算，并给出函数和测试demo的C代码，以及与matlab计算的结果； 并且，本章相当于前面几章的大杂烩，前面所有的结构体、宏定义、函数本章基本全部都有用到。 另，这将也是我此连载文章的系列精品之一，矩阵运算的功能越来越复杂，但是笔者全部分模块进行，化繁为简，化整为零，所以需要调用的小函数越来越多，读者遇到不熟悉的函数可以随时Jump到（一）、（二）、（三）、（四）的内容。 （PS：另外这两个编辑器为啥功能不能优势互补，而且都没有贴matl
c语言程序改错有几个错,Ｃ语言程序（两复数矩阵相乘）改错求助
weixin_42151305的博客
05-23 101
Ｃ语言程序(两复数矩阵相乘)改错求助哪位高手帮我修改一下下面这段程序的错误，我看了实在是改不出．急用．．．先谢谢了！double bucmul(double ar,double ai,double br,double bi,int m,int n,int k,double cr,double ci){int i,j,l,u,v,w;double p,q,s;for(i=0;i<=m-1;i+...
C语言程序实现矩阵相乘
qq_41649694的博客
08-05 3万+
  矩阵相乘需要注意： 当矩阵A的列数等于矩阵B的行数时，A与B可以相乘 矩阵C的行数等于矩阵A的行数，C的列数等于B的列数 乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应元素乘积之和 代码实现： #include &lt;stdio.h&gt; #define M 3 #define N 3 #define K 3 int main() { int A[M]...
complex--创建复数
qq_18343569的博客
12-28 1521
【功能简介】用实部和虚部创建复数。 【语法格式】 1．c=complex(a,b) 用两个实数a和b创建复数c，c=a+bi。c与a、b是同型的数组或矩阵。如果b是全零的，c也依然是一个复数，例如，c=complex(1,0)返回复数1，isreal(c)等于false，而1+0i则返回实数1。 2．c=complex(a) 输入参数a作为复数c的实部，c的虚部为零，
C语言数据结构算法之实现快速傅立叶变换
08-30
三、C语言实现快速傅立叶变换 在C语言中，快速傅立叶变换可以使用递归函数或迭代函数来实现。下面是一个使用递归函数实现快速傅立叶变换的示例代码： ```c void fft(int l, int k) { int i, j; struct COMPLEX *w...
c语言程序设计讲义（前期汇总）
11-23
5. **复数**：虽然C语言标准库没有内置复数类型，但可以通过结构体自定义复数并实现相关运算。 6. **对数**：对数在科学计算中常见，理解自然对数和常用对数的概念及其应用。 7. **数论**：探讨了素数、整除性、模...
几个常用的矩阵运算--相乘、相加、共轭、转置等c的源代码
09-19
常用的矩阵运算，复数矩阵的乘法、相加、共轭等，去掉复数的修饰‘’_Complex‘’，即为实数的相关运算
你必须知道的495个C语言问题
05-08
2.4　在C语言中用什么方法实现抽象数据类型最好? *2.5　在C语言中是否有模拟继承等面向对象程序设计特性的好方法？ 2.6　为什么声明externf(structx*p);给我报了一个晦涩难懂的警告信息？ 2.7　我遇到这样声明...
c语言算法c语言 算法
08-05
这本书详细介绍了166个C语言实现的算法，涉及了从基础数学运算到复杂的数据处理等多个领域，旨在帮助读者理解和应用这些算法。 在介绍C语言算法之前，书中首先简要回顾了程序设计语言的发展，特别是C语言的优势和...
使用C语言实现复数矩阵的求逆的源代码
05-20
使用 C 语言实现复数矩阵的求逆，可以运行，使用 VS2012 软件编写。
复数矩阵求逆c/c++实现
06-03
支持任意阶的复数矩阵求逆，a是复数矩阵的实属部分，b是虚数部分，c、d分别是输出实属和虚数部分
复数矩阵求逆的C语言程序
m0_37043496的博客
10-16 1054
https://blog.csdn.net/wangxunweihua/article/details/90369914
复数的乘积c语言,复数矩阵乘法C语言实现
weixin_39540704的博客
05-17 196
下面代码参考TI的实现：/* NAME *//* DSPF_dp_mat_mul_cplx -- Complex matrix multiplication *//* ...
C语言实现复数矩阵基本操作+LU分解求逆
qq_43756950的博客
03-13 3646
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语言 n*n矩阵求值及求逆矩阵
热门推荐
hpuzsk的博客
06-15 3万+
求出矩阵的值以及输出逆矩阵，英语不好，略拗口。 上代码： #include #include #include int map1[110][110],i,j,k,l,m,n,p,vis[110][110],num; int just[110][110]; int just2[110][110]; void print(int map[][110],int n)//打印矩阵 { int j;
vivado HLS复数矩阵乘法
最新发布
09-18
你可以在函数内部使用循环和复数乘法运算来实现矩阵乘法。 3. 指定优化指令：通过使用pragma指令来指定优化选项，以实现高性能的硬件加速。例如，你可以使用array_partition指令将矩阵分区到不同的存储区域，以使...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值