C# FFT 实施未产生预期结果

Question

I'm trying to implement, in C#, for my own learning, an FFT algorithm described here:

https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm

under "Data reordering, bit reversal, and in-place algorithms".

My code is as follows, with some background operator overloading for the "cplx" structure to allow me to do arithmetic on these objects.

Bitreverse seems to work fine, and so does the "twiddle factor" calculation, so I'm not sure where I've gone wrong. The code looks awfully similar to the pseudocode given on the wiki page.

    public cplx[] FFT(cplx[] x)
    {
        //Bitreverse Copy
        cplx[] a = BitReverse(x);

        //Number of points
        int n = a.Length;

        for (int s = 1; s <= Math.Log(n); s++)
        {
            int m = (int)Math.Pow(2,s);
            cplx w_m = Omega(m);

            for (int k = 0; k < n; k += m)
            {
                cplx w = new cplx(1, 0);

                for(int j = 0; j < m/2; j++)
                {
                    cplx t = w * a[k + j + (m / 2)];
                    cplx u = a[k + j];

                    a[k + j] = u + t;
                    a[k + j + (m / 2)] = u - t;

                    w = w * w_m;
                }
            }
        }

        return a;
    }

I'm testing it with an input array of an origin-impulse with 8 samples, which should produce a constant output.

Instead, I'm getting 4 ones and 4 zeros, in that order.

As an aside, I assume that in the pseudocode:

for k = 0 to n-1 by m

Refers to for(k = 0; k < n; k += m) although I'm not sure that's right.

Hopefully someone can shed some light on my incompetence!

Cheers.

Here's the code for bitreversal and the omega calculation.

       private int Rev(int x, int k)
    {
        int reversed = 0;

        for (int i = 0; i < k; i++)
        {
            reversed |= (x & (1 << i)) != 0 ? 1 << (k - 1 - i) : 0;
        }

        return reversed;
    }

    public cplx[] BitReverse(cplx[] x)
    {
        cplx[] r = new cplx[x.Length];

        int bits = (int)Math.Log(x.Length, 2);

        for(int k = 0; k < x.Length; k++)
        {
            r[Rev(k, bits)] = x[k];
        }

        return r;
    }

    private cplx Omega(int m)
    {
        float x = (- 2 * (float)Math.PI) / m;

        return new cplx((float)Math.Cos(x), (float)(Math.Sin(x)));
    }

Answer 1

I should have been using log2(n) when I was using Math.Log() .