comparison src/EM.cpp @ 97:840c0d703bbb timing

Use single-precision floats throughout EM code

 
 using std::vector;
 using std::cerr;
 using std::endl;
 
-static double epsilon = 1e-16;
+static float epsilon = 1e-8;
 
 EM::EM() :
     m_noteCount(SILVET_TEMPLATE_NOTE_COUNT),
     m_shiftCount(SILVET_TEMPLATE_MAX_SHIFT * 2 + 1),
     m_binCount(SILVET_TEMPLATE_HEIGHT),

 }
 
 void
 EM::normaliseColumn(V &column)
 {
-    double sum = 0.0;
+    float sum = 0.0;
     for (int i = 0; i < (int)column.size(); ++i) {
         sum += column[i];
     }
     for (int i = 0; i < (int)column.size(); ++i) {
         column[i] /= sum;

         }
     }
 }
 
 void
-EM::iterate(V column)
-{
-    normaliseColumn(column);
-    expectation(column);
-    maximisation(column);
-}
-
-const double *
+EM::iterate(const vector<double> &column)
+{
+    V norm(column.begin(), column.end());
+    normaliseColumn(norm);
+    expectation(norm);
+    maximisation(norm);
+}
+
+const float *
 EM::templateFor(int instrument, int note, int shift)
 {
     return silvet_templates[instrument].data[note] + shift;
 }
 

         m_estimate[i] = epsilon;
     }
 
     for (int i = 0; i < m_instrumentCount; ++i) {
         for (int n = 0; n < m_noteCount; ++n) {
-            const double pitch = m_pitches[n];
-            const double source = m_sources[i][n];
+            const float pitch = m_pitches[n];
+            const float source = m_sources[i][n];
             for (int f = 0; f < m_shiftCount; ++f) {
-                const double *w = templateFor(i, n, f);
-                const double shift = m_shifts[f][n];
-                const double factor = pitch * source * shift;
+                const float *w = templateFor(i, n, f);
+                const float shift = m_shifts[f][n];
+                const float factor = pitch * source * shift;
                 for (int j = 0; j < m_binCount; ++j) {
                     m_estimate[j] += w[j] * factor;
                 }
             }
         }

     Grid newShifts(m_shiftCount, V(m_noteCount, epsilon));
     Grid newSources(m_instrumentCount, V(m_noteCount, epsilon));
 
     for (int n = 0; n < m_noteCount; ++n) {
 
-        const double pitch = m_pitches[n];
+        const float pitch = m_pitches[n];
 
         for (int f = 0; f < m_shiftCount; ++f) {
 
-            const double shift = m_shifts[f][n];
+            const float shift = m_shifts[f][n];
 
             for (int i = 0; i < m_instrumentCount; ++i) {
 
-                const double source = m_sources[i][n];
-                const double factor = pitch * source * shift;
-                const double *w = templateFor(i, n, f);
+                const float source = m_sources[i][n];
+                const float factor = pitch * source * shift;
+                const float *w = templateFor(i, n, f);
 
                 if (n >= m_lowestPitch && n <= m_highestPitch) {
 
                     for (int j = 0; j < m_binCount; ++j) {
                         newPitches[n] += w[j] * m_q[j] * factor;