FFT returning conjugate of true answer

Question

I have an odd problem. Following (re: copying) from here, I've been trying to implement the Cooley–Tukey FFT algorithm for arrays with a power-of-2 size, but the answers returned from this implementation are the conjugate of the true answers.

int fft_pow2(int dir,int m,float complex *a)
{
   long nn,i,i1,j,k,i2,l,l1,l2;
   float c1,c2,tx,ty,t1,t2,u1,u2,z;
   float complex t;
   /* Calculate the number of points */
   nn = 1;
   for (i=0;i<m;i++)
      nn *= 2;

   /* Do the bit reversal */
   i2 = nn >> 1;
   j = 0;
   for (i=0;i<nn-1;i++) {
      if (i < j) {
         t = a[i];
         a[i] = a[j];
         a[j] = t;
      }
      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<nn;i+=l2) {
            i1 = i + l1;
            t = u1 * crealf(a[i1]) - u2 * cimagf(a[i1])
                + I * (u1 * cimagf(a[i1]) + u2 * crealf(a[i1]));

            a[i1] = a[i] - t;

            a[i] += t;

         }
         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<nn;i++) {
        a[i] /= (float)nn;
      }
   }

   return 1;
}

int main(int argc, char **argv) {
    float complex arr[4] = { 1.0, 2.0, 3.0, 4.0 };
    fft_pow2(0, log2(n), arr);
    for (int i = 0; i < n; i++) {
        printf("%f %f\n", crealf(arr[i]), cimagf(arr[i]));
    }
}

The results:

10.000000 0.000000
-2.000000 -2.000000
-2.000000 0.000000
-2.000000 2.000000

whereas the true answer is the conjugate.

Any ideas?

score 2 · Answer 1 · answered May 16 '13 at 11:33

The FFT is often defined with H_k = sum(e^{–2•π•i•j•k/N}•h_j, 0 < j ≤ N). Note the minus sign in the exponent. The FFT can be defined with a plus sign instead of the minus sign. In large part, the definitions are equivalent, because +i and –i are completely symmetric.

The code you show is written for the definition with the negative sign, and it is also written so that the first parameter, dir, is 1 for a forward transform and something else for a reverse transform. We can determine the intended direction because of the comment about scaling for the forward transform: It scales if dir is 1.

So, where your code in main calls fft_pow2 with 0 for dir, it is requesting a reverse transform. Your code has performed a reverse transform using the FFT definition with a negative sign. The reverse of the transform with a negative sign is a transform with a positive sign. For [1, 2, 3, 4], the result is:

1⁰•1 + 1¹•2 + 1²•3 + 1³•4 = 1 + 2 + 3 + 4 = 10.
i⁰•1 + i¹•2 + i²•3 + i³•4 = 1 + 2i – 3 – 4i = –2 – 2i.
(–1)⁰•1 + (–1)¹•2 + (–1)²•3 + (–1)³•4 = 1 – 2 + 3 – 4 = –2.
(–i)⁰•1 + (–i)¹•2 + (–i)²•3 + (–i)³•4 = 1 – 2i – 3 + 4i = –2 + 2i.

And that is the result you obtained.

FFT returning conjugate of true answer

1 Answers1