Mercurial > hg > constant-q-cpp

annotate test/TestFFT.cpp @ 196:da283326bcd3 tip master

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Update plugin versions in RDF
author Chris Cannam <cannam@all-day-breakfast.com>
date Fri, 28 Feb 2020 09:43:02 +0000
parents 6b13f9c694a8
children
rev   line source
c@131 1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
c@131 2
c@131 3 #include "dsp/FFT.h"
c@131 4
c@131 5 #define BOOST_TEST_DYN_LINK
c@131 6 #define BOOST_TEST_MAIN
c@131 7
c@131 8 #include <boost/test/unit_test.hpp>
c@131 9
c@131 10 #include <stdexcept>
c@131 11
c@131 12 BOOST_AUTO_TEST_SUITE(TestFFT)
c@131 13
c@131 14 #define COMPARE_CONST(a, n) \
c@131 15 for (int cmp_i = 0; cmp_i < (int)(sizeof(a)/sizeof(a[0])); ++cmp_i) { \
c@131 16 BOOST_CHECK_SMALL(a[cmp_i] - n, 1e-14); \
c@131 17 }
c@131 18
c@131 19 #define COMPARE_ARRAY(a, b) \
c@131 20 for (int cmp_i = 0; cmp_i < (int)(sizeof(a)/sizeof(a[0])); ++cmp_i) { \
c@131 21 BOOST_CHECK_SMALL(a[cmp_i] - b[cmp_i], 1e-14); \
c@131 22 }
c@131 23
c@131 24 //!!! need at least one test with complex time-domain signal
c@131 25
c@131 26 BOOST_AUTO_TEST_CASE(forwardArrayBounds)
c@131 27 {
c@131 28 // initialise bins to something recognisable, so we can tell if
c@131 29 // they haven't been written; and allocate the inputs on the heap
c@131 30 // so that, if running under valgrind, we get warnings about
c@131 31 // overruns
c@131 32 double *in = new double[4];
c@131 33 in[0] = 1;
c@131 34 in[1] = 1;
c@131 35 in[2] = -1;
c@131 36 in[3] = -1;
c@131 37 double re[] = { 999, 999, 999, 999, 999, 999 };
c@131 38 double im[] = { 999, 999, 999, 999, 999, 999 };
c@131 39 FFT(4).process(false, in, 0, re+1, im+1);
c@131 40 // And check we haven't overrun the arrays
c@131 41 BOOST_CHECK_EQUAL(re[0], 999.0);
c@131 42 BOOST_CHECK_EQUAL(im[0], 999.0);
c@131 43 BOOST_CHECK_EQUAL(re[5], 999.0);
c@131 44 BOOST_CHECK_EQUAL(im[5], 999.0);
c@131 45 delete[] in;
c@131 46 }
c@131 47
c@131 48 BOOST_AUTO_TEST_CASE(r_forwardArrayBounds)
c@131 49 {
c@131 50 // initialise bins to something recognisable, so we can tell if
c@131 51 // they haven't been written; and allocate the inputs on the heap
c@131 52 // so that, if running under valgrind, we get warnings about
c@131 53 // overruns
c@131 54 double *in = new double[4];
c@131 55 in[0] = 1;
c@131 56 in[1] = 1;
c@131 57 in[2] = -1;
c@131 58 in[3] = -1;
c@131 59 double re[] = { 999, 999, 999, 999, 999, 999 };
c@131 60 double im[] = { 999, 999, 999, 999, 999, 999 };
c@131 61 FFTReal(4).forward(in, re+1, im+1);
c@131 62 // And check we haven't overrun the arrays
c@131 63 BOOST_CHECK_EQUAL(re[0], 999.0);
c@131 64 BOOST_CHECK_EQUAL(im[0], 999.0);
c@131 65 BOOST_CHECK_EQUAL(re[5], 999.0);
c@131 66 BOOST_CHECK_EQUAL(im[5], 999.0);
c@131 67 delete[] in;
c@131 68 }
c@131 69
c@131 70 BOOST_AUTO_TEST_CASE(inverseArrayBounds)
c@131 71 {
c@131 72 // initialise bins to something recognisable, so we can tell if
c@131 73 // they haven't been written; and allocate the inputs on the heap
c@131 74 // so that, if running under valgrind, we get warnings about
c@131 75 // overruns
c@131 76 double *re = new double[4];
c@131 77 double *im = new double[4];
c@131 78 re[0] = 0;
c@131 79 re[1] = 1;
c@131 80 re[2] = 0;
c@131 81 re[3] = 1;
c@131 82 im[0] = 0;
c@131 83 im[1] = -2;
c@131 84 im[2] = 0;
c@131 85 im[3] = 2;
c@131 86 double outre[] = { 999, 999, 999, 999, 999, 999 };
c@131 87 double outim[] = { 999, 999, 999, 999, 999, 999 };
c@131 88 FFT(4).process(true, re, im, outre+1, outim+1);
c@131 89 // And check we haven't overrun the arrays
c@131 90 BOOST_CHECK_EQUAL(outre[0], 999.0);
c@131 91 BOOST_CHECK_EQUAL(outim[0], 999.0);
c@131 92 BOOST_CHECK_EQUAL(outre[5], 999.0);
c@131 93 BOOST_CHECK_EQUAL(outim[5], 999.0);
c@131 94 delete[] re;
c@131 95 delete[] im;
c@131 96 }
c@131 97
c@131 98 BOOST_AUTO_TEST_CASE(r_inverseArrayBounds)
c@131 99 {
c@131 100 // initialise bins to something recognisable, so we can tell if
c@131 101 // they haven't been written; and allocate the inputs on the heap
c@131 102 // so that, if running under valgrind, we get warnings about
c@131 103 // overruns
c@131 104 double *re = new double[3];
c@131 105 double *im = new double[3];
c@131 106 re[0] = 0;
c@131 107 re[1] = 1;
c@131 108 re[2] = 0;
c@131 109 im[0] = 0;
c@131 110 im[1] = -2;
c@131 111 im[2] = 0;
c@131 112 double outre[] = { 999, 999, 999, 999, 999, 999 };
c@131 113 FFTReal(4).inverse(re, im, outre+1);
c@131 114 // And check we haven't overrun the arrays
c@131 115 BOOST_CHECK_EQUAL(outre[0], 999.0);
c@131 116 BOOST_CHECK_EQUAL(outre[5], 999.0);
c@131 117 delete[] re;
c@131 118 delete[] im;
c@131 119 }
c@131 120
c@131 121 BOOST_AUTO_TEST_CASE(dc)
c@131 122 {
c@131 123 // DC-only signal. The DC bin is purely real
c@131 124 double in[] = { 1, 1, 1, 1 };
c@131 125 double re[] = { 999, 999, 999, 999 };
c@131 126 double im[] = { 999, 999, 999, 999 };
c@131 127 FFT(4).process(false, in, 0, re, im);
c@131 128 BOOST_CHECK_EQUAL(re[0], 4.0);
c@131 129 BOOST_CHECK_EQUAL(re[1], 0.0);
c@131 130 BOOST_CHECK_EQUAL(re[2], 0.0);
c@131 131 BOOST_CHECK_EQUAL(re[3], 0.0);
c@131 132 COMPARE_CONST(im, 0.0);
c@131 133 double back[4];
c@131 134 double backim[4];
c@131 135 FFT(4).process(true, re, im, back, backim);
c@131 136 COMPARE_ARRAY(back, in);
c@131 137 COMPARE_CONST(backim, 0.0);
c@131 138 }
c@131 139
c@131 140 BOOST_AUTO_TEST_CASE(r_dc)
c@131 141 {
c@131 142 // DC-only signal. The DC bin is purely real
c@131 143 double in[] = { 1, 1, 1, 1 };
c@131 144 double re[] = { 999, 999, 999, 999 };
c@131 145 double im[] = { 999, 999, 999, 999 };
c@131 146 FFTReal(4).forward(in, re, im);
c@131 147 BOOST_CHECK_EQUAL(re[0], 4.0);
c@131 148 BOOST_CHECK_EQUAL(re[1], 0.0);
c@131 149 BOOST_CHECK_EQUAL(re[2], 0.0);
c@131 150 BOOST_CHECK_EQUAL(re[3], 0.0);
c@131 151 COMPARE_CONST(im, 0.0);
c@131 152 double back[4];
c@131 153 // check conjugates are reconstructed
c@131 154 re[3] = 999;
c@131 155 im[3] = 999;
c@131 156 FFTReal(4).inverse(re, im, back);
c@131 157 COMPARE_ARRAY(back, in);
c@131 158 }
c@131 159
c@131 160 BOOST_AUTO_TEST_CASE(c_dc)
c@131 161 {
c@131 162 // DC-only signal. The DC bin is purely real
c@131 163 double rin[] = { 1, 1, 1, 1 };
c@131 164 double iin[] = { 1, 1, 1, 1 };
c@131 165 double re[] = { 999, 999, 999, 999 };
c@131 166 double im[] = { 999, 999, 999, 999 };
c@131 167 FFT(4).process(false, rin, iin, re, im);
c@131 168 BOOST_CHECK_EQUAL(re[0], 4.0);
c@131 169 BOOST_CHECK_EQUAL(re[1], 0.0);
c@131 170 BOOST_CHECK_EQUAL(re[2], 0.0);
c@131 171 BOOST_CHECK_EQUAL(re[3], 0.0);
c@131 172 BOOST_CHECK_EQUAL(im[0], 4.0);
c@131 173 BOOST_CHECK_EQUAL(im[1], 0.0);
c@131 174 BOOST_CHECK_EQUAL(im[2], 0.0);
c@131 175 BOOST_CHECK_EQUAL(im[3], 0.0);
c@131 176 double back[4];
c@131 177 double backim[4];
c@131 178 FFT(4).process(true, re, im, back, backim);
c@131 179 COMPARE_ARRAY(back, rin);
c@131 180 COMPARE_ARRAY(backim, iin);
c@131 181 }
c@131 182
c@131 183 BOOST_AUTO_TEST_CASE(sine)
c@131 184 {
c@131 185 // Sine. Output is purely imaginary
c@131 186 double in[] = { 0, 1, 0, -1 };
c@131 187 double re[] = { 999, 999, 999, 999 };
c@131 188 double im[] = { 999, 999, 999, 999 };
c@131 189 FFT(4).process(false, in, 0, re, im);
c@131 190 COMPARE_CONST(re, 0.0);
c@131 191 BOOST_CHECK_EQUAL(im[0], 0.0);
c@131 192 BOOST_CHECK_EQUAL(im[1], -2.0);
c@131 193 BOOST_CHECK_EQUAL(im[2], 0.0);
c@131 194 BOOST_CHECK_EQUAL(im[3], 2.0);
c@131 195 double back[4];
c@131 196 double backim[4];
c@131 197 FFT(4).process(true, re, im, back, backim);
c@131 198 COMPARE_ARRAY(back, in);
c@131 199 COMPARE_CONST(backim, 0.0);
c@131 200 }
c@131 201
c@131 202 BOOST_AUTO_TEST_CASE(r_sine)
c@131 203 {
c@131 204 // Sine. Output is purely imaginary
c@131 205 double in[] = { 0, 1, 0, -1 };
c@131 206 double re[] = { 999, 999, 999, 999 };
c@131 207 double im[] = { 999, 999, 999, 999 };
c@131 208 FFTReal(4).forward(in, re, im);
c@131 209 COMPARE_CONST(re, 0.0);
c@131 210 BOOST_CHECK_EQUAL(im[0], 0.0);
c@131 211 BOOST_CHECK_EQUAL(im[1], -2.0);
c@131 212 BOOST_CHECK_EQUAL(im[2], 0.0);
c@131 213 BOOST_CHECK_EQUAL(im[3], 2.0);
c@131 214 double back[4];
c@131 215 // check conjugates are reconstructed
c@131 216 re[3] = 999;
c@131 217 im[3] = 999;
c@131 218 FFTReal(4).inverse(re, im, back);
c@131 219 COMPARE_ARRAY(back, in);
c@131 220 }
c@131 221
c@131 222 BOOST_AUTO_TEST_CASE(cosine)
c@131 223 {
c@131 224 // Cosine. Output is purely real
c@131 225 double in[] = { 1, 0, -1, 0 };
c@131 226 double re[] = { 999, 999, 999, 999 };
c@131 227 double im[] = { 999, 999, 999, 999 };
c@131 228 FFT(4).process(false, in, 0, re, im);
c@131 229 BOOST_CHECK_EQUAL(re[0], 0.0);
c@131 230 BOOST_CHECK_EQUAL(re[1], 2.0);
c@131 231 BOOST_CHECK_EQUAL(re[2], 0.0);
c@131 232 BOOST_CHECK_EQUAL(re[3], 2.0);
c@131 233 COMPARE_CONST(im, 0.0);
c@131 234 double back[4];
c@131 235 double backim[4];
c@131 236 FFT(4).process(true, re, im, back, backim);
c@131 237 COMPARE_ARRAY(back, in);
c@131 238 COMPARE_CONST(backim, 0.0);
c@131 239 }
c@131 240
c@131 241 BOOST_AUTO_TEST_CASE(r_cosine)
c@131 242 {
c@131 243 // Cosine. Output is purely real
c@131 244 double in[] = { 1, 0, -1, 0 };
c@131 245 double re[] = { 999, 999, 999, 999 };
c@131 246 double im[] = { 999, 999, 999, 999 };
c@131 247 FFTReal(4).forward(in, re, im);
c@131 248 BOOST_CHECK_EQUAL(re[0], 0.0);
c@131 249 BOOST_CHECK_EQUAL(re[1], 2.0);
c@131 250 BOOST_CHECK_EQUAL(re[2], 0.0);
c@131 251 BOOST_CHECK_EQUAL(re[3], 2.0);
c@131 252 COMPARE_CONST(im, 0.0);
c@131 253 double back[4];
c@131 254 // check conjugates are reconstructed
c@131 255 re[3] = 999;
c@131 256 im[3] = 999;
c@131 257 FFTReal(4).inverse(re, im, back);
c@131 258 COMPARE_ARRAY(back, in);
c@131 259 }
c@131 260
c@131 261 BOOST_AUTO_TEST_CASE(c_cosine)
c@131 262 {
c@131 263 // Cosine. Output is purely real
c@131 264 double rin[] = { 1, 0, -1, 0 };
c@131 265 double iin[] = { 1, 0, -1, 0 };
c@131 266 double re[] = { 999, 999, 999, 999 };
c@131 267 double im[] = { 999, 999, 999, 999 };
c@131 268 FFT(4).process(false, rin, iin, re, im);
c@131 269 BOOST_CHECK_EQUAL(re[0], 0.0);
c@131 270 BOOST_CHECK_EQUAL(re[1], 2.0);
c@131 271 BOOST_CHECK_EQUAL(re[2], 0.0);
c@131 272 BOOST_CHECK_EQUAL(re[3], 2.0);
c@131 273 BOOST_CHECK_EQUAL(im[0], 0.0);
c@131 274 BOOST_CHECK_EQUAL(im[1], 2.0);
c@131 275 BOOST_CHECK_EQUAL(im[2], 0.0);
c@131 276 BOOST_CHECK_EQUAL(im[3], 2.0);
c@131 277 double back[4];
c@131 278 double backim[4];
c@131 279 FFT(4).process(true, re, im, back, backim);
c@131 280 COMPARE_ARRAY(back, rin);
c@131 281 COMPARE_ARRAY(backim, iin);
c@131 282 }
c@131 283
c@131 284 BOOST_AUTO_TEST_CASE(sineCosine)
c@131 285 {
c@131 286 // Sine and cosine mixed
c@131 287 double in[] = { 0.5, 1, -0.5, -1 };
c@131 288 double re[] = { 999, 999, 999, 999 };
c@131 289 double im[] = { 999, 999, 999, 999 };
c@131 290 FFT(4).process(false, in, 0, re, im);
c@131 291 BOOST_CHECK_EQUAL(re[0], 0.0);
c@131 292 BOOST_CHECK_CLOSE(re[1], 1.0, 1e-12);
c@131 293 BOOST_CHECK_EQUAL(re[2], 0.0);
c@131 294 BOOST_CHECK_CLOSE(re[3], 1.0, 1e-12);
c@131 295 BOOST_CHECK_EQUAL(im[0], 0.0);
c@131 296 BOOST_CHECK_CLOSE(im[1], -2.0, 1e-12);
c@131 297 BOOST_CHECK_EQUAL(im[2], 0.0);
c@131 298 BOOST_CHECK_CLOSE(im[3], 2.0, 1e-12);
c@131 299 double back[4];
c@131 300 double backim[4];
c@131 301 FFT(4).process(true, re, im, back, backim);
c@131 302 COMPARE_ARRAY(back, in);
c@131 303 COMPARE_CONST(backim, 0.0);
c@131 304 }
c@131 305
c@131 306 BOOST_AUTO_TEST_CASE(r_sineCosine)
c@131 307 {
c@131 308 // Sine and cosine mixed
c@131 309 double in[] = { 0.5, 1, -0.5, -1 };
c@131 310 double re[] = { 999, 999, 999, 999 };
c@131 311 double im[] = { 999, 999, 999, 999 };
c@131 312 FFTReal(4).forward(in, re, im);
c@131 313 BOOST_CHECK_EQUAL(re[0], 0.0);
c@131 314 BOOST_CHECK_CLOSE(re[1], 1.0, 1e-12);
c@131 315 BOOST_CHECK_EQUAL(re[2], 0.0);
c@131 316 BOOST_CHECK_CLOSE(re[3], 1.0, 1e-12);
c@131 317 BOOST_CHECK_EQUAL(im[0], 0.0);
c@131 318 BOOST_CHECK_CLOSE(im[1], -2.0, 1e-12);
c@131 319 BOOST_CHECK_EQUAL(im[2], 0.0);
c@131 320 BOOST_CHECK_CLOSE(im[3], 2.0, 1e-12);
c@131 321 double back[4];
c@131 322 // check conjugates are reconstructed
c@131 323 re[3] = 999;
c@131 324 im[3] = 999;
c@131 325 FFTReal(4).inverse(re, im, back);
c@131 326 COMPARE_ARRAY(back, in);
c@131 327 }
c@131 328
c@131 329 BOOST_AUTO_TEST_CASE(c_sineCosine)
c@131 330 {
c@131 331 double rin[] = { 1, 0, -1, 0 };
c@131 332 double iin[] = { 0, 1, 0, -1 };
c@131 333 double re[] = { 999, 999, 999, 999 };
c@131 334 double im[] = { 999, 999, 999, 999 };
c@131 335 FFT(4).process(false, rin, iin, re, im);
c@131 336 BOOST_CHECK_EQUAL(re[0], 0.0);
c@131 337 BOOST_CHECK_EQUAL(re[1], 4.0);
c@131 338 BOOST_CHECK_EQUAL(re[2], 0.0);
c@131 339 BOOST_CHECK_EQUAL(re[3], 0.0);
c@131 340 COMPARE_CONST(im, 0.0);
c@131 341 double back[4];
c@131 342 double backim[4];
c@131 343 FFT(4).process(true, re, im, back, backim);
c@131 344 COMPARE_ARRAY(back, rin);
c@131 345 COMPARE_ARRAY(backim, iin);
c@131 346 }
c@131 347
c@131 348 BOOST_AUTO_TEST_CASE(nyquist)
c@131 349 {
c@131 350 double in[] = { 1, -1, 1, -1 };
c@131 351 double re[] = { 999, 999, 999, 999 };
c@131 352 double im[] = { 999, 999, 999, 999 };
c@131 353 FFT(4).process(false, in, 0, re, im);
c@131 354 BOOST_CHECK_EQUAL(re[0], 0.0);
c@131 355 BOOST_CHECK_EQUAL(re[1], 0.0);
c@131 356 BOOST_CHECK_EQUAL(re[2], 4.0);
c@131 357 BOOST_CHECK_EQUAL(re[3], 0.0);
c@131 358 COMPARE_CONST(im, 0.0);
c@131 359 double back[4];
c@131 360 double backim[4];
c@131 361 FFT(4).process(true, re, im, back, backim);
c@131 362 COMPARE_ARRAY(back, in);
c@131 363 COMPARE_CONST(backim, 0.0);
c@131 364 }
c@131 365
c@131 366 BOOST_AUTO_TEST_CASE(r_nyquist)
c@131 367 {
c@131 368 double in[] = { 1, -1, 1, -1 };
c@131 369 double re[] = { 999, 999, 999, 999 };
c@131 370 double im[] = { 999, 999, 999, 999 };
c@131 371 FFTReal(4).forward(in, re, im);
c@131 372 BOOST_CHECK_EQUAL(re[0], 0.0);
c@131 373 BOOST_CHECK_EQUAL(re[1], 0.0);
c@131 374 BOOST_CHECK_EQUAL(re[2], 4.0);
c@131 375 BOOST_CHECK_EQUAL(re[3], 0.0);
c@131 376 COMPARE_CONST(im, 0.0);
c@131 377 double back[4];
c@131 378 // check conjugates are reconstructed
c@131 379 re[3] = 999;
c@131 380 im[3] = 999;
c@131 381 FFTReal(4).inverse(re, im, back);
c@131 382 COMPARE_ARRAY(back, in);
c@131 383 }
c@131 384
c@131 385 BOOST_AUTO_TEST_CASE(dirac)
c@131 386 {
c@131 387 double in[] = { 1, 0, 0, 0 };
c@131 388 double re[] = { 999, 999, 999, 999 };
c@131 389 double im[] = { 999, 999, 999, 999 };
c@131 390 FFT(4).process(false, in, 0, re, im);
c@131 391 BOOST_CHECK_EQUAL(re[0], 1.0);
c@131 392 BOOST_CHECK_EQUAL(re[1], 1.0);
c@131 393 BOOST_CHECK_EQUAL(re[2], 1.0);
c@131 394 BOOST_CHECK_EQUAL(re[3], 1.0);
c@131 395 COMPARE_CONST(im, 0.0);
c@131 396 double back[4];
c@131 397 double backim[4];
c@131 398 FFT(4).process(true, re, im, back, backim);
c@131 399 COMPARE_ARRAY(back, in);
c@131 400 COMPARE_CONST(backim, 0.0);
c@131 401 }
c@131 402
c@131 403 BOOST_AUTO_TEST_CASE(r_dirac)
c@131 404 {
c@131 405 double in[] = { 1, 0, 0, 0 };
c@131 406 double re[] = { 999, 999, 999, 999 };
c@131 407 double im[] = { 999, 999, 999, 999 };
c@131 408 FFTReal(4).forward(in, re, im);
c@131 409 BOOST_CHECK_EQUAL(re[0], 1.0);
c@131 410 BOOST_CHECK_EQUAL(re[1], 1.0);
c@131 411 BOOST_CHECK_EQUAL(re[2], 1.0);
c@131 412 BOOST_CHECK_EQUAL(re[3], 1.0);
c@131 413 COMPARE_CONST(im, 0.0);
c@131 414 double back[4];
c@131 415 // check conjugates are reconstructed
c@131 416 re[3] = 999;
c@131 417 im[3] = 999;
c@131 418 FFTReal(4).inverse(re, im, back);
c@131 419 COMPARE_ARRAY(back, in);
c@131 420 }
c@131 421
c@131 422 BOOST_AUTO_TEST_CASE(sizes)
c@131 423 {
c@131 424 // Complex supports any size. A single test with an odd size
c@131 425 // will do here, without getting too much into our expectations
c@131 426 // about supported butterflies etc
c@131 427
c@131 428 double in[] = { 1, 1, 1 };
c@131 429 double re[] = { 999, 999, 999 };
c@131 430 double im[] = { 999, 999, 999 };
c@131 431 FFT(3).process(false, in, 0, re, im);
c@131 432 BOOST_CHECK_EQUAL(re[0], 3.0);
c@131 433 BOOST_CHECK_EQUAL(re[1], 0.0);
c@131 434 BOOST_CHECK_EQUAL(re[2], 0.0);
c@131 435 COMPARE_CONST(im, 0.0);
c@131 436 double back[3];
c@131 437 double backim[3];
c@131 438 FFT(3).process(true, re, im, back, backim);
c@131 439 COMPARE_ARRAY(back, in);
c@131 440 COMPARE_CONST(backim, 0.0);
c@131 441 }
c@131 442
c@131 443 BOOST_AUTO_TEST_CASE(r_sizes)
c@131 444 {
c@131 445 // Real supports any even size, but not odd ones
c@131 446
c@131 447 BOOST_CHECK_THROW(FFTReal r(3), std::invalid_argument);
c@131 448
c@131 449 double in[] = { 1, 1, 1, 1, 1, 1 };
c@131 450 double re[] = { 999, 999, 999, 999, 999, 999 };
c@131 451 double im[] = { 999, 999, 999, 999, 999, 999 };
c@131 452 FFTReal(6).forward(in, re, im);
c@131 453 BOOST_CHECK_EQUAL(re[0], 6.0);
c@131 454 BOOST_CHECK_EQUAL(re[1], 0.0);
c@131 455 BOOST_CHECK_EQUAL(re[2], 0.0);
c@131 456 BOOST_CHECK_EQUAL(re[3], 0.0);
c@131 457 BOOST_CHECK_EQUAL(re[4], 0.0);
c@131 458 BOOST_CHECK_EQUAL(re[5], 0.0);
c@131 459 COMPARE_CONST(im, 0.0);
c@131 460 double back[6];
c@131 461 FFTReal(6).inverse(re, im, back);
c@131 462 COMPARE_ARRAY(back, in);
c@131 463 }
c@131 464
c@131 465 BOOST_AUTO_TEST_SUITE_END()
c@131 466