int main( int argc, char *argv[] ) { const UINT4 n = 65536; const REAL4 dt = 1.0 / 16384.0; static LALStatus status; static REAL4TimeSeries x; static COMPLEX8FrequencySeries X; static REAL4TimeSeries y; static REAL4FrequencySeries Y; static COMPLEX8TimeSeries z; static COMPLEX8FrequencySeries Z; RealFFTPlan *fwdRealPlan = NULL; RealFFTPlan *revRealPlan = NULL; ComplexFFTPlan *fwdComplexPlan = NULL; ComplexFFTPlan *revComplexPlan = NULL; RandomParams *randpar = NULL; AverageSpectrumParams avgSpecParams; UINT4 srate[] = { 4096, 9000 }; UINT4 npts[] = { 262144, 1048576 }; REAL4 var[] = { 5, 16 }; UINT4 j, sr, np, vr; /*CHAR fname[2048];*/ ParseOptions( argc, argv ); LALSCreateVector( &status, &x.data, n ); TestStatus( &status, CODES( 0 ), 1 ); LALCCreateVector( &status, &X.data, n / 2 + 1 ); TestStatus( &status, CODES( 0 ), 1 ); LALCCreateVector( &status, &z.data, n ); TestStatus( &status, CODES( 0 ), 1 ); LALCCreateVector( &status, &Z.data, n ); TestStatus( &status, CODES( 0 ), 1 ); LALCreateForwardRealFFTPlan( &status, &fwdRealPlan, n, 0 ); TestStatus( &status, CODES( 0 ), 1 ); LALCreateReverseRealFFTPlan( &status, &revRealPlan, n, 0 ); TestStatus( &status, CODES( 0 ), 1 ); LALCreateForwardComplexFFTPlan( &status, &fwdComplexPlan, n, 0 ); TestStatus( &status, CODES( 0 ), 1 ); LALCreateReverseComplexFFTPlan( &status, &revComplexPlan, n, 0 ); TestStatus( &status, CODES( 0 ), 1 ); randpar = XLALCreateRandomParams( 100 ); /* * * Try the real transform. * */ x.f0 = 0; x.deltaT = dt; x.sampleUnits = lalMeterUnit; snprintf( x.name, sizeof( x.name ), "x" ); XLALNormalDeviates( x.data, randpar ); for ( j = 0; j < n; ++j ) /* add a 60 Hz line */ { REAL4 t = j * dt; x.data->data[j] += 0.1 * cos( LAL_TWOPI * 60.0 * t ); } LALSPrintTimeSeries( &x, "x.out" ); snprintf( X.name, sizeof( X.name ), "X" ); LALTimeFreqRealFFT( &status, &X, &x, fwdRealPlan ); TestStatus( &status, CODES( 0 ), 1 ); LALCPrintFrequencySeries( &X, "X.out" ); LALFreqTimeRealFFT( &status, &x, &X, revRealPlan ); TestStatus( &status, CODES( 0 ), 1 ); LALSPrintTimeSeries( &x, "xx.out" ); /* * * Try the average power spectum. * */ avgSpecParams.method = useMean; for ( np = 0; np < XLAL_NUM_ELEM(npts) ; ++np ) { /* length of time series for 7 segments, overlapped by 1/2 segment */ UINT4 tsLength = npts[np] * 7 - 6 * npts[np] / 2; LALCreateVector( &status, &y.data, tsLength ); TestStatus( &status, CODES( 0 ), 1 ); LALCreateVector( &status, &Y.data, npts[np] / 2 + 1 ); TestStatus( &status, CODES( 0 ), 1 ); avgSpecParams.overlap = npts[np] / 2; /* create the window */ avgSpecParams.window = XLALCreateHannREAL4Window(npts[np]); avgSpecParams.plan = NULL; LALCreateForwardRealFFTPlan( &status, &avgSpecParams.plan, npts[np], 0 ); TestStatus( &status, CODES( 0 ), 1 ); for ( sr = 0; sr < XLAL_NUM_ELEM(srate) ; ++sr ) { /* set the sample rate of the time series */ y.deltaT = 1.0 / (REAL8) srate[sr]; for ( vr = 0; vr < XLAL_NUM_ELEM(var) ; ++vr ) { REAL4 eps = 1e-6; /* very conservative fp precision */ REAL4 Sfk = 2.0 * var[vr] * var[vr] * y.deltaT; REAL4 sfk = 0; REAL4 lbn; REAL4 sig; REAL4 ssq; REAL4 tol; /* create the data */ XLALNormalDeviates( y.data, randpar ); ssq = 0; for ( j = 0; j < y.data->length; ++j ) { y.data->data[j] *= var[vr]; ssq += y.data->data[j] * y.data->data[j]; } /* compute tolerance for comparison */ lbn = log( y.data->length ) / log( 2 ); sig = sqrt( 2.5 * lbn * eps * eps * ssq / y.data->length ); tol = 5 * sig; /* compute the psd and find the average */ LALREAL4AverageSpectrum( &status, &Y, &y, &avgSpecParams ); TestStatus( &status, CODES( 0 ), 1 ); LALSMoment( &status, &sfk, Y.data, 1 ); TestStatus( &status, CODES( 0 ), 1 ); /* check the result */ if ( fabs(Sfk-sfk) > tol ) { fprintf( stderr, "FAIL: PSD estimate appears incorrect\n"); fprintf( stderr, "expected %e, got %e ", Sfk, sfk ); fprintf( stderr, "(difference = %e, tolerance = %e)\n", fabs(Sfk-sfk), tol ); exit(2); } } } /* destroy structures that need to be resized */ LALDestroyRealFFTPlan( &status, &avgSpecParams.plan ); TestStatus( &status, CODES( 0 ), 1 ); XLALDestroyREAL4Window( avgSpecParams.window ); LALDestroyVector( &status, &y.data ); TestStatus( &status, CODES( 0 ), 1 ); LALDestroyVector( &status, &Y.data ); TestStatus( &status, CODES( 0 ), 1 ); } /* * * Try the complex transform. * */ z.f0 = 0; z.deltaT = dt; z.sampleUnits = lalVoltUnit; snprintf( z.name, sizeof( z.name ), "z" ); { /* dirty hack */ REAL4Vector tmp; tmp.length = 2 * z.data->length; tmp.data = (REAL4 *)z.data->data; XLALNormalDeviates( &tmp, randpar ); } for ( j = 0; j < n; ++j ) /* add a 50 Hz line and a 500 Hz ringdown */ { REAL4 t = j * dt; z.data->data[j] += 0.2 * cos( LAL_TWOPI * 50.0 * t ); z.data->data[j] += I * exp( -t ) * sin( LAL_TWOPI * 500.0 * t ); } LALCPrintTimeSeries( &z, "z.out" ); TestStatus( &status, CODES( 0 ), 1 ); snprintf( Z.name, sizeof( Z.name ), "Z" ); LALTimeFreqComplexFFT( &status, &Z, &z, fwdComplexPlan ); TestStatus( &status, CODES( 0 ), 1 ); LALCPrintFrequencySeries( &Z, "Z.out" ); LALFreqTimeComplexFFT( &status, &z, &Z, revComplexPlan ); TestStatus( &status, CODES( 0 ), 1 ); LALCPrintTimeSeries( &z, "zz.out" ); XLALDestroyRandomParams( randpar ); LALDestroyRealFFTPlan( &status, &fwdRealPlan ); TestStatus( &status, CODES( 0 ), 1 ); LALDestroyRealFFTPlan( &status, &revRealPlan ); TestStatus( &status, CODES( 0 ), 1 ); LALDestroyComplexFFTPlan( &status, &fwdComplexPlan ); TestStatus( &status, CODES( 0 ), 1 ); LALDestroyComplexFFTPlan( &status, &revComplexPlan ); TestStatus( &status, CODES( 0 ), 1 ); LALCDestroyVector( &status, &Z.data ); TestStatus( &status, CODES( 0 ), 1 ); LALCDestroyVector( &status, &z.data ); TestStatus( &status, CODES( 0 ), 1 ); LALCDestroyVector( &status, &X.data ); TestStatus( &status, CODES( 0 ), 1 ); LALSDestroyVector( &status, &x.data ); TestStatus( &status, CODES( 0 ), 1 ); LALCheckMemoryLeaks(); return 0; }
int main( int argc, char *argv[] ) { static LALStatus status; RealFFTPlan *fwd = NULL; RealFFTPlan *rev = NULL; REAL4Vector *dat = NULL; REAL4Vector *rfft = NULL; REAL4Vector *ans = NULL; COMPLEX8Vector *dft = NULL; COMPLEX8Vector *fft = NULL; #if LAL_CUDA_ENABLED /* The test itself should pass at 1e-4, but it might fail at * some rare cases where accuracy is bad for some numbers. */ REAL8 eps = 3e-4; #else /* very conservative floating point precision */ REAL8 eps = 1e-6; #endif REAL8 lbn; REAL8 ssq; REAL8 var; REAL8 tol; UINT4 nmax; UINT4 m; UINT4 n; UINT4 i; UINT4 j; UINT4 k; UINT4 s = 0; FILE *fp; ParseOptions( argc, argv ); m = m_; n = n_; fp = verbose ? stdout : NULL ; if ( n == 0 ) { nmax = 65536; } else { nmax = n--; } while ( n < nmax ) { if ( n < 128 ) { ++n; } else { n *= 2; } LALSCreateVector( &status, &dat, n ); TestStatus( &status, CODES( 0 ), 1 ); LALSCreateVector( &status, &rfft, n ); TestStatus( &status, CODES( 0 ), 1 ); LALSCreateVector( &status, &ans, n ); TestStatus( &status, CODES( 0 ), 1 ); LALCCreateVector( &status, &dft, n / 2 + 1 ); TestStatus( &status, CODES( 0 ), 1 ); LALCCreateVector( &status, &fft, n / 2 + 1 ); TestStatus( &status, CODES( 0 ), 1 ); LALCreateForwardRealFFTPlan( &status, &fwd, n, 0 ); TestStatus( &status, CODES( 0 ), 1 ); LALCreateReverseRealFFTPlan( &status, &rev, n, 0 ); TestStatus( &status, CODES( 0 ), 1 ); /* * * Do m trials of random data. * */ for ( i = 0; i < m; ++i ) { srand( s++ ); /* seed the random number generator */ /* * * Create data and compute error tolerance. * * Reference: Kaneko and Liu, * "Accumulation of round-off error in fast fourier tranforms" * J. Asssoc. Comp. Mach, Vol 17 (No 4) 637-654, October 1970. * */ srand( i ); /* seed the random number generator */ ssq = 0; for ( j = 0; j < n; ++j ) { dat->data[j] = 20.0 * rand() / (REAL4)( RAND_MAX + 1.0 ) - 10.0; ssq += dat->data[j] * dat->data[j]; fp ? fprintf( fp, "%e\n", dat->data[j] ) : 0; } lbn = log( n ) / log( 2 ); var = 2.5 * lbn * eps * eps * ssq / n; tol = 5 * sqrt( var ); /* up to 5 sigma excursions */ fp ? fprintf( fp, "\neps = %e \ntol = %e\n", eps, tol ) : 0; /* * * Perform forward FFT and DFT (only if n < 100). * */ LALForwardRealFFT( &status, fft, dat, fwd ); TestStatus( &status, CODES( 0 ), 1 ); LALREAL4VectorFFT( &status, rfft, dat, fwd ); TestStatus( &status, CODES( 0 ), 1 ); LALREAL4VectorFFT( &status, ans, rfft, rev ); TestStatus( &status, CODES( 0 ), 1 ); fp ? fprintf( fp, "rfft()\t\trfft(rfft())\trfft(rfft())\n\n" ) : 0; for ( j = 0; j < n; ++j ) { fp ? fprintf( fp, "%e\t%e\t%e\n", rfft->data[j], ans->data[j], ans->data[j] / n ) : 0; } if ( n < 128 ) { LALForwardRealDFT( &status, dft, dat ); TestStatus( &status, CODES( 0 ), 1 ); /* * * Check accuracy of FFT vs DFT. * */ fp ? fprintf( fp, "\nfftre\t\tfftim\t\t" ) : 0; fp ? fprintf( fp, "dtfre\t\tdftim\n" ) : 0; for ( k = 0; k <= n / 2; ++k ) { REAL8 fftre = creal(fft->data[k]); REAL8 fftim = cimag(fft->data[k]); REAL8 dftre = creal(dft->data[k]); REAL8 dftim = cimag(dft->data[k]); REAL8 errre = fabs( dftre - fftre ); REAL8 errim = fabs( dftim - fftim ); REAL8 avere = fabs( dftre + fftre ) / 2 + eps; REAL8 aveim = fabs( dftim + fftim ) / 2 + eps; REAL8 ferre = errre / avere; REAL8 ferim = errim / aveim; fp ? fprintf( fp, "%e\t%e\t", fftre, fftim ) : 0; fp ? fprintf( fp, "%e\t%e\n", dftre, dftim ) : 0; /* fp ? fprintf( fp, "%e\t%e\t", errre, errim ) : 0; */ /* fp ? fprintf( fp, "%e\t%e\n", ferre, ferim ) : 0; */ if ( ferre > eps && errre > tol ) { fputs( "FAIL: Incorrect result from forward transform\n", stderr ); fprintf( stderr, "\tdifference = %e\n", errre ); fprintf( stderr, "\ttolerance = %e\n", tol ); fprintf( stderr, "\tfrac error = %e\n", ferre ); fprintf( stderr, "\tprecision = %e\n", eps ); return 1; } if ( ferim > eps && errim > tol ) { fputs( "FAIL: Incorrect result from forward transform\n", stderr ); fprintf( stderr, "\tdifference = %e\n", errim ); fprintf( stderr, "\ttolerance = %e\n", tol ); fprintf( stderr, "\tfrac error = %e\n", ferim ); fprintf( stderr, "\tprecision = %e\n", eps ); return 1; } } } /* * * Perform reverse FFT and check accuracy vs original data. * */ LALReverseRealFFT( &status, ans, fft, rev ); TestStatus( &status, CODES( 0 ), 1 ); fp ? fprintf( fp, "\ndat->data[j]\tans->data[j] / n\n" ) : 0; for ( j = 0; j < n; ++j ) { REAL8 err = fabs( dat->data[j] - ans->data[j] / n ); REAL8 ave = fabs( dat->data[j] + ans->data[j] / n ) / 2 + eps; REAL8 fer = err / ave; fp ? fprintf( fp, "%e\t%e\n", dat->data[j], ans->data[j] / n ) : 0; /* fp ? fprintf( fp, "%e\t%e\n", err, fer ) : 0; */ if ( fer > eps && err > tol ) { fputs( "FAIL: Incorrect result after reverse transform\n", stderr ); fprintf( stderr, "\tdifference = %e\n", err ); fprintf( stderr, "\ttolerance = %e\n", tol ); fprintf( stderr, "\tfrac error = %e\n", fer ); fprintf( stderr, "\tprecision = %e\n", eps ); return 1; } } } LALSDestroyVector( &status, &dat ); TestStatus( &status, CODES( 0 ), 1 ); LALSDestroyVector( &status, &rfft ); TestStatus( &status, CODES( 0 ), 1 ); LALSDestroyVector( &status, &ans ); TestStatus( &status, CODES( 0 ), 1 ); LALCDestroyVector( &status, &dft ); TestStatus( &status, CODES( 0 ), 1 ); LALCDestroyVector( &status, &fft ); TestStatus( &status, CODES( 0 ), 1 ); LALDestroyRealFFTPlan( &status, &fwd ); TestStatus( &status, CODES( 0 ), 1 ); LALDestroyRealFFTPlan( &status, &rev ); TestStatus( &status, CODES( 0 ), 1 ); } LALCheckMemoryLeaks(); return 0; }