# HG changeset patch
# User Chris Cannam <cannam@all-day-breakfast.com>
# Date 1559726508 -3600
# Node ID 12b5a9244bb0f4ed8270e0f1a1b418579e003de1
# Parent  8a8693f38b91939ab0df89d611874429d18933ae
Style fixes: avoid unsigned, fix formatting

diff -r 8a8693f38b91 -r 12b5a9244bb0 dsp/rateconversion/Decimator.cpp
--- a/dsp/rateconversion/Decimator.cpp	Mon Jun 03 14:32:24 2019 +0100
+++ b/dsp/rateconversion/Decimator.cpp	Wed Jun 05 10:21:48 2019 +0100
@@ -203,7 +203,7 @@
         
     doAntiAlias( src, decBuffer, m_inputLength );
 
-    unsigned idx = 0;
+    int idx = 0;
 
     for (int i = 0; i < m_outputLength; i++ ) {
         dst[ idx++ ] = decBuffer[ m_decFactor * i ];
diff -r 8a8693f38b91 -r 12b5a9244bb0 dsp/tempotracking/DownBeat.cpp
--- a/dsp/tempotracking/DownBeat.cpp	Mon Jun 03 14:32:24 2019 +0100
+++ b/dsp/tempotracking/DownBeat.cpp	Wed Jun 05 10:21:48 2019 +0100
@@ -246,9 +246,9 @@
 {
     // JENSEN-SHANNON DIVERGENCE BETWEEN SPECTRAL FRAMES
 
-    unsigned int SPECSIZE = 512;   // ONLY LOOK AT FIRST 512 SAMPLES OF SPECTRUM. 
-    if (SPECSIZE > oldspec.size()/4) {
-        SPECSIZE = oldspec.size()/4;
+    int SPECSIZE = 512;   // ONLY LOOK AT FIRST 512 SAMPLES OF SPECTRUM. 
+    if (SPECSIZE > int(oldspec.size())/4) {
+        SPECSIZE = int(oldspec.size())/4;
     }
     double SD = 0.;
     double sd1 = 0.;
@@ -256,7 +256,7 @@
     double sumnew = 0.;
     double sumold = 0.;
   
-    for (unsigned int i = 0;i < SPECSIZE;i++) {
+    for (int i = 0;i < SPECSIZE;i++) {
         
         newspec[i] +=EPS;
         oldspec[i] +=EPS;
@@ -265,7 +265,7 @@
         sumold+=oldspec[i];
     } 
     
-    for (unsigned int i = 0;i < SPECSIZE;i++) {
+    for (int i = 0;i < SPECSIZE;i++) {
         
         newspec[i] /= (sumnew);
         oldspec[i] /= (sumold);
diff -r 8a8693f38b91 -r 12b5a9244bb0 dsp/tempotracking/TempoTrackV2.cpp
--- a/dsp/tempotracking/TempoTrackV2.cpp	Mon Jun 03 14:32:24 2019 +0100
+++ b/dsp/tempotracking/TempoTrackV2.cpp	Wed Jun 05 10:21:48 2019 +0100
@@ -34,9 +34,11 @@
 void
 TempoTrackV2::filter_df(d_vec_t &df)
 {
+    int df_len = int(df.size());
+    
     d_vec_t a(3);
     d_vec_t b(3);
-    d_vec_t lp_df(df.size());
+    d_vec_t lp_df(df_len);
 
     //equivalent in matlab to [b,a] = butter(2,0.4);
     a[0] = 1.0000;
@@ -53,7 +55,7 @@
 
 
     // forwards filtering
-    for (unsigned int i = 0;i < df.size();i++) {
+    for (int i = 0; i < df_len; i++) {
         lp_df[i] =  b[0]*df[i] + b[1]*inp1 + b[2]*inp2 - a[1]*out1 - a[2]*out2;
         inp2 = inp1;
         inp1 = df[i];
@@ -63,11 +65,11 @@
 
     // copy forwards filtering to df...
     // but, time-reversed, ready for backwards filtering
-    for (unsigned int i = 0;i < df.size();i++) {
-        df[i] = lp_df[df.size()-i-1];
+    for (int i = 0; i < df_len; i++) {
+        df[i] = lp_df[df_len - i - 1];
     }
 
-    for (unsigned int i = 0;i < df.size();i++) {
+    for (int i = 0; i < df_len; i++) {
         lp_df[i] = 0.;
     }
 
@@ -75,7 +77,7 @@
     out1 = 0.; out2 = 0.;
 
     // backwards filetering on time-reversed df
-    for (unsigned int i = 0;i < df.size();i++) {
+    for (int i = 0; i < df_len; i++) {
         lp_df[i] =  b[0]*df[i] + b[1]*inp1 + b[2]*inp2 - a[1]*out1 - a[2]*out2;
         inp2 = inp1;
         inp1 = df[i];
@@ -84,8 +86,8 @@
     }
 
     // write the re-reversed (i.e. forward) version back to df
-    for (unsigned int i = 0;i < df.size();i++) {
-        df[i] = lp_df[df.size()-i-1];
+    for (int i = 0; i < df_len; i++) {
+        df[i] = lp_df[df_len - i - 1];
     }
 }
 
@@ -108,7 +110,7 @@
     // then call viterbi decoding with weight vector and transition matrix
     // and get best path
 
-    unsigned int wv_len = 128;
+    int wv_len = 128;
 
     // MEPD 28/11/12
     // the default value of inputtempo in the beat tracking plugin is 120
@@ -124,33 +126,34 @@
     // check whether or not to use rayleigh weighting (if constraintempo is false)
     // or use gaussian weighting it (constraintempo is true)
     if (constraintempo) {
-        for (unsigned int i=0; i<wv.size(); i++) {
+        for (int i = 0; i < wv_len; i++) {
             // MEPD 28/11/12
             // do a gaussian weighting instead of rayleigh
-            wv[i] = exp( (-1.*pow((static_cast<double> (i)-rayparam),2.)) / (2.*pow(rayparam/4.,2.)) );
+            wv[i] = exp( (-1.*pow((double(i)-rayparam),2.)) / (2.*pow(rayparam/4.,2.)) );
         }
     } else {
-        for (unsigned int i=0; i<wv.size(); i++) {
+        for (int i = 0; i < wv_len; i++) {
             // MEPD 28/11/12
             // standard rayleigh weighting over periodicities
-            wv[i] = (static_cast<double> (i) / pow(rayparam,2.)) * exp((-1.*pow(-static_cast<double> (i),2.)) / (2.*pow(rayparam,2.)));
+            wv[i] = (double(i) / pow(rayparam,2.)) * exp((-1.*pow(-double(i),2.)) / (2.*pow(rayparam,2.)));
         }
     }
 
     // beat tracking frame size (roughly 6 seconds) and hop (1.5 seconds)
-    unsigned int winlen = 512;
-    unsigned int step = 128;
+    int winlen = 512;
+    int step = 128;
 
     // matrix to store output of comb filter bank, increment column of matrix at each frame
     d_mat_t rcfmat;
     int col_counter = -1;
+    int df_len = int(df.size());
 
     // main loop for beat period calculation
-    for (unsigned int i=0; i+winlen<df.size(); i+=step) {
+    for (int i = 0; i+winlen < df_len; i+=step) {
         
         // get dfframe
         d_vec_t dfframe(winlen);
-        for (unsigned int k=0; k<winlen; k++) {
+        for (int k=0; k < winlen; k++) {
             dfframe[k] = df[i+k];
         }
         // get rcf vector for current frame
@@ -159,7 +162,7 @@
 
         rcfmat.push_back( d_vec_t() ); // adds a new column
         col_counter++;
-        for (unsigned int j=0; j<rcf.size(); j++) {
+        for (int j = 0; j < wv_len; j++) {
             rcfmat[col_counter].push_back( rcf[j] );
         }
     }
@@ -182,25 +185,28 @@
 
     MathUtilities::adaptiveThreshold(dfframe);
 
-    d_vec_t acf(dfframe.size());
+    int dfframe_len = int(dfframe.size());
+    int rcf_len = int(rcf.size());
+    
+    d_vec_t acf(dfframe_len);
 
-    for (unsigned int lag=0; lag<dfframe.size(); lag++) {
+    for (int lag = 0; lag < dfframe_len; lag++) {
         double sum = 0.;
         double tmp = 0.;
 
-        for (unsigned int n=0; n<(dfframe.size()-lag); n++) {
-            tmp = dfframe[n] * dfframe[n+lag];
+        for (int n = 0; n < (dfframe_len - lag); n++) {
+            tmp = dfframe[n] * dfframe[n + lag];
             sum += tmp;
         }
-        acf[lag] = static_cast<double> (sum/ (dfframe.size()-lag));
+        acf[lag] = double(sum/ (dfframe_len - lag));
     }
 
     // now apply comb filtering
     int numelem = 4;
 
-    for (unsigned int i = 2;i < rcf.size();i++) { // max beat period
-        for (int a = 1;a <= numelem;a++) { // number of comb elements
-            for (int b = 1-a;b <= a-1;b++) { // general state using normalisation of comb elements
+    for (int i = 2; i < rcf_len; i++) { // max beat period
+        for (int a = 1; a <= numelem; a++) { // number of comb elements
+            for (int b = 1-a; b <= a-1; b++) { // general state using normalisation of comb elements
                 rcf[i-1] += ( acf[(a*i+b)-1]*wv[i-1] ) / (2.*a-1.);     // calculate value for comb filter row
             }
         }
@@ -210,13 +216,13 @@
     MathUtilities::adaptiveThreshold(rcf);
 
     double rcfsum =0.;
-    for (unsigned int i=0; i<rcf.size(); i++) {
+    for (int i = 0; i < rcf_len; i++) {
         rcf[i] += EPS ;
         rcfsum += rcf[i];
     }
 
     // normalise rcf to sum to unity
-    for (unsigned int i=0; i<rcf.size(); i++) {
+    for (int i = 0; i < rcf_len; i++) {
         rcf[i] /= (rcfsum + EPS);
     }
 }
@@ -226,12 +232,14 @@
 {
     // following Kevin Murphy's Viterbi decoding to get best path of
     // beat periods through rfcmat
-
+    
+    int wv_len = int(wv.size());
+    
     // make transition matrix
     d_mat_t tmat;
-    for (unsigned int i=0;i<wv.size();i++) {
+    for (int i = 0; i < wv_len; i++) {
         tmat.push_back ( d_vec_t() ); // adds a new column
-        for (unsigned int j=0; j<wv.size(); j++) {
+        for (int j = 0; j < wv_len; j++) {
             tmat[i].push_back(0.); // fill with zeros initially
         }
     }
@@ -240,9 +248,9 @@
     // formed of Gaussians on diagonal - implies slow tempo change
     double sigma = 8.;
     // don't want really short beat periods, or really long ones
-    for (unsigned int i=20;i <wv.size()-20; i++) {
-        for (unsigned int j=20; j<wv.size()-20; j++) {
-            double mu = static_cast<double>(i);
+    for (int i = 20; i  < wv_len - 20; i++) {
+        for (int j = 20; j < wv_len - 20; j++) {
+            double mu = double(i);
             tmat[i][j] = exp( (-1.*pow((j-mu),2.)) / (2.*pow(sigma,2.)) );
         }
     }
@@ -252,41 +260,41 @@
 
     d_mat_t delta;
     i_mat_t psi;
-    for (unsigned int i=0;i <rcfmat.size(); i++) {
-        delta.push_back( d_vec_t());
-        psi.push_back( i_vec_t());
-        for (unsigned int j=0; j<rcfmat[i].size(); j++) {
+    for (int i = 0; i < int(rcfmat.size()); i++) {
+        delta.push_back(d_vec_t());
+        psi.push_back(i_vec_t());
+        for (int j = 0; j < int(rcfmat[i].size()); j++) {
             delta[i].push_back(0.); // fill with zeros initially
             psi[i].push_back(0); // fill with zeros initially
         }
     }
 
-    unsigned int T = delta.size();
+    int T = delta.size();
 
     if (T < 2) return; // can't do anything at all meaningful
 
-    unsigned int Q = delta[0].size();
+    int Q = delta[0].size();
 
     // initialize first column of delta
-    for (unsigned int j=0; j<Q; j++) {
+    for (int j = 0; j < Q; j++) {
         delta[0][j] = wv[j] * rcfmat[0][j];
         psi[0][j] = 0;
     }
 
     double deltasum = 0.;
-    for (unsigned int i=0; i<Q; i++) {
+    for (int i = 0; i < Q; i++) {
         deltasum += delta[0][i];
     }
-    for (unsigned int i=0; i<Q; i++) {
+    for (int i = 0; i < Q; i++) {
         delta[0][i] /= (deltasum + EPS);
     }
 
-    for (unsigned int t=1; t<T; t++)
+    for (int t=1; t < T; t++)
     {
         d_vec_t tmp_vec(Q);
 
-        for (unsigned int j=0; j<Q; j++) {
-            for (unsigned int i=0; i<Q; i++) {
+        for (int j = 0; j < Q; j++) {
+            for (int i = 0; i < Q; i++) {
                 tmp_vec[i] = delta[t-1][i] * tmat[j][i];
             }
 
@@ -299,17 +307,17 @@
 
         // normalise current delta column
         double deltasum = 0.;
-        for (unsigned int i=0; i<Q; i++) {
+        for (int i = 0; i < Q; i++) {
             deltasum += delta[t][i];
         }
-        for (unsigned int i=0; i<Q; i++) {
+        for (int i = 0; i < Q; i++) {
             delta[t][i] /= (deltasum + EPS);
         }
     }
 
     i_vec_t bestpath(T);
     d_vec_t tmp_vec(Q);
-    for (unsigned int i=0; i<Q; i++) {
+    for (int i = 0; i < Q; i++) {
         tmp_vec[i] = delta[T-1][i];
     }
 
@@ -317,29 +325,29 @@
     bestpath[T-1] = get_max_ind(tmp_vec);
 
     // backtrace through index of maximum values in psi
-    for (unsigned int t=T-2; t>0 ;t--) {
+    for (int t=T-2; t>0 ;t--) {
         bestpath[t] = psi[t+1][bestpath[t+1]];
     }
 
     // weird but necessary hack -- couldn't get above loop to terminate at t >= 0
     bestpath[0] = psi[1][bestpath[1]];
 
-    unsigned int lastind = 0;
-    for (unsigned int i=0; i<T; i++) {
-        unsigned int step = 128;
-        for (unsigned int j=0; j<step; j++) {
+    int lastind = 0;
+    for (int i = 0; i < T; i++) {
+        int step = 128;
+        for (int j = 0; j < step; j++) {
             lastind = i*step+j;
             beat_period[lastind] = bestpath[i];
         }
 //        std::cerr << "bestpath[" << i << "] = " << bestpath[i] << " (used for beat_periods " << i*step << " to " << i*step+step-1 << ")" << std::endl;
     }
 
-    //fill in the last values...
-    for (unsigned int i=lastind; i<beat_period.size(); i++) {
+    // fill in the last values...
+    for (int i = lastind; i < int(beat_period.size()); i++) {
         beat_period[i] = beat_period[lastind];
     }
 
-    for (unsigned int i = 0; i < beat_period.size(); i++) {
+    for (int i = 0; i < int(beat_period.size()); i++) {
         tempi.push_back((60. * m_rate / m_increment)/beat_period[i]);
     }
 }
@@ -348,7 +356,9 @@
 TempoTrackV2::get_max_val(const d_vec_t &df)
 {
     double maxval = 0.;
-    for (unsigned int i=0; i<df.size(); i++) {
+    int df_len = int(df.size());
+    
+    for (int i = 0; i < df_len; i++) {
         if (maxval < df[i]) {
             maxval = df[i];
         }
@@ -362,7 +372,9 @@
 {
     double maxval = 0.;
     int ind = 0;
-    for (unsigned int i=0; i<df.size(); i++) {
+    int df_len = int(df.size());
+    
+    for (int i = 0; i < df_len; i++) {
         if (maxval < df[i]) {
             maxval = df[i];
             ind = i;
@@ -376,11 +388,13 @@
 TempoTrackV2::normalise_vec(d_vec_t &df)
 {
     double sum = 0.;
-    for (unsigned int i=0; i<df.size(); i++) {
+    int df_len = int(df.size());
+    
+    for (int i = 0; i < df_len; i++) {
         sum += df[i];
     }
 
-    for (unsigned int i=0; i<df.size(); i++) {
+    for (int i = 0; i < df_len; i++) {
         df[i]/= (sum + EPS);
     }
 }
@@ -396,11 +410,13 @@
 {
     if (df.empty() || beat_period.empty()) return;
 
-    d_vec_t cumscore(df.size()); // store cumulative score
-    i_vec_t backlink(df.size()); // backlink (stores best beat locations at each time instant)
-    d_vec_t localscore(df.size()); // localscore, for now this is the same as the detection function
+    int df_len = int(df.size());
 
-    for (unsigned int i=0; i<df.size(); i++) {
+    d_vec_t cumscore(df_len); // store cumulative score
+    i_vec_t backlink(df_len); // backlink (stores best beat locations at each time instant)
+    d_vec_t localscore(df_len); // localscore, for now this is the same as the detection function
+
+    for (int i = 0; i < df_len; i++) {
         localscore[i] = df[i];
         backlink[i] = -1;
     }
@@ -413,24 +429,25 @@
 //    std::cerr << "tightness" << tightness << std::endl;
 
     // main loop
-    for (unsigned int i=0; i<localscore.size(); i++) {
+    for (int i = 0; i < df_len; i++) {
         
         int prange_min = -2*beat_period[i];
         int prange_max = round(-0.5*beat_period[i]);
 
         // transition range
-        d_vec_t txwt (prange_max - prange_min + 1);
-        d_vec_t scorecands (txwt.size());
+        int txwt_len = prange_max - prange_min + 1;
+        d_vec_t txwt (txwt_len);
+        d_vec_t scorecands (txwt_len);
 
-        for (unsigned int j=0;j<txwt.size();j++) {
+        for (int j = 0; j < txwt_len; j++) {
             
-            double mu = static_cast<double> (beat_period[i]);
+            double mu = double(beat_period[i]);
             txwt[j] = exp( -0.5*pow(tightness * log((round(2*mu)-j)/mu),2));
 
             // IF IN THE ALLOWED RANGE, THEN LOOK AT CUMSCORE[I+PRANGE_MIN+J
             // ELSE LEAVE AT DEFAULT VALUE FROM INITIALISATION:  D_VEC_T SCORECANDS (TXWT.SIZE());
 
-            int cscore_ind = i+prange_min+j;
+            int cscore_ind = i + prange_min + j;
             if (cscore_ind >= 0) {
                 scorecands[j] = txwt[j] * cumscore[cscore_ind];
             }
@@ -448,16 +465,16 @@
 
     // STARTING POINT, I.E. LAST BEAT.. PICK A STRONG POINT IN cumscore VECTOR
     d_vec_t tmp_vec;
-    for (unsigned int i=cumscore.size() - beat_period[beat_period.size()-1] ; i<cumscore.size(); i++) {
+    for (int i = df_len - beat_period[beat_period.size()-1] ; i < df_len; i++) {
         tmp_vec.push_back(cumscore[i]);
     }
 
     int startpoint = get_max_ind(tmp_vec) +
-        cumscore.size() - beat_period[beat_period.size()-1] ;
+        df_len - beat_period[beat_period.size()-1] ;
 
     // can happen if no results obtained earlier (e.g. input too short)
-    if (startpoint >= (int)backlink.size()) {
-        startpoint = backlink.size()-1;
+    if (startpoint >= int(backlink.size())) {
+        startpoint = int(backlink.size()) - 1;
     }
 
     // USE BACKLINK TO GET EACH NEW BEAT (TOWARDS THE BEGINNING OF THE FILE)
@@ -473,8 +490,8 @@
     }
 
     // REVERSE SEQUENCE OF IBEATS AND STORE AS BEATS
-    for (unsigned int i=0; i<ibeats.size(); i++) {
-        beats.push_back( static_cast<double>(ibeats[ibeats.size()-i-1]) );
+    for (int i = 0; i < int(ibeats.size()); i++) {
+        beats.push_back(double(ibeats[ibeats.size() - i - 1]));
     }
 }