comparison maths/MathUtilities.cpp @ 477:fa407c1d9923

Untabify + indent

 void MathUtilities::getAlphaNorm(const double *data, int len, int alpha, double* ANorm)
 {
     int i;
     double temp = 0.0;
     double a=0.0;
-	
-    for( i = 0; i < len; i++)
-    {
-	temp = data[ i ];
-		
-	a  += ::pow( fabs(temp), double(alpha) );
+        
+    for( i = 0; i < len; i++) {
+        temp = data[ i ];
+        a  += ::pow( fabs(temp), double(alpha) );
     }
     a /= ( double )len;
     a = ::pow( a, ( 1.0 / (double) alpha ) );
 
     *ANorm = a;

 {
     int i;
     int len = data.size();
     double temp = 0.0;
     double a=0.0;
-	
-    for( i = 0; i < len; i++)
-    {
-	temp = data[ i ];
-	a  += ::pow( fabs(temp), double(alpha) );
+        
+    for( i = 0; i < len; i++) {
+        temp = data[ i ];
+        a  += ::pow( fabs(temp), double(alpha) );
     }
     a /= ( double )len;
     a = ::pow( a, ( 1.0 / (double) alpha ) );
 
     return a;

 double MathUtilities::sum(const double *src, int len)
 {
     int i ;
     double retVal =0.0;
 
-    for(  i = 0; i < len; i++)
-    {
-	retVal += src[ i ];
+    for(  i = 0; i < len; i++) {
+        retVal += src[ i ];
     }
 
     return retVal;
 }
 

     double retVal =0.0;
 
     if (len == 0) return 0;
 
     double s = sum( src, len );
-	
+        
     retVal =  s  / (double)len;
 
     return retVal;
 }
 
 double MathUtilities::mean(const vector<double> &src,
                            int start,
                            int count)
 {
     double sum = 0.;
-	
+        
     if (count == 0) return 0;
     
-    for (int i = 0; i < (int)count; ++i)
-    {
+    for (int i = 0; i < (int)count; ++i) {
         sum += src[start + i];
     }
 
     return sum / count;
 }

 
     if (len == 0) {
         *min = *max = 0;
         return;
     }
-	
+        
     *min = data[0];
     *max = data[0];
 
-    for( i = 0; i < len; i++)
-    {
-	temp = data[ i ];
-
-	if( temp < *min )
-	{
-	    *min =  temp ;
-	}
-	if( temp > *max )
-	{
-	    *max =  temp ;
-	}
-		
+    for( i = 0; i < len; i++) {
+        temp = data[ i ];
+
+        if( temp < *min ) {
+            *min =  temp ;
+        }
+        if( temp > *max ) {
+            *max =  temp ;
+        }
     }
 }
 
 int MathUtilities::getMax( double* pData, int Length, double* pMax )
 {
-	int index = 0;
-	int i;
-	double temp = 0.0;
-	
-	double max = pData[0];
-
-	for( i = 0; i < Length; i++)
-	{
-		temp = pData[ i ];
-
-		if( temp > max )
-		{
-			max =  temp ;
-			index = i;
-		}
-		
-   	}
-
-	if (pMax) *pMax = max;
-
-
-	return index;
+    int index = 0;
+    int i;
+    double temp = 0.0;
+        
+    double max = pData[0];
+
+    for( i = 0; i < Length; i++) {
+        temp = pData[ i ];
+
+        if( temp > max ) {
+            max =  temp ;
+            index = i;
+        }
+    }
+
+    if (pMax) *pMax = max;
+
+
+    return index;
 }
 
 int MathUtilities::getMax( const vector<double> & data, double* pMax )
 {
-	int index = 0;
-	int i;
-	double temp = 0.0;
-	
-	double max = data[0];
-
-	for( i = 0; i < int(data.size()); i++)
-	{
-		temp = data[ i ];
-
-		if( temp > max )
-		{
-			max =  temp ;
-			index = i;
-		}
-		
-   	}
-
-	if (pMax) *pMax = max;
-
-
-	return index;
+    int index = 0;
+    int i;
+    double temp = 0.0;
+        
+    double max = data[0];
+
+    for( i = 0; i < int(data.size()); i++) {
+
+        temp = data[ i ];
+
+        if( temp > max ) {
+            max =  temp ;
+            index = i;
+        }
+    }
+
+    if (pMax) *pMax = max;
+
+
+    return index;
 }
 
 void MathUtilities::circShift( double* pData, int length, int shift)
 {
-	shift = shift % length;
-	double temp;
-	int i,n;
-
-	for( i = 0; i < shift; i++)
-	{
-		temp=*(pData + length - 1);
-
-		for( n = length-2; n >= 0; n--)
-		{
-			*(pData+n+1)=*(pData+n);
-		}
+    shift = shift % length;
+    double temp;
+    int i,n;
+
+    for( i = 0; i < shift; i++) {
+        
+        temp=*(pData + length - 1);
+
+        for( n = length-2; n >= 0; n--) {
+            *(pData+n+1)=*(pData+n);
+        }
 
         *pData = temp;
     }
 }
 
 int MathUtilities::compareInt (const void * a, const void * b)
 {
-  return ( *(int*)a - *(int*)b );
+    return ( *(int*)a - *(int*)b );
 }
 
 void MathUtilities::normalise(double *data, int length, NormaliseType type)
 {
     switch (type) {

     }
     return pow(tot, 1.0 / p);
 }
 
 vector<double> MathUtilities::normaliseLp(const vector<double> &data,
-                                               int p,
-                                               double threshold)
+                                          int p,
+                                          double threshold)
 {
     int n = int(data.size());
     if (n == 0 || p == 0) return data;
     double norm = getLpNorm(data, p);
     if (norm < threshold) {

 {
     int sz = int(data.size());
     if (sz == 0) return;
 
     vector<double> smoothed(sz);
-	
+        
     int p_pre = 8;
     int p_post = 7;
 
     for (int i = 0; i < sz; ++i) {
 

 
 int
 MathUtilities::nearestPowerOfTwo(int x)
 {
     if (isPowerOfTwo(x)) return x;
-    int n0 = previousPowerOfTwo(x), n1 = nextPowerOfTwo(x);
+    int n0 = previousPowerOfTwo(x);
+    int n1 = nextPowerOfTwo(x);
     if (x - n0 < n1 - x) return n0;
     else return n1;
 }
 
 double
 MathUtilities::factorial(int x)
 {
     if (x < 0) return 0;
     double f = 1;
     for (int i = 1; i <= x; ++i) {
-	f = f * i;
+        f = f * i;
     }
     return f;
 }
 
 int