这个C ++ FFT函数是否等效于“ fft” matlab函数？

Question

I have always used the function "fft(x)" in matlab where "x" is a vector of complex numbers. I am looking for an easy to use function in C++ that would return complex numbers.

I have found this code : http://paulbourke.net/miscellaneous/dft/

If it is equivalent, how can I use it ? Thank you for your time !

  /*
   This computes an in-place complex-to-complex FFT 
   x and y are the real and imaginary arrays of 2^m points.
   dir =  1 gives forward transform
   dir = -1 gives reverse transform 
*/
short FFT(short int dir,long m,double *x,double *y)
{
   long n,i,i1,j,k,i2,l,l1,l2;
   double c1,c2,tx,ty,t1,t2,u1,u2,z;

   /* Calculate the number of points */
   n = 1;
   for (i=0;i<m;i++) 
      n *= 2;

   /* Do the bit reversal */
   i2 = n >> 1;
   j = 0;
   for (i=0;i<n-1;i++) {
      if (i < j) {
         tx = x[i];
         ty = y[i];
         x[i] = x[j];
         y[i] = y[j];
         x[j] = tx;
         y[j] = ty;
      }
      k = i2;
      while (k <= j) {
         j -= k;
         k >>= 1;
      }
      j += k;
   }

   /* Compute the FFT */
   c1 = -1.0; 
   c2 = 0.0;
   l2 = 1;
   for (l=0;l<m;l++) {
      l1 = l2;
      l2 <<= 1;
      u1 = 1.0; 
      u2 = 0.0;
      for (j=0;j<l1;j++) {
         for (i=j;i<n;i+=l2) {
            i1 = i + l1;
            t1 = u1 * x[i1] - u2 * y[i1];
            t2 = u1 * y[i1] + u2 * x[i1];
            x[i1] = x[i] - t1; 
            y[i1] = y[i] - t2;
            x[i] += t1;
            y[i] += t2;
         }
         z =  u1 * c1 - u2 * c2;
         u2 = u1 * c2 + u2 * c1;
         u1 = z;
      }
      c2 = sqrt((1.0 - c1) / 2.0);
      if (dir == 1) 
         c2 = -c2;
      c1 = sqrt((1.0 + c1) / 2.0);
   }

   /* Scaling for forward transform */
   if (dir == 1) {
      for (i=0;i<n;i++) {
         x[i] /= n;
         y[i] /= n;
      }
   }

   return(TRUE);
}

Answer 1

Alternative Suggestion:

I had same problem. I used fft library from fftw. http://www.fftw.org/download.html Its performance is similar to matlab.

Answer 2

The code looks fine at first glance. The original FFT is not a lot of code.

One feature of the FFT is that it is an inplace operation. Many higher level bindings effectively hide that fact.

So you put your real and imaginary parts into the x and y arrays. After the executing the function you read those same arrays for your result.

This particularly simple implementation will only work with powers of 2 as the original FFT. If you have inputs of lengths other than powers of 2 you could zero-pad your signal.

Google the book Numerical Recipes and fft (older versions are freely available) if you want to read up on the background of the FFT. The version in that book is different from other implementations in that you have to feed in the real and imaginary parts interleaved.

What I'm missing on the implementation that you are quoting is the use of pi or trigonometric functions. You'll have to try it out to compare against Matlab.