format

src/analysis/pitch_extraction_by_reaper.cc

@@ -84,8 +84,10 @@ bool PitchExtractionByReaper::Get(
   reaper::EpochTracker epoch_tracker;
   epoch_tracker.set_unvoiced_cost(static_cast<float>(voicing_threshold_));
   std::vector<int16_t> integer_waveform(waveform.begin(), waveform.end());
-  if (!epoch_tracker.Init(&(integer_waveform[0]), static_cast<int32_t>(waveform.size()),
-                          static_cast<float>(sampling_rate_), static_cast<float>(lower_f0_), static_cast<float>(upper_f0_), true, false)) {
+  if (!epoch_tracker.Init(
+          &(integer_waveform[0]), static_cast<int32_t>(waveform.size()),
+          static_cast<float>(sampling_rate_), static_cast<float>(lower_f0_),
+          static_cast<float>(upper_f0_), true, false)) {
     return false;
   }
 

src/analysis/pitch_extraction_by_world.cc

@@ -89,12 +89,14 @@ bool PitchExtractionByWorld::Get(
     option.f0_ceil = upper_f0_;
     option.allowed_range = voicing_threshold_;
 
-    const int tmp_length(
-        world::GetSamplesForDIO(static_cast<int>(sampling_rate_), static_cast<int>(waveform.size()), frame_period));
+    const int tmp_length(world::GetSamplesForDIO(
+        static_cast<int>(sampling_rate_), static_cast<int>(waveform.size()),
+        frame_period));
     std::vector<double> time_axis(tmp_length);
     std::vector<double> tmp_f0(tmp_length);
-    world::Dio(&(waveform[0]), static_cast<int>(waveform.size()), static_cast<int>(sampling_rate_), &option,
-               &(time_axis[0]), &(tmp_f0[0]));
+    world::Dio(&(waveform[0]), static_cast<int>(waveform.size()),
+               static_cast<int>(sampling_rate_), &option, &(time_axis[0]),
+               &(tmp_f0[0]));
 
     const int target_length(static_cast<int>(
         std::ceil(static_cast<double>(waveform.size()) / frame_shift_)));

src/compression/uniform_quantization.cc

@@ -87,12 +87,13 @@ bool UniformQuantization::Run(double input, int* output) const {
   int index;
   switch (quantization_type_) {
     case kMidRise: {
-      index = static_cast<int>(std::floor(input * inverse_step_size_) + quantization_levels_ / 2);
+      index = static_cast<int>(std::floor(input * inverse_step_size_) +
+                               quantization_levels_ / 2);
       break;
     }
     case kMidTread: {
       index = static_cast<int>(std::round(input * inverse_step_size_) +
-              (quantization_levels_ - 1) / 2);
+                               (quantization_levels_ - 1) / 2);
       break;
     }
     default: { return false; }

src/conversion/filter_coefficients_to_group_delay.cc

@@ -113,7 +113,8 @@ bool FilterCoefficientsToGroupDelay::Run(
                             &buffer->convolved_coefficients_)) {
     return false;
   }
-  const int coefficients_length(static_cast<int>(buffer->convolved_coefficients_.size()));
+  const int coefficients_length(
+      static_cast<int>(buffer->convolved_coefficients_.size()));
 
   std::copy(buffer->convolved_coefficients_.begin(),
             buffer->convolved_coefficients_.end(), buffer->real_part1_.begin());

src/generation/nonrecursive_maximum_likelihood_parameter_generation.cc

@@ -125,7 +125,8 @@ bool NonrecursiveMaximumLikelihoodParameterGeneration::Run(
 
   const int sequence_length(static_cast<int>(variance_vectors.size()));
   std::vector<SymmetricMatrix> covariance_matrices(
-      sequence_length, SymmetricMatrix(static_cast<int>(variance_vectors[0].size())));
+      sequence_length,
+      SymmetricMatrix(static_cast<int>(variance_vectors[0].size())));
   for (int t(0); t < sequence_length; ++t) {
     if (!covariance_matrices[t].SetDiagonal(variance_vectors[t])) {
       return false;

src/generation/recursive_maximum_likelihood_parameter_generation.cc

@@ -92,8 +92,8 @@ RecursiveMaximumLikelihoodParameterGeneration::
 
   for (int i(1); i < calculation_field_; ++i) {
     if (!input_source->Get(&buffer_.static_and_dynamic_parameters)) {
-      const int static_and_dynamic_size(static_cast<int>(
-          buffer_.static_and_dynamic_parameters.size() / 2));
+      const int static_and_dynamic_size(
+          static_cast<int>(buffer_.static_and_dynamic_parameters.size() / 2));
       // Initialize with zero mean.
       std::fill(buffer_.static_and_dynamic_parameters.begin(),
                 buffer_.static_and_dynamic_parameters.begin() +
@@ -119,8 +119,8 @@ bool RecursiveMaximumLikelihoodParameterGeneration::Get(
   }
 
   if (!input_source_->Get(&buffer_.static_and_dynamic_parameters)) {
-    const int static_and_dynamic_size(static_cast<int>(
-        buffer_.static_and_dynamic_parameters.size() / 2));
+    const int static_and_dynamic_size(
+        static_cast<int>(buffer_.static_and_dynamic_parameters.size() / 2));
     // Unobserbed mean is zero.
     std::fill(
         buffer_.static_and_dynamic_parameters.begin(),

src/input/input_source_from_vector.cc

@@ -53,7 +53,8 @@ InputSourceFromVector::InputSourceFromVector(bool zero_padding, int read_size,
                                              std::vector<double>* input_vector)
     : zero_padding_(zero_padding),
       read_size_(read_size),
-      vector_size_(NULL == input_vector ? 0 : static_cast<int>(input_vector->size())),
+      vector_size_(
+          NULL == input_vector ? 0 : static_cast<int>(input_vector->size())),
       input_vector_(input_vector),
       position_(0),
       is_valid_(true) {

src/math/dynamic_time_warping.cc

@@ -143,7 +143,8 @@ bool DynamicTimeWarping::Run(
 
   const int num_candidate(static_cast<int>(local_path_candidates_.size()));
   const int num_query_vector(static_cast<int>(query_vector_sequence.size()));
-  const int num_reference_vector(static_cast<int>(reference_vector_sequence.size()));
+  const int num_reference_vector(
+      static_cast<int>(reference_vector_sequence.size()));
 
   std::vector<std::vector<Cell> > cell(num_query_vector,
                                        std::vector<Cell>(num_reference_vector));

src/window/standard_window.cc

@@ -65,42 +65,48 @@ void MakeBartlett(bool periodic, std::vector<double>* window) {
 }
 
 void MakeBlackman(bool periodic, std::vector<double>* window) {
-  sptk::CosineWindow maker(static_cast<int>(window->size()), {0.42, 0.5, 0.08}, periodic);
+  sptk::CosineWindow maker(static_cast<int>(window->size()), {0.42, 0.5, 0.08},
+                           periodic);
   *window = maker.Get();
 }
 
 void MakeBlackmanHarris(bool periodic, std::vector<double>* window) {
-  sptk::CosineWindow maker(static_cast<int>(window->size()), {0.35875, 0.48829, 0.14128, 0.01168},
-                           periodic);
+  sptk::CosineWindow maker(static_cast<int>(window->size()),
+                           {0.35875, 0.48829, 0.14128, 0.01168}, periodic);
   *window = maker.Get();
 }
 
 void MakeBlackmanNuttall(bool periodic, std::vector<double>* window) {
-  sptk::CosineWindow maker(
-    static_cast<int>(window->size()), {0.3635819, 0.4891775, 0.1365995, 0.0106411}, periodic);
+  sptk::CosineWindow maker(static_cast<int>(window->size()),
+                           {0.3635819, 0.4891775, 0.1365995, 0.0106411},
+                           periodic);
   *window = maker.Get();
 }
 
 void MakeFlatTop(bool periodic, std::vector<double>* window) {
-  sptk::CosineWindow maker(static_cast<int>(window->size()), {0.21557895, 0.41663158, 0.277263158,
-                                            0.083578947, 0.006947368},
-                           periodic);
+  sptk::CosineWindow maker(
+      static_cast<int>(window->size()),
+      {0.21557895, 0.41663158, 0.277263158, 0.083578947, 0.006947368},
+      periodic);
   *window = maker.Get();
 }
 
 void MakeHamming(bool periodic, std::vector<double>* window) {
-  sptk::CosineWindow maker(static_cast<int>(window->size()), {0.54, 0.46}, periodic);
+  sptk::CosineWindow maker(static_cast<int>(window->size()), {0.54, 0.46},
+                           periodic);
   *window = maker.Get();
 }
 
 void MakeHanning(bool periodic, std::vector<double>* window) {
-  sptk::CosineWindow maker(static_cast<int>(window->size()), {0.5, 0.5}, periodic);
+  sptk::CosineWindow maker(static_cast<int>(window->size()), {0.5, 0.5},
+                           periodic);
   *window = maker.Get();
 }
 
 void MakeNuttall(bool periodic, std::vector<double>* window) {
-  sptk::CosineWindow maker(
-    static_cast<int>(window->size()), {0.3635819, 0.4891775, 0.1365995, 0.0106411}, periodic);
+  sptk::CosineWindow maker(static_cast<int>(window->size()),
+                           {0.3635819, 0.4891775, 0.1365995, 0.0106411},
+                           periodic);
   *window = maker.Get();
 }