FFT returns NaN values - c

Question

I'm trying to use the FFTW for my large project, so I wrote a basic program to check if the FFT is working or not. I am trying to send sine values to the FFT and back. After using the FFT forwards and FFT backwards I get exactly the same results, but I get a NaN value at the first element of the array. I read in some of the questions here that the issue is the data type, I need to use long double and fftwl to maintain accuracy of the results.
Where is the problem? Is it in the data type and how can I solve it?
#include <fftw3.h>
#include <math.h>
#include <stdio.h>
#include <complex.h>
#include <stdlib.h>
#include <inttypes.h>
#include <assert.h>
int Ypt=128;
long double PI=3.14159265358979323846;
void complex2FFT( complex long double *U)
{
long double normalizing_factor= 2.0/Ypt;
fftwl_plan plan_f;
fftwl_complex *in;
fftwl_complex *out;
in = (fftwl_complex *) fftwl_malloc(sizeof(fftwl_complex) * Ypt);
out = (fftwl_complex *) fftwl_malloc(sizeof(fftwl_complex) * Ypt);
for (int i = 0; i < Ypt; ++i){
in[i ][0]= creal(U[i]);
in[i ][1]= cimag(U[i]);
}
plan_f = fftwl_plan_dft_1d(Ypt, in, out, FFTW_FORWARD , FFTW_ESTIMATE);
fftwl_execute(plan_f);
for (int i = 0; i < Ypt; ++i){
U[i] = normalizing_factor*out[i][0] + normalizing_factor*out[i][1]*I;
}
fftwl_destroy_plan(plan_f);
fftwl_free(in);
fftwl_free(out);
fftwl_cleanup();
}
void FFT2complex( complex long double *U)
{
long double normalizing_factor= 1.0;
fftwl_plan plan_b;
fftwl_complex *in;
fftwl_complex *out;
in = (fftwl_complex *) fftwl_malloc(sizeof(fftwl_complex) * Ypt);
out = (fftwl_complex *) fftwl_malloc(sizeof(fftwl_complex) * Ypt);
for (int i = 0; i < Ypt; ++i){
out[i ][0]= creal(U[i]);
out[i ][1]= cimag(U[i]);
}
plan_b = fftwl_plan_dft_1d(Ypt, in, out, FFTW_BACKWARD, FFTW_ESTIMATE);
for (int i = 0; i < Ypt; ++i){
U[i] = normalizing_factor*in[i ][0] + normalizing_factor*in[i ][1]*I;
}
fftwl_execute(plan_b);
fftwl_destroy_plan(plan_b);
fftwl_free(in);
fftwl_free(out);
fftwl_cleanup();
}
int main(int argc, char **argv){
long double dy=( (long double)1) / ( (long double)Ypt);
complex long double *U = malloc(Ypt * sizeof(*U));
complex long double *V = malloc(Ypt * sizeof(*V));
for (int i = 0; i < Ypt; ++i){
U[i] = sin( (double) (2.0*PI* (double)i * dy)) ;
V[i] = sin( (double) (2.0*PI* (double)i * dy)) ;
}
char name[45];
FILE *stream;
sprintf(name, "V%d.txt", 0);
stream= fopen(name,"w");
for (int i = 0; i < Ypt; ++i){
fprintf(stream, "%Lf %2.5f %2.5f \n", (long double)i*dy,creal(U[i]),cimag(U[i]));
}
complex2FFT(U);
FFT2complex(U);
for (int i = 0; i < Ypt; ++i){
fprintf(stream, "%Lf %2.5f %2.5f \n", (long double)i*dy,creal(U[i]),cimag(U[i]) );
}
free(U);
free(V);
}

Answer 1

As noticed by #Dietrich Epp , fftwl_execute(plan_b) runs after the output is copied, therefore the output is left unchanged. In addition, FFTW_BACKWARD performs the backward DFT, but it does not mean that the argument in is used as output. Even with flag FFTW_BACKWARD, the input argument of fftw_plan_dft_1d() is in and the output is out.
See for instance that example of forward then backward transform : FFTW forward and back ward yield in different results why?
for (int i = 0; i < Ypt; ++i){
out[i ][0]= creal(U[i]);
out[i ][1]= cimag(U[i]);
}
plan_b = fftwl_plan_dft_1d(Ypt, out, in, FFTW_BACKWARD, FFTW_ESTIMATE);
fftwl_execute(plan_b);
for (int i = 0; i < Ypt; ++i){
U[i] = normalizing_factor*in[i ][0] + normalizing_factor*in[i ][1]*I;
}