m文件转换c代码

parametet.m
clc;
clear;

load('src.mat')
CZT_N = ;
CZT_M = ;
CZT_W = exp(-j*(*pi/));
CZT_A = exp(j**pi/);

该文件罗列了用到的参数的取值情况，src.mat文件是matlab保存下来的原始数据，数据情况：2048*1个数据，每个数据都是科学计数法表示的。

load命令，可以将文件中的数据加载到项目中，以便后续使用（如何使用，还依赖一个模块化仿真图）。

czt_w/A都是指数形式的复数：在c++语言中复数运算库——<complex>中定义了复数的运算，其中包括复数的指数运算——pow(a,b)=a^b和exp(a)=e^a。

c++中定义复数的形式：complex <double> var_name(real_port,imag_port);

这类似于在定义一个复数变量时调用了一个给实部和虚部赋值的函数，其实在c++中复数是一个类的定义，定义复数就是定义对象，给复数赋值也就只能是初始化方式赋值了——调用构造函数赋值，第二种赋值方式就是对象赋值。（目前了解的。。。。）

定义复数类的形式（形似）

class complex

{

　　public:

　　double real_port;

　　double imag_port;

};

例如：

complex <double> abc(1.2,3.12);

那么：

abc=(1.2,3.12)

real(abc)=1.2; imag(abc)=3.12

complex <double> bbb; bbb=abc; -->bbb=(1.2,3.12)

有了这点理解，所以：

parameter.h就好写了

 #include <complex>
 #include <vector>
 #include <iostream>

 using namespace std;

 double pi = 3.14159265359;

 int czt_n = ;
 int czt_m = ;
 complex <double> czt_w_1(,-*pi/);
 complex <double> czt_w = exp(czt_w_1);
 complex <double> czt_a_1(,pi/);
 complex <double> czt_a = exp(czt_a_1);

CZT.m:
function y=CZT(u,CZT_N,CZT_M,CZT_W,CZT_A)

L = CZT_M + CZT_N ; %L=
g = zeros(L,); %g为L行1列的全0矩阵

for i=:CZT_N- %矩阵g元素赋值
    g(i+,) = CZT_A^(-i)*CZT_W^(i^/)*u(i+,);
end
G=fft(g);

h = zeros(L,);
for i=:CZT_M-
    h(i+,)=CZT_W^(-i^/);
end
for i=L-CZT_N+:L-
   h(i+,)=CZT_W^(-(L-i)^/);
end
H=fft(h);

Q=H.*G;

q=ifft(Q);

X=zeros(CZT_M,);
for i=:CZT_M-
   X(i+,)=CZT_W^(i^/)*q(i+);
end

y=X;

czt.m文件定义了一个函数——czt。（文件名与函数名相同）

function是matlab中定义函数的关键字，y表示返回值，u,CZT_N,CZT_M,CZT_W,CZT_A，表示参数，那个这个函数的理解就是用：u,CZT_N,CZT_M,CZT_W,CZT_A这些参数经过一系列步骤得到输出y的过程，这些步骤就是函数体，其中u表示什么呢？，它就是一个矩阵，元素为src.mat文件中的数据，因此u是一个2048*1的矩阵（矩阵可以用数组在c语言环境下代替）。

统领全篇：用到的计算方法有：fft、ifft、矩阵的点乘、复数的指数运算。

L = CZT_M + CZT_N ; %L=
g = zeros(L,); %g为L行1列的全0矩阵

for i=:CZT_N- %矩阵g元素赋值
    g(i+,) = CZT_A^(-i)*CZT_W^(i^/)*u(i+,);
end
G=fft(g);

在写这部分代码时，首先要做的几个准备工作：

1、g矩阵是一个4096*1的矩阵，可以用一维数组代替，数组的元素性质是复数。

2、u矩阵的元素在这之前还是以文件的形式存储的，要读到u变量中去（src_real.txt只记录了实部，src_imag.txt只记录了虚部）

3、g = zeros(L,1)表示的是变量初始化过程，因此数组还得初始化。

4、值得注意的是这里的G由于要在下面参与运算，所以不能是函数的局部变量，还能提取fft函数，使其能在后续计算中能被访问。

 // test_9.cpp : 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include <vector>
 #include <complex>
 #include <iostream>
 #include "parameter.h"
 #include "fftw3.h"
 #include <stdlib.h>
 #include <malloc.h>

 complex <double> u[];

 /***********读原始数据到矩阵（数组u）***************/
 void src_txt_u()
 {
         int i=;
         double u_real=;
         double u_imag=;

         FILE *fp_1,*fp_2;
         fp_1=fopen("real_src.txt","r");
         if(fp_1==NULL)
             cout<<"fopen_error"<<endl;
         fp_2=fopen("imag_src.txt","r");
         if(fp_2==NULL)
             cout<<"fopen_error"<<endl;

         for(i=;i<;i++)
         {
             fscanf(fp_1,"%lf",&u_real);
             fscanf(fp_2,"%lf",&u_imag);
             complex <double> u_mid(u_real,u_imag);
             u[i]=u_mid;
         }
         fclose(fp_1);
         fclose(fp_2);
 }

