comparison base/Window.h @ 505:930b5b0f707d

Merge branch 'codestyle-and-tidy'

     published by the Free Software Foundation; either version 2 of the
     License, or (at your option) any later version.  See the file
     COPYING included with this distribution for more information.
 */
 
-#ifndef _WINDOW_H_
-#define _WINDOW_H_
+#ifndef QM_DSP_WINDOW_H
+#define QM_DSP_WINDOW_H
 
 #include <cmath>
 #include <iostream>
 #include <map>
 #include <vector>

      * symmetrical window of size N+1 with the final element missing.)
      */
     Window(WindowType type, int size) : m_type(type), m_size(size) { encache(); }
     Window(const Window &w) : m_type(w.m_type), m_size(w.m_size) { encache(); }
     Window &operator=(const Window &w) {
-	if (&w == this) return *this;
-	m_type = w.m_type;
-	m_size = w.m_size;
-	encache();
-	return *this;
+        if (&w == this) return *this;
+        m_type = w.m_type;
+        m_size = w.m_size;
+        encache();
+        return *this;
     }
     virtual ~Window() { delete[] m_cache; }
     
     void cut(T *src) const { cut(src, src); }
     void cut(const T *src, T *dst) const {
-	for (int i = 0; i < m_size; ++i) dst[i] = src[i] * m_cache[i];
+        for (int i = 0; i < m_size; ++i) {
+            dst[i] = src[i] * m_cache[i];
+        }
     }
 
     WindowType getType() const { return m_type; }
     int getSize() const { return m_size; }
 

     T *mult = new T[n];
     int i;
     for (i = 0; i < n; ++i) mult[i] = 1.0;
 
     switch (m_type) {
-		
+                
     case RectangularWindow:
         for (i = 0; i < n; ++i) {
             mult[i] = mult[i] * 0.5;
-	}
-	break;
-	    
+        }
+        break;
+            
     case BartlettWindow:
         if (n == 2) {
             mult[0] = mult[1] = 0; // "matlab compatible"
         } else if (n == 3) {
             mult[0] = 0;

         } else if (n > 3) {
             for (i = 0; i < n/2; ++i) {
                 mult[i] = mult[i] * (i / T(n/2));
                 mult[i + n - n/2] = mult[i + n - n/2] * (1.0 - (i / T(n/2)));
             }
-	}
-	break;
-	    
+        }
+        break;
+            
     case HammingWindow:
         if (n > 1) {
             for (i = 0; i < n; ++i) {
                 mult[i] = mult[i] * (0.54 - 0.46 * cos(2 * M_PI * i / n));
             }
-	}
-	break;
-	    
+        }
+        break;
+            
     case HanningWindow:
         if (n > 1) {
             for (i = 0; i < n; ++i) {
                 mult[i] = mult[i] * (0.50 - 0.50 * cos(2 * M_PI * i / n));
             }
-	}
-	break;
-	    
+        }
+        break;
+            
     case BlackmanWindow:
         if (n > 1) {
             for (i = 0; i < n; ++i) {
                 mult[i] = mult[i] * (0.42 - 0.50 * cos(2 * M_PI * i / n)
                                      + 0.08 * cos(4 * M_PI * i / n));
             }
-	}
-	break;
-	    
+        }
+        break;
+            
     case BlackmanHarrisWindow:
         if (n > 1) {
             for (i = 0; i < n; ++i) {
                 mult[i] = mult[i] * (0.35875
                                      - 0.48829 * cos(2 * M_PI * i / n)
                                      + 0.14128 * cos(4 * M_PI * i / n)
                                      - 0.01168 * cos(6 * M_PI * i / n));
             }
-	}
-	break;
+        }
+        break;
     }
-	   
+           
     m_cache = mult;
 }
 
 #endif