Chris@118: /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
Chris@110: 
Chris@110: #include "dsp/transforms/FFT.h"
Chris@110: 
Chris@110: #define BOOST_TEST_DYN_LINK
Chris@110: #define BOOST_TEST_MAIN
Chris@110: 
Chris@110: #include <boost/test/unit_test.hpp>
Chris@110: 
Chris@129: #include <stdexcept>
Chris@129: 
Chris@110: BOOST_AUTO_TEST_SUITE(TestFFT)
Chris@110: 
Chris@110: #define COMPARE_CONST(a, n) \
Chris@110:     for (int cmp_i = 0; cmp_i < (int)(sizeof(a)/sizeof(a[0])); ++cmp_i) { \
Chris@110:         BOOST_CHECK_SMALL(a[cmp_i] - n, 1e-14);				\
Chris@110:     }
Chris@110: 
Chris@110: #define COMPARE_ARRAY(a, b)						\
Chris@110:     for (int cmp_i = 0; cmp_i < (int)(sizeof(a)/sizeof(a[0])); ++cmp_i) { \
Chris@110:         BOOST_CHECK_SMALL(a[cmp_i] - b[cmp_i], 1e-14);			\
Chris@110:     }
Chris@110: 
Chris@114: //!!! need at least one test with complex time-domain signal
Chris@110: 
Chris@110: BOOST_AUTO_TEST_CASE(forwardArrayBounds)
Chris@110: {
Chris@170:     // initialise bins to something recognisable, so we can tell if
Chris@170:     // they haven't been written; and allocate the inputs on the heap
Chris@170:     // so that, if running under valgrind, we get warnings about
Chris@170:     // overruns
Chris@170:     double *in = new double[4];
Chris@170:     in[0] = 1;
Chris@170:     in[1] = 1;
Chris@170:     in[2] = -1;
Chris@170:     in[3] = -1;
Chris@110:     double re[] = { 999, 999, 999, 999, 999, 999 };
Chris@110:     double im[] = { 999, 999, 999, 999, 999, 999 };
Chris@110:     FFT(4).process(false, in, 0, re+1, im+1);
Chris@110:     // And check we haven't overrun the arrays
Chris@110:     BOOST_CHECK_EQUAL(re[0], 999.0);
Chris@110:     BOOST_CHECK_EQUAL(im[0], 999.0);
Chris@110:     BOOST_CHECK_EQUAL(re[5], 999.0);
Chris@110:     BOOST_CHECK_EQUAL(im[5], 999.0);
Chris@170:     delete[] in;
Chris@110: }
Chris@110: 
Chris@114: BOOST_AUTO_TEST_CASE(r_forwardArrayBounds)
Chris@114: {
Chris@170:     // initialise bins to something recognisable, so we can tell if
Chris@170:     // they haven't been written; and allocate the inputs on the heap
Chris@170:     // so that, if running under valgrind, we get warnings about
Chris@170:     // overruns
Chris@170:     double *in = new double[4];
Chris@170:     in[0] = 1;
Chris@170:     in[1] = 1;
Chris@170:     in[2] = -1;
Chris@170:     in[3] = -1;
Chris@114:     double re[] = { 999, 999, 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999, 999, 999 };
Chris@114:     FFTReal(4).forward(in, re+1, im+1);
Chris@114:     // And check we haven't overrun the arrays
Chris@114:     BOOST_CHECK_EQUAL(re[0], 999.0);
Chris@114:     BOOST_CHECK_EQUAL(im[0], 999.0);
Chris@114:     BOOST_CHECK_EQUAL(re[5], 999.0);
Chris@114:     BOOST_CHECK_EQUAL(im[5], 999.0);
Chris@170:     delete[] in;
Chris@114: }
Chris@114: 
Chris@110: BOOST_AUTO_TEST_CASE(inverseArrayBounds)
Chris@110: {
Chris@170:     // initialise bins to something recognisable, so we can tell if
Chris@170:     // they haven't been written; and allocate the inputs on the heap
Chris@170:     // so that, if running under valgrind, we get warnings about
Chris@170:     // overruns
Chris@170:     double *re = new double[4];
Chris@170:     double *im = new double[4];
Chris@170:     re[0] = 0;
Chris@170:     re[1] = 1;
Chris@170:     re[2] = 0;
Chris@170:     re[3] = 1;
Chris@170:     im[0] = 0;
Chris@170:     im[1] = -2;
Chris@170:     im[2] = 0;
Chris@170:     im[3] = 2;
Chris@110:     double outre[] = { 999, 999, 999, 999, 999, 999 };
Chris@110:     double outim[] = { 999, 999, 999, 999, 999, 999 };
Chris@114:     FFT(4).process(true, re, im, outre+1, outim+1);
Chris@110:     // And check we haven't overrun the arrays
Chris@110:     BOOST_CHECK_EQUAL(outre[0], 999.0);
Chris@110:     BOOST_CHECK_EQUAL(outim[0], 999.0);
Chris@110:     BOOST_CHECK_EQUAL(outre[5], 999.0);
Chris@110:     BOOST_CHECK_EQUAL(outim[5], 999.0);
Chris@170:     delete[] re;
Chris@170:     delete[] im;
Chris@110: }
Chris@110: 
Chris@114: BOOST_AUTO_TEST_CASE(r_inverseArrayBounds)
Chris@114: {
Chris@170:     // initialise bins to something recognisable, so we can tell if
Chris@170:     // they haven't been written; and allocate the inputs on the heap
Chris@170:     // so that, if running under valgrind, we get warnings about
Chris@170:     // overruns
Chris@170:     double *re = new double[3];
Chris@170:     double *im = new double[3];
Chris@170:     re[0] = 0;
Chris@170:     re[1] = 1;
Chris@170:     re[2] = 0;
Chris@170:     im[0] = 0;
Chris@170:     im[1] = -2;
Chris@170:     im[2] = 0;
Chris@114:     double outre[] = { 999, 999, 999, 999, 999, 999 };
Chris@114:     FFTReal(4).inverse(re, im, outre+1);
Chris@114:     // And check we haven't overrun the arrays
Chris@114:     BOOST_CHECK_EQUAL(outre[0], 999.0);
Chris@114:     BOOST_CHECK_EQUAL(outre[5], 999.0);
Chris@170:     delete[] re;
Chris@170:     delete[] im;
Chris@114: }
Chris@114: 
Chris@114: BOOST_AUTO_TEST_CASE(dc)
Chris@114: {
Chris@114:     // DC-only signal. The DC bin is purely real
Chris@114:     double in[] = { 1, 1, 1, 1 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFT(4).process(false, in, 0, re, im);
Chris@114:     BOOST_CHECK_EQUAL(re[0], 4.0);
Chris@114:     BOOST_CHECK_EQUAL(re[1], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[2], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[3], 0.0);
Chris@114:     COMPARE_CONST(im, 0.0);
Chris@114:     double back[4];
Chris@114:     double backim[4];
Chris@114:     FFT(4).process(true, re, im, back, backim);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114:     COMPARE_CONST(backim, 0.0);
Chris@114: }
Chris@114: 
Chris@114: BOOST_AUTO_TEST_CASE(r_dc)
Chris@114: {
Chris@114:     // DC-only signal. The DC bin is purely real
Chris@114:     double in[] = { 1, 1, 1, 1 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFTReal(4).forward(in, re, im);
Chris@114:     BOOST_CHECK_EQUAL(re[0], 4.0);
Chris@114:     BOOST_CHECK_EQUAL(re[1], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[2], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[3], 0.0);
Chris@114:     COMPARE_CONST(im, 0.0);
Chris@114:     double back[4];
Chris@114:     // check conjugates are reconstructed
Chris@114:     re[3] = 999;
Chris@114:     im[3] = 999;
Chris@114:     FFTReal(4).inverse(re, im, back);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114: }
Chris@114: 
Chris@159: BOOST_AUTO_TEST_CASE(c_dc)
Chris@159: {
Chris@159:     // DC-only signal. The DC bin is purely real
Chris@159:     double rin[] = { 1, 1, 1, 1 };
Chris@159:     double iin[] = { 1, 1, 1, 1 };
Chris@159:     double re[] = { 999, 999, 999, 999 };
Chris@159:     double im[] = { 999, 999, 999, 999 };
Chris@159:     FFT(4).process(false, rin, iin, re, im);
Chris@159:     BOOST_CHECK_EQUAL(re[0], 4.0);
Chris@159:     BOOST_CHECK_EQUAL(re[1], 0.0);
Chris@159:     BOOST_CHECK_EQUAL(re[2], 0.0);
Chris@159:     BOOST_CHECK_EQUAL(re[3], 0.0);
Chris@159:     BOOST_CHECK_EQUAL(im[0], 4.0);
Chris@159:     BOOST_CHECK_EQUAL(im[1], 0.0);
Chris@159:     BOOST_CHECK_EQUAL(im[2], 0.0);
Chris@159:     BOOST_CHECK_EQUAL(im[3], 0.0);
Chris@159:     double back[4];
Chris@159:     double backim[4];
Chris@159:     FFT(4).process(true, re, im, back, backim);
Chris@159:     COMPARE_ARRAY(back, rin);
Chris@159:     COMPARE_ARRAY(backim, iin);
Chris@159: }
Chris@159: 
Chris@114: BOOST_AUTO_TEST_CASE(sine)
Chris@114: {
Chris@114:     // Sine. Output is purely imaginary
Chris@114:     double in[] = { 0, 1, 0, -1 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFT(4).process(false, in, 0, re, im);
Chris@114:     COMPARE_CONST(re, 0.0);
Chris@114:     BOOST_CHECK_EQUAL(im[0], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(im[1], -2.0);
Chris@114:     BOOST_CHECK_EQUAL(im[2], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(im[3], 2.0);
Chris@114:     double back[4];
Chris@114:     double backim[4];
Chris@114:     FFT(4).process(true, re, im, back, backim);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114:     COMPARE_CONST(backim, 0.0);
Chris@114: }
Chris@114: 
Chris@114: BOOST_AUTO_TEST_CASE(r_sine)
Chris@114: {
Chris@114:     // Sine. Output is purely imaginary
Chris@114:     double in[] = { 0, 1, 0, -1 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFTReal(4).forward(in, re, im);
Chris@114:     COMPARE_CONST(re, 0.0);
Chris@114:     BOOST_CHECK_EQUAL(im[0], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(im[1], -2.0);
Chris@114:     BOOST_CHECK_EQUAL(im[2], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(im[3], 2.0);
Chris@114:     double back[4];
Chris@114:     // check conjugates are reconstructed
Chris@114:     re[3] = 999;
Chris@114:     im[3] = 999;
Chris@114:     FFTReal(4).inverse(re, im, back);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114: }
Chris@114: 
Chris@114: BOOST_AUTO_TEST_CASE(cosine)
Chris@114: {
Chris@114:     // Cosine. Output is purely real
Chris@114:     double in[] = { 1, 0, -1, 0 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFT(4).process(false, in, 0, re, im);
Chris@114:     BOOST_CHECK_EQUAL(re[0], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[1], 2.0);
Chris@114:     BOOST_CHECK_EQUAL(re[2], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[3], 2.0);
Chris@114:     COMPARE_CONST(im, 0.0);
Chris@114:     double back[4];
Chris@114:     double backim[4];
Chris@114:     FFT(4).process(true, re, im, back, backim);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114:     COMPARE_CONST(backim, 0.0);
Chris@114: }
Chris@114: 
Chris@114: BOOST_AUTO_TEST_CASE(r_cosine)
Chris@114: {
Chris@114:     // Cosine. Output is purely real
Chris@114:     double in[] = { 1, 0, -1, 0 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFTReal(4).forward(in, re, im);
Chris@114:     BOOST_CHECK_EQUAL(re[0], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[1], 2.0);
Chris@114:     BOOST_CHECK_EQUAL(re[2], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[3], 2.0);
Chris@114:     COMPARE_CONST(im, 0.0);
Chris@114:     double back[4];
Chris@114:     // check conjugates are reconstructed
Chris@114:     re[3] = 999;
Chris@114:     im[3] = 999;
Chris@114:     FFTReal(4).inverse(re, im, back);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114: }
Chris@159: 
Chris@159: BOOST_AUTO_TEST_CASE(c_cosine)
Chris@159: {
Chris@159:     // Cosine. Output is purely real
Chris@159:     double rin[] = { 1, 0, -1, 0 };
Chris@159:     double iin[] = { 1, 0, -1, 0 };
Chris@159:     double re[] = { 999, 999, 999, 999 };
Chris@159:     double im[] = { 999, 999, 999, 999 };
Chris@159:     FFT(4).process(false, rin, iin, re, im);
Chris@159:     BOOST_CHECK_EQUAL(re[0], 0.0);
Chris@159:     BOOST_CHECK_EQUAL(re[1], 2.0);
Chris@159:     BOOST_CHECK_EQUAL(re[2], 0.0);
Chris@159:     BOOST_CHECK_EQUAL(re[3], 2.0);
Chris@159:     BOOST_CHECK_EQUAL(im[0], 0.0);
Chris@159:     BOOST_CHECK_EQUAL(im[1], 2.0);
Chris@159:     BOOST_CHECK_EQUAL(im[2], 0.0);
Chris@159:     BOOST_CHECK_EQUAL(im[3], 2.0);
Chris@159:     double back[4];
Chris@159:     double backim[4];
Chris@159:     FFT(4).process(true, re, im, back, backim);
Chris@159:     COMPARE_ARRAY(back, rin);
Chris@159:     COMPARE_ARRAY(backim, iin);
Chris@159: }
Chris@114: 	
Chris@114: BOOST_AUTO_TEST_CASE(sineCosine)
Chris@114: {
Chris@114:     // Sine and cosine mixed
Chris@114:     double in[] = { 0.5, 1, -0.5, -1 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFT(4).process(false, in, 0, re, im);
Chris@114:     BOOST_CHECK_EQUAL(re[0], 0.0);
Chris@114:     BOOST_CHECK_CLOSE(re[1], 1.0, 1e-12);
Chris@114:     BOOST_CHECK_EQUAL(re[2], 0.0);
Chris@114:     BOOST_CHECK_CLOSE(re[3], 1.0, 1e-12);
Chris@114:     BOOST_CHECK_EQUAL(im[0], 0.0);
Chris@114:     BOOST_CHECK_CLOSE(im[1], -2.0, 1e-12);
Chris@114:     BOOST_CHECK_EQUAL(im[2], 0.0);
Chris@114:     BOOST_CHECK_CLOSE(im[3], 2.0, 1e-12);
Chris@114:     double back[4];
Chris@114:     double backim[4];
Chris@114:     FFT(4).process(true, re, im, back, backim);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114:     COMPARE_CONST(backim, 0.0);
Chris@114: }
Chris@114: 	
Chris@114: BOOST_AUTO_TEST_CASE(r_sineCosine)
Chris@114: {
Chris@114:     // Sine and cosine mixed
Chris@114:     double in[] = { 0.5, 1, -0.5, -1 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFTReal(4).forward(in, re, im);
Chris@114:     BOOST_CHECK_EQUAL(re[0], 0.0);
Chris@114:     BOOST_CHECK_CLOSE(re[1], 1.0, 1e-12);
Chris@114:     BOOST_CHECK_EQUAL(re[2], 0.0);
Chris@114:     BOOST_CHECK_CLOSE(re[3], 1.0, 1e-12);
Chris@114:     BOOST_CHECK_EQUAL(im[0], 0.0);
Chris@114:     BOOST_CHECK_CLOSE(im[1], -2.0, 1e-12);
Chris@114:     BOOST_CHECK_EQUAL(im[2], 0.0);
Chris@114:     BOOST_CHECK_CLOSE(im[3], 2.0, 1e-12);
Chris@114:     double back[4];
Chris@114:     // check conjugates are reconstructed
Chris@114:     re[3] = 999;
Chris@114:     im[3] = 999;
Chris@114:     FFTReal(4).inverse(re, im, back);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114: }
Chris@159: 	
Chris@159: BOOST_AUTO_TEST_CASE(c_sineCosine)
Chris@159: {
Chris@159:     double rin[] = { 1, 0, -1, 0 };
Chris@159:     double iin[] = { 0, 1, 0, -1 };
Chris@159:     double re[] = { 999, 999, 999, 999 };
Chris@159:     double im[] = { 999, 999, 999, 999 };
Chris@159:     FFT(4).process(false, rin, iin, re, im);
Chris@159:     BOOST_CHECK_EQUAL(re[0], 0.0);
Chris@159:     BOOST_CHECK_EQUAL(re[1], 4.0);
Chris@159:     BOOST_CHECK_EQUAL(re[2], 0.0);
Chris@159:     BOOST_CHECK_EQUAL(re[3], 0.0);
Chris@159:     COMPARE_CONST(im, 0.0);
Chris@159:     double back[4];
Chris@159:     double backim[4];
Chris@159:     FFT(4).process(true, re, im, back, backim);
Chris@159:     COMPARE_ARRAY(back, rin);
Chris@159:     COMPARE_ARRAY(backim, iin);
Chris@159: }
Chris@114: 
Chris@114: BOOST_AUTO_TEST_CASE(nyquist)
Chris@114: {
Chris@114:     double in[] = { 1, -1, 1, -1 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFT(4).process(false, in, 0, re, im);
Chris@114:     BOOST_CHECK_EQUAL(re[0], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[1], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[2], 4.0);
Chris@114:     BOOST_CHECK_EQUAL(re[3], 0.0);
Chris@114:     COMPARE_CONST(im, 0.0);
Chris@114:     double back[4];
Chris@114:     double backim[4];
Chris@114:     FFT(4).process(true, re, im, back, backim);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114:     COMPARE_CONST(backim, 0.0);
Chris@114: }
Chris@114: 
Chris@114: BOOST_AUTO_TEST_CASE(r_nyquist)
Chris@114: {
Chris@114:     double in[] = { 1, -1, 1, -1 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFTReal(4).forward(in, re, im);
Chris@114:     BOOST_CHECK_EQUAL(re[0], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[1], 0.0);
Chris@114:     BOOST_CHECK_EQUAL(re[2], 4.0);
Chris@114:     BOOST_CHECK_EQUAL(re[3], 0.0);
Chris@114:     COMPARE_CONST(im, 0.0);
Chris@114:     double back[4];
Chris@114:     // check conjugates are reconstructed
Chris@114:     re[3] = 999;
Chris@114:     im[3] = 999;
Chris@114:     FFTReal(4).inverse(re, im, back);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114: }
Chris@114: 
Chris@114: BOOST_AUTO_TEST_CASE(dirac)
Chris@114: {
Chris@114:     double in[] = { 1, 0, 0, 0 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFT(4).process(false, in, 0, re, im);
Chris@114:     BOOST_CHECK_EQUAL(re[0], 1.0);
Chris@114:     BOOST_CHECK_EQUAL(re[1], 1.0);
Chris@114:     BOOST_CHECK_EQUAL(re[2], 1.0);
Chris@114:     BOOST_CHECK_EQUAL(re[3], 1.0);
Chris@114:     COMPARE_CONST(im, 0.0);
Chris@114:     double back[4];
Chris@114:     double backim[4];
Chris@114:     FFT(4).process(true, re, im, back, backim);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114:     COMPARE_CONST(backim, 0.0);
Chris@114: }
Chris@114: 
Chris@114: BOOST_AUTO_TEST_CASE(r_dirac)
Chris@114: {
Chris@114:     double in[] = { 1, 0, 0, 0 };
Chris@114:     double re[] = { 999, 999, 999, 999 };
Chris@114:     double im[] = { 999, 999, 999, 999 };
Chris@114:     FFTReal(4).forward(in, re, im);
Chris@114:     BOOST_CHECK_EQUAL(re[0], 1.0);
Chris@114:     BOOST_CHECK_EQUAL(re[1], 1.0);
Chris@114:     BOOST_CHECK_EQUAL(re[2], 1.0);
Chris@114:     BOOST_CHECK_EQUAL(re[3], 1.0);
Chris@114:     COMPARE_CONST(im, 0.0);
Chris@114:     double back[4];
Chris@114:     // check conjugates are reconstructed
Chris@114:     re[3] = 999;
Chris@114:     im[3] = 999;
Chris@114:     FFTReal(4).inverse(re, im, back);
Chris@114:     COMPARE_ARRAY(back, in);
Chris@114: }
Chris@114: 
Chris@129: BOOST_AUTO_TEST_CASE(sizes) 
Chris@129: {
Chris@129:     // Complex supports any size. A single test with an odd size
Chris@129:     // will do here, without getting too much into our expectations
Chris@129:     // about supported butterflies etc
Chris@129: 
Chris@129:     double in[] = { 1, 1, 1 };
Chris@129:     double re[] = { 999, 999, 999 };
Chris@129:     double im[] = { 999, 999, 999 };
Chris@129:     FFT(3).process(false, in, 0, re, im);
Chris@129:     BOOST_CHECK_EQUAL(re[0], 3.0);
Chris@129:     BOOST_CHECK_EQUAL(re[1], 0.0);
Chris@129:     BOOST_CHECK_EQUAL(re[2], 0.0);
Chris@129:     COMPARE_CONST(im, 0.0);
Chris@129:     double back[3];
Chris@129:     double backim[3];
Chris@129:     FFT(3).process(true, re, im, back, backim);
Chris@129:     COMPARE_ARRAY(back, in);
Chris@129:     COMPARE_CONST(backim, 0.0);
Chris@129: }
Chris@129: 
Chris@129: BOOST_AUTO_TEST_CASE(r_sizes)
Chris@129: {
Chris@129:     // Real supports any even size, but not odd ones
Chris@129: 
Chris@129:     BOOST_CHECK_THROW(FFTReal r(3), std::invalid_argument);
Chris@129: 
Chris@129:     double in[] = { 1, 1, 1, 1, 1, 1 };
Chris@129:     double re[] = { 999, 999, 999, 999, 999, 999 };
Chris@129:     double im[] = { 999, 999, 999, 999, 999, 999 };
Chris@129:     FFTReal(6).forward(in, re, im);
Chris@129:     BOOST_CHECK_EQUAL(re[0], 6.0);
Chris@129:     BOOST_CHECK_EQUAL(re[1], 0.0);
Chris@129:     BOOST_CHECK_EQUAL(re[2], 0.0);
Chris@129:     BOOST_CHECK_EQUAL(re[3], 0.0);
Chris@129:     BOOST_CHECK_EQUAL(re[4], 0.0);
Chris@129:     BOOST_CHECK_EQUAL(re[5], 0.0);
Chris@129:     COMPARE_CONST(im, 0.0);
Chris@129:     double back[6];
Chris@129:     FFTReal(6).inverse(re, im, back);
Chris@129:     COMPARE_ARRAY(back, in);
Chris@129: }
Chris@129: 
Chris@110: BOOST_AUTO_TEST_SUITE_END()
Chris@110: