数字信号产生之解析信号的产生

fft.h

 

#pragma once
#include <math.h>

#define pi 3.14159265359

class fft
{
private:
 double * x, * y;
 double c, c1, e, s, s1, t, tr, ti;
 int n, sign, i, j, k, l, m, n1, n2;

public:
 fft() {}
 void generate();
 void transform(double *, double *, int, int);
 /*~fft()
 {
  delete[] x, y;
 }*/
};

//当sign = 1时，计算快速傅立叶变换
//当sign = -1时，计算快速傅立叶逆变换
void fft::transform(double * x, double * y, int n, int sign)
{
 j = 1;
 for (i = 1; i < 16; i++)
 {
  m = i;
  j = 2 * j;
  if (j == n)
   break;
 }

 n1 = n - 1;
 j = 0;
 for (i = 0; i < n1; i++)
 {
  if (i < j)
  {
   tr = x[j];
   ti = y[j];
   x[j] = x[i];
   y[j] = y[i];
   x[i] = tr;
   y[i] = ti;
  }
  k = n / 2;
  while (k < (j + 1))
  {
   j = j - k;
   k = k / 2;
  }
  j = j + k;
 }

 n1 = 1;
 for (l = 1; l <= m; l++)
 {
  n1 = 2 * n1;
  n2 = n1 / 2;
  e = pi / n2;
  c = 1.0;
  s = 0.0;
  c1 = cos(e);
  s1 = -sign * sin(e);
  for (j = 0; j < n2; j++)
  {
   for (i = j; i < n; i += n1)
   {
    k = i + n2;
    tr = c * x[k] - s * y[k];
    ti = c * y[k] + s * x[k];
    x[k] = x[i] - tr;
    y[k] = y[i] - ti;
    x[i] = x[i] + tr;
    y[i] = y[i] + ti;
   }
   t = c;
   c = c * c1 - s * s1;
   s = t * s1 + s * c1;
  }
 }

 if (sign == -1)
 {
  for (i = 0; i < n; i++)
  {
   x[i] /= n;
   y[i] /= n;
  }
 }
}

 

 

analytic.h

 

#pragma once
#include "fft.h"

class analytic
{
private:
 double * x, * y;
 int n, i, n1;

public:
 analytic() {}
 void generate();
 void random_number(double *, double *, int);
 ~analytic()
 {
  delete[] x, y;
 }
};

void analytic::random_number(double * x, double * y, int n)
{
 fft fft_num;

 n1 = n / 2;
 for (i = 0; i < n; i++)
 {
  y[i] = 0.0;
 }
 fft_num.transform(x, y, n, 1);
 for (i = 1; i < n1; i++)
 {
  x[i] = 2 * x[i];
  y[i] = 2 * y[i];
 }
 for (i = n1; i < n; i++)
 {
  x[i] = 0.0;
  y[i] = 0.0;
 }
 fft_num.transform(x, y, n, -1);
}

 

 

analytic.cpp

 

//计算序列的解析信号，并与理想值进行比较
#include <iostream>
#include <math.h>
#include <fstream>
#include "Analytic.h"

#define pi 3.14159265

using namespace std;

void main()
{
 analytic solution;
 solution.generate();
}

void analytic::generate()
{
 //数据长度，必须是2的整数次幂，即n = 2 ^ m
 cout << "输入数据长度：";
 cin >> n;
 //开始时存放实数输入信号，最后存放解析信号的实部
 x = new double[n];
 //存放解析信号的虚部
 y = new double[n];

 double * z =  new double[n];
 
 for (int k = 0; k < n; k++)
 {
  x[k] = sin(2 * pi * k / n);
 }

 ofstream fout;
 //输出原始数据
 fout.open("原始数据.dat");
 for (int k = 0; k < n; k++)
  fout << x[k] << endl;
 fout.close();

 for (int k = 0; k < n; k++)
 {
  z[k] = -cos(2 * pi * k / n);
 }
 //输出理想希尔伯特变换结果
 fout.open("理想希尔伯特变换结果.dat");
 for (int k = 0; k < n; k++)
  fout << z[k] << endl;
 fout.close();

 random_number(x, y, n);
 //输出解析信号的实部
 fout.open("解析信号的实部.dat");
 for (int k = 0; k < n; k++)
  fout << x[k] << endl;
 fout.close();
 //输出解析信号的虚部
 fout.open("解析信号的虚部.dat");
 for (int k = 0; k < n; k++)
  fout << y[k] << endl;
 fout.close();
}