comparison data/model/test/TestFFTModel.h @ 1450:a12fd0456f0c streaming-csv-writer

Merge from default branch

                     float eRe = expectedValues[ch][i].real();
                     float eIm = expectedValues[ch][i].imag();
                     float thresh = 1e-5f;
                     if (abs(reals[i] - eRe) > thresh ||
                         abs(imags[i] - eIm) > thresh) {
-                        cerr << "ERROR: output is not as expected for column "
+                        SVCERR << "ERROR: output is not as expected for column "
                              << i << " in channel " << ch << " (stepThrough = "
                              << stepThrough << ")" << endl;
-                        cerr << "expected : ";
+                        SVCERR << "expected : ";
                         for (int j = 0; j < hs1; ++j) {
-                            cerr << expectedValues[ch][j] << " ";
+                            SVCERR << expectedValues[ch][j] << " ";
                         }
-                        cerr << "\nactual   : ";
+                        SVCERR << "\nactual   : ";
                         for (int j = 0; j < hs1; ++j) {
-                            cerr << complex<float>(reals[j], imags[j]) << " ";
+                            SVCERR << complex<float>(reals[j], imags[j]) << " ";
                         }
-                        cerr << endl;
+                        SVCERR << endl;
                     }
                     COMPARE_FUZZIER_F(reals[i], eRe);
                     COMPARE_FUZZIER_F(imags[i], eIm);
                 }
                 QCOMPARE(reals[hs1], 999.f);

     // (rather than something with a step in it that is harder to
     // reason about the FFT of) and the results for subsequent columns
     // are those of our expected signal.
     
     void dc_simple_rect() {
-	MockWaveModel mwm({ DC }, 16, 4);
+        MockWaveModel mwm({ DC }, 16, 4);
         test(&mwm, RectangularWindow, 8, 8, 8, 0,
              { { {}, {}, {}, {}, {} } }, 4);
         test(&mwm, RectangularWindow, 8, 8, 8, 1,
              { { { 4.f, 0.f }, {}, {}, {}, {} } }, 4);
         test(&mwm, RectangularWindow, 8, 8, 8, 2,

     }
 
     void dc_simple_hann() {
         // The Hann window function is a simple sinusoid with period
         // equal to twice the window size, and it halves the DC energy
-	MockWaveModel mwm({ DC }, 16, 4);
+        MockWaveModel mwm({ DC }, 16, 4);
         test(&mwm, HanningWindow, 8, 8, 8, 0,
              { { {}, {}, {}, {}, {} } }, 4);
         test(&mwm, HanningWindow, 8, 8, 8, 1,
              { { { 4.f, 0.f }, { 2.f, 0.f }, {}, {}, {} } }, 4);
         test(&mwm, HanningWindow, 8, 8, 8, 2,

         test(&mwm, HanningWindow, 8, 8, 8, 3,
              { { {}, {}, {}, {}, {} } }, 4);
     }
     
     void dc_simple_hann_halfoverlap() {
-	MockWaveModel mwm({ DC }, 16, 4);
+        MockWaveModel mwm({ DC }, 16, 4);
         test(&mwm, HanningWindow, 8, 4, 8, 0,
              { { {}, {}, {}, {}, {} } }, 7);
         test(&mwm, HanningWindow, 8, 4, 8, 2,
              { { { 4.f, 0.f }, { 2.f, 0.f }, {}, {}, {} } }, 7);
         test(&mwm, HanningWindow, 8, 4, 8, 3,

         test(&mwm, HanningWindow, 8, 4, 8, 6,
              { { {}, {}, {}, {}, {} } }, 7);
     }
     
     void sine_simple_rect() {
-	MockWaveModel mwm({ Sine }, 16, 4);
+        MockWaveModel mwm({ Sine }, 16, 4);
         // Sine: output is purely imaginary. Note the sign is flipped
         // (normally the first half of the output would have negative
         // sign for a sine starting at 0) because the model does an
         // FFT shift to centre the phase
         test(&mwm, RectangularWindow, 8, 8, 8, 0,

         test(&mwm, RectangularWindow, 8, 8, 8, 3,
              { { {}, {}, {}, {}, {} } }, 4);
     }
     
     void cosine_simple_rect() {
-	MockWaveModel mwm({ Cosine }, 16, 4);
+        MockWaveModel mwm({ Cosine }, 16, 4);
         // Cosine: output is purely real. Note the sign is flipped
         // because the model does an FFT shift to centre the phase
         test(&mwm, RectangularWindow, 8, 8, 8, 0,
              { { {}, {}, {}, {}, {} } }, 4);
         test(&mwm, RectangularWindow, 8, 8, 8, 1,

         test(&mwm, RectangularWindow, 8, 8, 8, 3,
              { { {}, {}, {}, {}, {} } }, 4);
     }
     
     void twochan_simple_rect() {
-	MockWaveModel mwm({ Sine, Cosine }, 16, 4);
+        MockWaveModel mwm({ Sine, Cosine }, 16, 4);
         // Test that the two channels are read and converted separately
         test(&mwm, RectangularWindow, 8, 8, 8, 0,
              {
                  { {}, {}, {}, {}, {} },
                  { {}, {}, {}, {}, {} }

                  { {}, {}, {}, {}, {} }
              }, 4);
     }
     
     void nyquist_simple_rect() {
-	MockWaveModel mwm({ Nyquist }, 16, 4);
+        MockWaveModel mwm({ Nyquist }, 16, 4);
         // Again, the sign is flipped. This has the same amount of
         // energy as the DC example
         test(&mwm, RectangularWindow, 8, 8, 8, 0,
              { { {}, {}, {}, {}, {} } }, 4);
         test(&mwm, RectangularWindow, 8, 8, 8, 1,

         test(&mwm, RectangularWindow, 8, 8, 8, 3,
              { { {}, {}, {}, {}, {} } }, 4);
     }
     
     void dirac_simple_rect() {
-	MockWaveModel mwm({ Dirac }, 16, 4);
+        MockWaveModel mwm({ Dirac }, 16, 4);
         // The window scales by 0.5 and some signs are flipped. Only
         // column 1 has any data (the single impulse).
         test(&mwm, RectangularWindow, 8, 8, 8, 0,
              { { {}, {}, {}, {}, {} } }, 4);
         test(&mwm, RectangularWindow, 8, 8, 8, 1,

         test(&mwm, RectangularWindow, 8, 8, 8, 3,
              { { {}, {}, {}, {}, {} } }, 4);
     }
     
     void dirac_simple_rect_2() {
-	MockWaveModel mwm({ Dirac }, 16, 8);
+        MockWaveModel mwm({ Dirac }, 16, 8);
         // With 8 samples padding, the FFT shift places the first
         // Dirac impulse at the start of column 1, thus giving all
         // positive values
         test(&mwm, RectangularWindow, 8, 8, 8, 0,
              { { {}, {}, {}, {}, {} } }, 5);

         test(&mwm, RectangularWindow, 8, 8, 8, 4,
              { { {}, {}, {}, {}, {} } }, 5);
     }
 
     void dirac_simple_rect_halfoverlap() {
-	MockWaveModel mwm({ Dirac }, 16, 4);
+        MockWaveModel mwm({ Dirac }, 16, 4);
         test(&mwm, RectangularWindow, 8, 4, 8, 0,
              { { {}, {}, {}, {}, {} } }, 7);
         test(&mwm, RectangularWindow, 8, 4, 8, 1,
              { { { 0.5f, 0.f }, { 0.5f, 0.f }, { 0.5f, 0.f }, { 0.5f, 0.f }, { 0.5f, 0.f } } }, 7);
         test(&mwm, RectangularWindow, 8, 4, 8, 2,