实数傅里叶变换c语言实现

实数傅里叶变换（Real Fourier Transform）是一种将时间域信号转换为频域信号的方法。在C语言中，我们可以使用FFT算法来实现实数傅里叶变换。

以下是一个使用C语言实现实数傅里叶变换的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define PI 3.14159265358979323846

void FFT(int N, double *x, double *y) {
    int i, j, k, m;
    double s, t, tr, ti, ur, ui;

    j = 0;
    for (i = 0; i < N; i++) {
        if (j > i) {
            t = x[j];
            x[j] = x[i];
            x[i] = t;
            t = y[j];
            y[j] = y[i];
            y[i] = t;
        }
        m = N / 2;
        while (m >= 1 && j >= m) {
            j -= m;
            m /= 2;
        }
        j += m;
    }
    k = 0;
    for (i = 1; i < N; i *= 2) {
        k++;
    }
    for (m = 1; m <= k; m++) {
        for (i = 0; i < pow(2, m - 1); i++) {
            s = sin(PI / pow(2, m) * i);
            t = cos(PI / pow(2, m) * i);
            ur = 1;
            ui = 0;
            for (j = 0; j < pow(2, k - m); j++) {
                tr = x[i + j * pow(2, m)];
                ti = y[i + j * pow(2, m)];
                x[i + j * pow(2, m)] = tr * ur - ti * ui;
                y[i + j * pow(2, m)] = tr * ui + ti * ur;
                tr = x[i + (j + pow(2, k - m)) * pow(2, m)];
                ti = y[i + (j + pow(2, k - m)) * pow(2, m)];
                x[i + (j + pow(2, k - m)) * pow(2, m)] = tr * ur - ti * ui;
                y[i + (j + pow(2, k - m)) * pow(2, m)] = tr * ui + ti * ur;
                t = ur;
                ur = t * cos(PI / pow(2, m)) - ui * sin(PI / pow(2, m));
                ui = t * sin(PI / pow(2, m)) + ui * cos(PI / pow(2, m));
            }
        }
    }
}

int main() {
    int N = 8;
    double x[] = {1, 2, 3, 4, 5, 6, 7, 8};
    double y[] = {0, 0, 0, 0, 0, 0, 0, 0};
    int i;

    FFT(N, x, y);

    for (i = 0; i < N; i++) {
        printf("%f + %f i\n", x[i], y[i]);
    }

    return 0;
}

在上面的示例代码中，我们定义了一个FFT函数来计算傅里叶变换。该函数采用了Cooley-Tukey算法，使用了迭代的方式来计算实数傅里叶变换。

在main函数中，我们定义了一个长度为8的实数序列x，并初始化为1到8。我们还定义了一个长度为8的虚数序列y，并将其初始化为0。最后，我们调用FFT函数来计算傅里叶变换，并输出结果。

请注意，在实数傅里叶变换中，由于信号是实数，因此正频率和负频率是相同的。因此，输出的结果中只包含前N/2个频率。