// нерекурсивный алгоритм с прореживанием по частоте
void CYourCoolClass::Fft(complex a[], int m, int ind)
    {
    int n = pow2(m), i;

    ASSERT(n == BUFSIZE);
    complex v, w;
    int step = n;
    for(i = m; i > 0; i--)
        {
        step >>= 1;

        cexp(&v, ind*step);
        w = complex(1, 0);
        for(int j = 0; j < step; j++)
            {
            for(int k = j; k < n; k += step<<1)
                bfl(a[k], a[k+step], w);
            w *= v;
            }
        }

    for(int j = i = 0; i < n-1; i++)
        {
        if(i < j)
            {
            complex t;
            t = a[i];
            a[i] = a[j];
            a[j] = t;
            }
        int k = n/2;
        while(k <= j)
            {
            j -= k;
            k /=2;
            }
        j += k;
        }
    }

double cexp(complex* c, int n)
    {
    __asm
        {
        fldpi
        fild    n
        fdivp   st(1), st(0)
        fsincos
        mov     ebx, c
        fstp    qword ptr [ebx]
        fstp    qword ptr [ebx+8]
        }
    }


void CYourCoolClass::bfl(complex& a1, complex& a2, complex& w)
    {
    complex t = a1 - a2;
    a1 += a2;
    a2 = w * t;
    }

// рекурсивный вариант БПФ
void CYourCoolClass::fft(complex a[], int num, int ind)
    {
    if(num == 2)
        {
        complex tmp = a[0] - a[1];
        a[0] += a[1];
        a[1] = tmp;
        return;
        }

    int step = num>>1;
    complex    w, v;
    cexp(&v, ind*step);
    w = complex(1,0);
    for(int k = 0; k < step; k++)
        {
        int l = k+step;
        complex tmp = a[k] - a[l];
        a[k] += a[l];
        a[l] = w * tmp;
        w *= v;
        }

    fft(a, step, ind);
    fft(a+step, step, ind);
    }