comparison src/vector.c @ 113:72a9a393d5bd

- Fixed bugs in xtract_flatness(), or at least added necessary
documentation and error checking to avoid problems
- Added xtract_is_denormal() helper function and XTRACT_DENORMAL_FOUND
return code
- Replaced all instances of log, sqrt, exp etc. with respective
floating point counterparts (logf etc.)
- Added check for architecture endianness to configure script
- Bug fix to PD example, now no longer crashes if no arguments are
given
- Minor documentation updates

 	else
 	    return (float)((int)f);
     }
 #endif
 
+#ifndef powf
+    #define powf pow
+#endif
+
+#ifndef expf
+    #define expf exp
+#endif
+
+#ifndef sqrtf
+    #define sqrtf sqrt
+#endif
+
+#ifndef fabsf
+    #define fabsf fabs
+#endif
+
 #ifdef XTRACT_FFT
 
 #include <fftw3.h>
 #include "xtract_globals_private.h"
 #include "xtract_macros_private.h"
 
 int xtract_spectrum(const float *data, const int N, const void *argv, float *result){
 
-    float *input, *rfft, q, temp, max;
+    float *input, *rfft, q, temp, max, NxN;
     size_t bytes;
     int n,
         m,
-        NxN, 
         M, 
         vector, 
         withDC, 
         argc,
         normalise;

 
 	case XTRACT_LOG_MAGNITUDE_SPECTRUM:
 	    for(n = 1; n < M; n++){
 		if ((temp = XTRACT_SQ(rfft[n]) + 
 			    XTRACT_SQ(rfft[N - n])) > XTRACT_LOG_LIMIT)
-		    temp = log(sqrt(temp) / N);
+		    temp = logf(sqrtf(temp) / (float)N);
 		else
 		    temp = XTRACT_LOG_LIMIT_DB;
 
                 if(withDC){
                     m = n;

 
 	case XTRACT_LOG_POWER_SPECTRUM:
 	    for(n = 1; n < M; n++){
 		if ((temp = XTRACT_SQ(rfft[n]) + XTRACT_SQ(rfft[N - n])) > 
 			XTRACT_LOG_LIMIT)
-		    temp = log(temp / NxN);
+		    temp = logf(temp / NxN);
 		else
 		    temp = XTRACT_LOG_LIMIT_DB; 		
 
                 if(withDC){
                     m = n;

                 else{
                     m = n - 1;
 		    result[M + m] = n * q;
                 }
 
-                result[m] = sqrt(XTRACT_SQ(rfft[n]) + 
-                        XTRACT_SQ(rfft[N - n])) / N; 
+                result[m] = sqrtf(XTRACT_SQ(rfft[n]) + 
+                        XTRACT_SQ(rfft[N - n])) / (float)N; 
                 max = result[m] > max ? result[m] : max;
 	    }
 	    break;
     }
     

     for(filter = 0; filter < f->n_filters; filter++){
         result[filter] = 0.f;
         for(n = 0; n < N; n++){
             result[filter] += data[n] * f->filters[filter][n];
         }
-        result[filter] = log(result[filter] < XTRACT_LOG_LIMIT ? XTRACT_LOG_LIMIT : result[filter]);
+        result[filter] = logf(result[filter] < XTRACT_LOG_LIMIT ? XTRACT_LOG_LIMIT : result[filter]);
     }
 
     xtract_dct(result, f->n_filters, NULL, result);
     
     return XTRACT_SUCCESS;

     int n = N, i;
     
     float md, temp;
 
     while(n--){
-       md = 0;
+       md = 0.f;
         for(i = 0; i < N - n; i++){
             temp = data[i] - data[i + n];
 			temp = (temp < 0 ? -temp : temp);
 			md += temp;
         }
-        result[n] = md / N;
+        result[n] = md / (float)N;
     }
 
     return XTRACT_SUCCESS;
 }
 

     int n = N, i;
     
     float sd;
 
     while(n--){
-       sd = 0;
+       sd = 0.f;
         for(i = 0; i < N - n; i++){
             /*sd = 1;*/
             sd += XTRACT_SQ(data[i] - data[i + n]);
         }
-        result[n] = sd / N;
+        result[n] = sd / (float)N;
     }
 
     return XTRACT_SUCCESS;
 }
 

     k = N; /* The length of *data */
     L = N - 1; /* The number of LPC coefficients */
     M = L * 2; /* The length of *result */
     ref = result;
     lpc = result+L;
-/*
+
     if(error == 0.0){
-        for(i = 0; i < M; i++)
-            result[i] = 0.f;
+        memset(result, 0, M * sizeof(float));
         return XTRACT_NO_RESULT;
     }
-*/
+
     memset(result, 0, M * sizeof(float));
 
     for (i = 0; i < L; i++) {
 
         /* Sum up this iteration's reflection coefficient. */