从文件中读数据到变量中时，采用的函数是——fscanf()。

由于复数在定义和赋值这两个操作是同时完成的，不能分开执行，所以这里定义了一个中间变量——u_mid由它来将最终复数赋值给相应的变量——数组的元素。

 /**************计算G=fft(g)**************/
 complex <double>* fft_g()
 {
     //得到矩阵g
     complex <double> *g;
     int L=czt_n+czt_m;
     g = (complex <double> *)malloc(sizeof(complex <double>)*L);
     for(int i=;i<czt_n;i++)
         g[i]=pow(czt_a,-i)*pow(czt_w,i*i/)*u[i];
     for(int i=czt_n;i<L;i++)
         g[i]=;

     //fft计算
     fftw_complex *in_put,*out_put;
     complex <double> *G_mid;
     G_mid = (complex <double> *)malloc(sizeof(complex <double>)*L);
     fftw_plan p_1;
     int N =L;
     in_put=(fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
     out_put=(fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
     for( int i=; i < N; i++)
     {
         in_put[i][] = real(g[i]);
         in_put[i][] = imag(g[i]);
         //printf("%lf+%lfj\n",in_put[i][0],in_put[i][1]);
     }
     p_1=fftw_plan_dft_1d(N,in_put,out_put, FFTW_FORWARD, FFTW_ESTIMATE);
     fftw_execute(p_1);
     for(int j = ;j < N;j++)
     {
         complex <double> var_mid(out_put[j][],out_put[j][]);
         G_mid[j]=var_mid;
     }
     fftw_destroy_plan(p_1);
     fftw_free(in_put);
     fftw_free(out_put);

     return G_mid;
 }

注意点：

1、在定义g数组时，不能使用：complex <double> g[L]这种形式，因为L是一个变量，那么数组的静态定义方式是行不通的。在动态定义中，一定要分配足够的空间，这里的g数组表示的是4096*1的矩阵空间，那么就需要malloc(sizeof(complex <double>)*L个空间。如果只是定义了一个复数的空间（complex <double> *g），那么只能存储第一个元素位置的数，其他的元素不能使用了。

2、fftw_complex类型和compelx <double>类型的数据不能强制转换，也不能隐式转换，但是可以使用实部和虚部分开来赋值：　　

　　for( int i=0; i < N; i++)
　　{
　　　　in_put[i][0] = real(g[i]);
　　　　in_put[i][1] = imag(g[i]);
　　}

　　for(int j = 0;j < N;j++)

　　{

　　　　complex <double> var_mid(out_put[j][0],out_put[j][1]);
　　　　G_mid[j]=var_mid;
　　}

　

h = zeros(L,); %*
for i=:CZT_M-
    h(i+,)=CZT_W^(-i^/);
end
for i=L-CZT_N+:L-
   h(i+,)=CZT_W^(-(L-i)^/);
end
H=fft(h);

注意matlab中矩阵下标是从1开始的，而在c语言中选择从0开始，要注意对应点。

从上式可以看出，h[1]——h[2048]被赋值CZT_W^(-i^2/2)，h[2050]——h[4095]被赋值为CZT_W^(-(L-i)^2/2)。h[2049]=0；

 /**************计算H=fft(h)*********************/
 complex <double>* fft_h()
 {
     int i=;
     //得到矩阵h
     complex <double> *h;
     int L=czt_n+czt_m;
     h = (complex <double> *)malloc(sizeof(complex <double>)*L);

     //给矩阵h赋值
     for(i=;i<czt_m;i++)
         h[i] = pow(czt_w,-(i*i)/);
     h[]=;
     for(i=czt_m+;i<L;i++)
         h[i]=pow(czt_w,(-(L-i)*(L-i)/));

     //fft计算
     fftw_complex *in_put,*out_put;
     complex <double> *H_mid;
     H_mid = (complex <double> *)malloc(sizeof(complex <double>)*L);
     fftw_plan p_1;
     int N =L;
     in_put=(fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
     out_put=(fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
     for( int i=; i < L; i++)
     {
         in_put[i][] = real(h[i]);
         in_put[i][] = imag(h[i]);
         //printf("%lf+%lfj\n",in_put[i][0],in_put[i][1]);
     }
     p_1=fftw_plan_dft_1d(N,in_put,out_put, FFTW_FORWARD, FFTW_ESTIMATE);
     fftw_execute(p_1);
     for(int j = ;j < N;j++)
     {
         complex <double> var_mid(out_put[j][],out_put[j][]);
         H_mid[j]=var_mid;
     }
     fftw_destroy_plan(p_1);
     fftw_free(in_put);
     fftw_free(out_put);
      return H_mid;

 }

Q=H.*G;

q=ifft(Q);

 /************计算q=ifft(Q)********************/
 complex <double> *ifft_Q()
 {
     //得到矩阵Q
     complex <double> *H=fft_h(); //调用函数得到H矩阵
     complex <double> *G=fft_g();  //调用函数得到G矩阵
     int L=czt_n+czt_m;
     complex <double> *Q;
     Q = (complex <double> *)malloc(sizeof(complex <double>)*L);
     for(int i=;i<L;i++)
     {
         Q[i]=H[i]*G[i];
     }

     //ifft计算
     fftw_complex *in_put,*out_put;
     complex <double> *q_mid;
     q_mid = (complex <double> *)malloc(sizeof(complex <double>)*L);
     fftw_plan p_1;
     int N =L;
     in_put=(fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
     out_put=(fftw_complex*) fftw_malloc(sizeof(fftw_complex) * N);
     for( int i=; i < L; i++)
     {
         in_put[i][] = real(Q[i]);
         in_put[i][] = imag(Q[i]);
         //printf("%lf+%lfj\n",in_put[i][0],in_put[i][1]);
     }
     p_1=fftw_plan_dft_1d(N,in_put,out_put, FFTW_BACKWARD, FFTW_ESTIMATE);
     fftw_execute(p_1);
     for(int j = ;j < N;j++)
     {
         complex <double> var_mid(out_put[j][]/N,out_put[j][]/N);
         q_mid[j]=var_mid;
     }
     fftw_destroy_plan(p_1);
     fftw_free(in_put);
     fftw_free(out_put);
     return q_mid;
 }

值得注意的是：

　　p_1=fftw_plan_dft_1d(N,in_put,out_put, FFTW_BACKWARD, FFTW_ESTIMATE); FFTW_BACKWARD表示进行ifft变换，但是计算的结果没有除以点数N，所以　　结果是实际ifft变换的N倍，要得到实际的ifft结果还得除以N。

　　所以：

　　for(int j = 0;j < N;j++)

　　{
　　　　complex <double> var_mid(out_put[j][0]/N,out_put[j][1]/N);
　　　　q_mid[j]=var_mid;
　　}

X=zeros(CZT_M,);
for i=:CZT_M-
   X(i+,)=CZT_W^(i^/)*q(i+);
end

y=X;

 /***************计算y的值*******************/
 void y()
 {
     complex <double> *x,*y;
     complex <double> *q=ifft_Q(); //调用函数得到q矩阵
     x=(complex <double>*)malloc(sizeof(complex <double>)*czt_m);
     y=(complex <double>*)malloc(sizeof(complex <double>)*czt_m);
     for(int i=;i<czt_m;i++)
     {
         x[i]=pow(czt_w,(i*i)/)*q[i];
     }
     y=x;
     output_to_file(y,czt_m);
 }

注意点：

output_to_file(y,czt_m);
函数功能是将输出矩阵——y中数据打印到一个文件中去，这样方便与matlab中结果比较，因为在终端显示器上由于点数较多，不能完全显示。这个函数需要的参数有两个：其一就是矩阵名——数组地址，其二就是矩阵长度——数组长度。完整定义如下：

 //写一个检验函数：目的是将复数输出结果打印到文件中去，以便跟matlab结果对比
 void output_to_file(complex <double> *name,int L)
 {
     complex <double> *var_name=name;
     FILE *fp=fopen("data.txt","w+");
     for(int i=;i<L;i++)
         fprintf(fp,"%lf + %lfj\n",real(var_name[i]),imag(var_name[i]));
     fclose(fp);
 }

所以这个函数可以检验多个中间过程的矩阵取值情况（很nice  呵呵）

最后就是主函数调用部分：

 int main()
 {
    src_txt_u();             //得到原始数据点
    complex <double> *G;
    G=fft_g();               //得到G矩阵
    complex <double> *H;
    H=fft_h();               //得到H矩阵
    y();                     //H.*G,q=ifft(Q)，y=x都是在这个函数中完成的
    return ;

 }