c语言实现只计算实部的FFT的高性能代码

以下是C语言实现只计算实部的FFT的高性能代码：

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

#define PI 3.141592653589793

/* 计算FFT */
void fft(double *in, double complex *out, int n) {
    if (n == 1) {
        *out = *in;
        return;
    }
    double *even = malloc(n / 2 * sizeof(double));
    double *odd = malloc(n / 2 * sizeof(double));
    double complex *even_out = malloc(n / 2 * sizeof(double complex));
    double complex *odd_out = malloc(n / 2 * sizeof(double complex));
    for (int i = 0; i < n / 2; i++) {
        even[i] = in[2 * i];
        odd[i] = in[2 * i + 1];
    }
    fft(even, even_out, n / 2);
    fft(odd, odd_out, n / 2);
    for (int i = 0; i < n / 2; i++) {
        double complex t = cexp(-2 * PI * I * i / n) * odd_out[i];
        out[i] = even_out[i] + t;
        out[i + n / 2] = even_out[i] - t;
    }
    free(even);
    free(odd);
    free(even_out);
    free(odd_out);
}

/* 只计算实部的FFT */
void rfft(double *in, double *out, int n) {
    double complex *cpx = malloc(n * sizeof(double complex));
    fft(in, cpx, n);
    out[0] = creal(cpx[0]);
    out[n / 2] = creal(cpx[n / 2]);
    for (int i = 1; i < n / 2; i++) {
        double complex t = cpx[i] + conj(cpx[n - i]);
        out[i] = creal(t);
        out[n - i] = cimag(t) * -1;
    }
    free(cpx);
}

/* 测试代码 */
int main() {
    int n = 8;
    double *in = malloc(n * sizeof(double));
    double *out = malloc(n * sizeof(double));
    for (int i = 0; i < n; i++) {
        in[i] = sin(2 * PI * i / n);
    }
    rfft(in, out, n);
    for (int i = 0; i < n; i++) {
        printf("%lf ", out[i]);
    }
    printf("\n");
    free(in);
    free(out);
    return 0;
}

这个实现使用了递归的FFT算法，并且在计算完成后仅保留实部。此外，还使用了一些技巧来优化算法的效率，例如在递归过程中仅对数据数组的偶数和奇数部分进行递归，避免了重复计算。