Question

我正在尝试使用c中的FFTW3来理解就地与非现场FFT。首先，我决定使用一维变换。我首先对复杂的变换进行了异地实现，然后我使用该变换的复数输出来进行实际变换的原位复合，希望能够获得原始的真实输入数据。但是，我不知道为什么？我的示例代码如下所示。

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

void one_dimensional_transform(void)
{
    float *in;
    fftwf_complex *out, *inplace;
    int N = 8;
    fftwf_plan plan;
    int i;
    FILE *fd;

    // Do out of place transform. For this, in has N elements and out has N/2 + 1.
    in  = fftwf_alloc_real(N);
    out = fftwf_alloc_complex(N/2 + 1); 
    inplace = fftwf_alloc_complex(2 * ((N/2) + 1));

    plan = fftwf_plan_dft_r2c_1d(N, in, out, FFTW_ESTIMATE);

    fd = fopen("input_data.txt", "w");

    for(i = 0; i < N; i++)
    {   
        in[i] = sin(2.0 * M_PI * (2.0 * M_PI * i / N));
        fprintf(fd, "%f\n", in[i]);
    }   
    fclose(fd);

    fftwf_execute(plan);
    fftwf_destroy_plan(plan);
    fftwf_cleanup();

    // Do in-place transform
    for(i = 0; i < N/2 + 1; i++)
    {   
        inplace[i] = out[i];
    }   

    plan = fftwf_plan_dft_c2r_1d(N, (fftwf_complex *)inplace, (float *)inplace, FFTW_ESTIMATE);

    // I think that I need to include the complex conjugates to the complex version of
    // inplace (as this is what Mesinger does), and that's why we have the size of
    // inplace being 2 * (N/2 + 1). 
    for(i = 1; i < N/2; i++)
    {   
        inplace[N/2 + i] = conjf(inplace[N/2 - i]); 
    }   

    for(i = 0; i < 2 * (N/2 + 1); i++)
    {   
        inplace[i] /= (float)N;
        fftwf_execute(plan);
        fftwf_destroy_plan(plan);
        fftwf_cleanup();

        fd = fopen("inplace_data.txt", "w");

        for(i = 0; i < N; i++)
        {
            fprintf(fd, "%f\n", crealf(inplace[i]));
        }
        fclose(fd);

        fftwf_free(in);
        fftwf_free(out);
        fftwf_free(inplace);
}

从FFTW3文档中，他们说实际数据必须是2（N / 2 + 1）。此外，由于Hermitian对称性，实数到复数变换切断了复数阵列的后半部分，我决定明确地将这些元素放回去，但我不确定是否需要。我还用N重新调整了就地变换的输出，因为文档说变换没有标准化。

Answer 1

主要问题是，由于循环，发布的代码实际上多次运行fftwf_execute（和fftw_destroy！）

for(i = 0; i < 2 * (N/2 + 1); i++)
{   
    inplace[i] /= (float)N;
    fftwf_execute(plan);
    fftwf_destroy_plan(plan);
    fftwf_cleanup();
    ...
}

您可能打算执行以下操作：

for(i = 0; i < 2 * (N/2 + 1); i++)
{   
    inplace[i] /= (float)N;
}
fftwf_execute(plan);
fftwf_destroy_plan(plan);
fftwf_cleanup();

此外，结果存储在float数组中，因此您应该回读并保存数据：

  for(i = 0; i < N; i++)
  {
    fprintf(fd, "%f\n", ((float*) inplace)[i]));
  }

而不是仅使用crealf(inplace[i])（仅使用每秒值）提取实部。

最后关于你的评论

此外，由于Hermitian对称性，实数到复数变换会切断复数阵列的后半部分，所以我决定明确地将这些元素放回去，但我不确定是否需要

我可以向你保证，不需要它。复数到实数的变换并不需要频谱的后半部分，因为它是基于它具有厄米对称性的知识。

使用FFTW3的就地FFT

1 个答案: