之前有篇文章实现了合数的fft，和2的幂次方的fft，这里主要是关于更加一般形式的快速计算
时间隔了很久，才出了第二篇文章，实在是惭愧

代码在文末，包含步骤

需要掌握的知识

1 卷积
2 卷积
3 傅里叶变换的一般公式

卷积 (需要基础的高数知识，不懂微积分请看具体后面的实现步骤，懂的可以拿出纸笔验算一下是否合理 下面的 * 都表示卷积， · 点号表示乘积)

连续函数的卷积定义

离散函数的卷积定义

建议自行wiki查看定义，下面只是用我自己的理解来描述的

卷积在数学上有个定义，大概就是两个可积分的函数做一个特殊的运算，然后生成另外的一个函数。这个运算是先将两函数做乘法（做乘法的时候参数是自变量会稍微改变一下，如 f(t) · g(x-t) ），然后再求积分，最后得到新的函数h(x)。至于为什么这样的一个运算叫做卷积呢，我想了很久，大概是因为两个函数的乘积做了求和的操作吧，所以就叫卷积了，总之这个称呼对于我们理解这个运算并没有什么问题。
好了到这里本来应该结束了，但是我感觉学完1+1就开始解决高数的问题还是有点难
下面说下卷积的一些定律吧

非常重要的两个定律

1. 交换律
   证明过程
   
   
   
   
   
   
   
   

2. 结合律
   证明过程
   
   
   
   
   
   
   
   
   

离散傅里叶一般公式是

到这一步就是很关键的一步了，关于卷积的计算我们可能没啥底，但是至少卷积有关的参数只有一个，所以这里的话就相当于把离散傅里叶的计算换成了卷积的计算

这一步还有个关键的知识点

---

虽然有点绕，但是上面这句话这个真的是核心，因为转化成卷积之后求取傅里叶变换没有了输入参数的个数限制，只有真正计算点的限制，也就是我们可以手动的补参数补到参数的个数为我们需要的2的幂次方那么多为止
例如

输入的长度是9,对于DFT 那就是9，补一个长度，就影响到了DFT最后的结果
对于上面的卷积呢，输入参数所影响的有傅里叶变换的结果，也有逆变换的结果，
最终的输出结果是没有任何影响的
这就是为什么核心的原因

---

特别注意

补充参数在这里有个只得注意的地方
关于补参数这个问题，由于需要计算的知识n->{0,N-1},所以对于f(n) ,如果不存在 x(n) = 0那么f(n)也是为0的，但是对于g(n)来说，补参数的话是有一些需要注意的问题的，g(n)是偶函数，这个在函数里面可以看出来 即 g(-n) = g(n),所以对于g(n)补参数的时候也是要满足这个性质和g(n)是周期函数的性质的，假设补参数之后的长度为L,那么这个L 最小也是N的两倍，还需满足 g(L-n) = g(n);

---

到了这一步应该大部分都没啥问题了，写代码的话只是时间问题

具体代码步骤

结合公式和三面的描述，具体步骤分为6步

1. 求出输入参数需要补充的长度

2. 根据上面的长度设置f(n) 和 g(n)的值,这里的N为原参数的长度，一定得看上面的特别注意

3. 对 f(n) 和 g(n) 求快速傅里叶变换 得 F(n) 和 G(n)

4. F(n) 和 G(n) 做乘积 得H(n)

5. 对H(n) 做快速傅里叶逆变换 得h(n)

6. 根据h(n) 求出傅里叶变换的结果

代码（参照上面的步骤）

这个对应下面代码的基础参数baseCmpow

/**
* 求取基础的参数的幂次方，上面
*/
Complexf *baseCmPow(Complexf *cm, int n, int p){
    cm->setReal( cos(p * PI /n));
    cm->setIm( sin(-p * PI / n));
    return cm;
}

/**
* 一般形式的fft
*/
void fft_normal(Complexf *cm, int N){
    u_int L = 1,tmpn = 0,M = N,tn = N * 2;
    while (L < 2*N ){
        L = L * 2;
    } 

    Complexf tempmul = Complexf();
    Complexf *temp = (Complexf *)malloc(L * sizeof(Complexf));
    
    Complexf *temp2 = (Complexf *)malloc(L * sizeof(Complexf));
    for (int i = 0; i < L; i++){
        
        if (i < N){
            tmpn = i*i;
            baseCmPow(&tempmul, N, tmpn);
            temp[i].setData(tempmul);
            temp[i] *= cm[i];

            baseCmPow(&tempmul, N, -tmpn);
            temp2[i].setData(tempmul);
        }else{
            if (i > L - N){
                tmpn = (L - i)*(L - i);
                baseCmPow(&tempmul, N, -tmpn);
                temp2[i].setData(tempmul);
            }else{
                temp2[i].init();
            }
            temp[i].init();
        }
    }

    fft_base2(temp, L);
    fft_base2(temp2, L);
    for (int i = 0; i < L;i++){
        temp[i] *= temp2[i];
    }

    ifft_base2(temp, L);

    for (int i = 0; i < N;i++){
        tmpn = i*i;
        baseCmPow(&tempmul, N, tmpn);
        tempmul *= temp[i];
        cm[i].setData(tempmul);
    }
    free(temp);
    free(temp2);
}
/**
* 一般形式的ifft
*/
void ifft_normal(Complexf *cm, int N){
    for (int i = 0; i<N; i++){
        cm[i].setIm(-cm[i].getIm());
    }

    fft_normal(cm, N);

    for (int i = 0; i<N; i++){
        cm[i].setReal(cm[i].getReal() / N);
        cm[i].setIm(-cm[i].getIm() / N);
    }
}

这里的fft_base2 ,ifft_base2 ,Complexf都参照这篇文章的，具体代码可以在github找到

---

结尾

到这里就结束了一般化的快速傅里叶计算，时间复杂度大于N'logN',这个N' 主要是因为补参数。

希望本文能对对你理解一般性质的快速傅里叶变换有所帮助。有问题欢迎留言或email

---