Match existing type usage better.

webrtc/modules/audio_processing/ns/ns_core.c

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 880 matching lines @@
                 float* imag,
                 float* magn) {
   int i;
 
   assert(magnitude_length == time_data_length / 2 + 1);
 
   WebRtc_rdft(time_data_length, 1, time_data, self->ip, self->wfft);
 
   imag[0] = 0;
   real[0] = time_data[0];
-  magn[0] = fabs(real[0]) + 1.f;
+  magn[0] = fabsf(real[0]) + 1.f;
   imag[magnitude_length - 1] = 0;
   real[magnitude_length - 1] = time_data[1];
-  magn[magnitude_length - 1] = fabs(real[magnitude_length - 1]) + 1.f;
+  magn[magnitude_length - 1] = fabsf(real[magnitude_length - 1]) + 1.f;
   for (i = 1; i < magnitude_length - 1; ++i) {
     real[i] = time_data[2 * i];
     imag[i] = time_data[2 * i + 1];
     // Magnitude spectrum.
     magn[i] = sqrtf(real[i] * real[i] + imag[i] * imag[i]) + 1.f;
   }
 }
 
 // Transforms the signal from frequency to time domain.
 // Inputs:
@@ skipping 168 matching lines @@
 
   self->blockInd++;  // Update the block index only when we process a block.
 
   FFT(self, winData, self->anaLen, self->magnLen, real, imag, magn);
 
   for (i = 0; i < self->magnLen; i++) {
     signalEnergy += real[i] * real[i] + imag[i] * imag[i];
     sumMagn += magn[i];
     if (self->blockInd < END_STARTUP_SHORT) {
       if (i >= kStartBand) {
-        tmpFloat2 = log((float)i);
+        tmpFloat2 = logf((float)i);
         sum_log_i += tmpFloat2;
         sum_log_i_square += tmpFloat2 * tmpFloat2;
-        tmpFloat1 = log(magn[i]);
+        tmpFloat1 = logf(magn[i]);
         sum_log_magn += tmpFloat1;
         sum_log_i_log_magn += tmpFloat2 * tmpFloat1;
       }
     }
   }
   signalEnergy = signalEnergy / ((float)self->magnLen);
   self->signalEnergy = signalEnergy;
   self->sumMagn = sumMagn;
 
   // Quantile noise estimate.
@@ skipping 22 matching lines @@
     }
     if (tmpFloat3 > 1.f) {
       tmpFloat3 = 1.f;
     }
     self->pinkNoiseExp += tmpFloat3;
 
     // Calculate frequency independent parts of parametric noise estimate.
     if (self->pinkNoiseExp > 0.f) {
       // Use pink noise estimate.
       parametric_num =
-          exp(self->pinkNoiseNumerator / (float)(self->blockInd + 1));
+          expf(self->pinkNoiseNumerator / (float)(self->blockInd + 1));
       parametric_num *= (float)(self->blockInd + 1);
       parametric_exp = self->pinkNoiseExp / (float)(self->blockInd + 1);
     }
     for (i = 0; i < self->magnLen; i++) {
       // Estimate the background noise using the white and pink noise
       // parameters.
       if (self->pinkNoiseExp == 0.f) {
         // Use white noise estimate.
         self->parametricNoise[i] = self->whiteNoiseLevel;
       } else {
         // Use pink noise estimate.
         float use_band = (float)(i < kStartBand ? kStartBand : i);
         self->parametricNoise[i] =
-            parametric_num / pow(use_band, parametric_exp);
+            parametric_num / powf(use_band, parametric_exp);
       }
       // Weight quantile noise with modeled noise.
       noise[i] *= (self->blockInd);
       tmpFloat2 =
           self->parametricNoise[i] * (END_STARTUP_SHORT - self->blockInd);
       noise[i] += (tmpFloat2 / (float)(self->blockInd + 1));
       noise[i] /= END_STARTUP_SHORT;
     }
   }
   // Compute average signal during END_STARTUP_LONG time:
@@ skipping 242 matching lines @@
     for (i = 0; i < num_high_bands; ++i) {
       for (j = 0; j < self->blockLen; j++) {
         outFrameHB[i][j] =
             WEBRTC_SPL_SAT(WEBRTC_SPL_WORD16_MAX,
                            gainTimeDomainHB * self->dataBufHB[i][j],
                            WEBRTC_SPL_WORD16_MIN);
       }
     }
   }  // End of H band gain computation.
 }