suppress warnings [skip ci]

include/SPTK/conversion/filter_coefficients_to_group_delay.h

@@ -165,14 +165,14 @@ class FilterCoefficientsToGroupDelay {
   /**
    * @return Alpha.
    */
-  bool GetAlpha() const {
+  double GetAlpha() const {
     return alpha_;
   }
 
   /**
    * @return Gamma.
    */
-  bool GetGamma() const {
+  double GetGamma() const {
     return gamma_;
   }
 

include/SPTK/generation/delta_calculation.h

@@ -144,8 +144,8 @@ class DeltaCalculation {
   bool is_valid_;
 
   int max_window_width_;
-  std::vector<double> lefts_;
-  std::vector<double> rights_;
+  std::vector<int> lefts_;
+  std::vector<int> rights_;
 
   Buffer buffer_;
 

src/analysis/mel_generalized_cepstral_analysis.cc

@@ -99,7 +99,7 @@ void CoefficientsFrequencyTransform(const std::vector<double>& input,
 void PTransform(double alpha, std::vector<double>* p) {
   if (0.0 == alpha) return;
 
-  const int order(p->size() - 1);
+  const int order(static_cast<int>(p->size()) - 1);
   double* x(&((*p)[0]));
   double d(x[order]);
   for (int k(order); 0 < k; --k) {
@@ -116,7 +116,7 @@ void PTransform(double alpha, std::vector<double>* p) {
 void QTransform(double alpha, std::vector<double>* q) {
   if (0.0 == alpha) return;
 
-  const int order(q->size() - 1);
+  const int order(static_cast<int>(q->size()) - 1);
   double* x(&((*q)[0]));
   double d(x[1]);
   for (int k(1); k <= order; ++k) {

src/analysis/pitch_extraction_by_rapt.cc

@@ -87,8 +87,8 @@ bool PitchExtractionByRapt::Get(
                             &tmp_length)) {
       return false;
     }
-    const int target_length(
-        std::ceil(static_cast<double>(waveform.size()) / frame_shift_));
+    const int target_length(static_cast<int>(
+        std::ceil(static_cast<double>(waveform.size()) / frame_shift_)));
     if (target_length < tmp_length) {
       tmp_length = target_length;
     }

src/analysis/pitch_extraction_by_reaper.cc

@@ -82,10 +82,10 @@ bool PitchExtractionByReaper::Get(
   }
 
   reaper::EpochTracker epoch_tracker;
-  epoch_tracker.set_unvoiced_cost(voicing_threshold_);
+  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]), waveform.size(),
-                          sampling_rate_, lower_f0_, 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;
   }
 
@@ -117,15 +117,15 @@ bool PitchExtractionByReaper::Get(
 
   if (NULL != f0) {
     const float external_frame_interval(static_cast<float>(frame_shift_) /
-                                        sampling_rate_);
+                                        static_cast<float>(sampling_rate_));
     std::vector<float> tmp_f0;
     std::vector<float> correlation;
     if (!epoch_tracker.ResampleAndReturnResults(external_frame_interval,
                                                 &tmp_f0, &correlation)) {
       return false;
     }
-    const int target_length(
-        std::ceil(static_cast<float>(waveform.size()) / frame_shift_));
+    const int target_length(static_cast<int>(
+        std::ceil(static_cast<float>(waveform.size()) / frame_shift_)));
     if (target_length < static_cast<int>(tmp_f0.size())) {
       tmp_f0.resize(target_length);
     }

src/analysis/pitch_extraction_by_swipe.cc

@@ -83,8 +83,8 @@ bool PitchExtractionBySwipe::Get(
     swipe::vector tmp_f0(swipe::swipe(
         waveform, sampling_rate_, lower_f0_, upper_f0_, voicing_threshold_,
         static_cast<double>(frame_shift_) / sampling_rate_));
-    const int target_length(
-        std::ceil(static_cast<double>(waveform.size()) / frame_shift_));
+    const int target_length(static_cast<int>(
+        std::ceil(static_cast<double>(waveform.size()) / frame_shift_)));
     if (target_length < tmp_f0.x) {
       tmp_f0.x = target_length;
     }

src/analysis/pitch_extraction_by_world.cc

@@ -90,14 +90,14 @@ bool PitchExtractionByWorld::Get(
     option.allowed_range = voicing_threshold_;
 
     const int tmp_length(
-        world::GetSamplesForDIO(sampling_rate_, waveform.size(), frame_period));
+        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]), waveform.size(), sampling_rate_, &option,
+    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(
-        std::ceil(static_cast<double>(waveform.size()) / frame_shift_));
+    const int target_length(static_cast<int>(
+        std::ceil(static_cast<double>(waveform.size()) / frame_shift_)));
     if (target_length < tmp_length) {
       tmp_f0.resize(target_length);
     }

src/compression/huffman_encoding.cc

@@ -86,8 +86,8 @@ bool HuffmanEncoding::Run(int input, std::vector<bool>* output) const {
     return false;
   }
 
-  const int output_length(codebook_.at(input).size());
-  if (output->size() != static_cast<std::size_t>(output_length)) {
+  const std::size_t output_length(codebook_.at(input).size());
+  if (output->size() != output_length) {
     output->resize(output_length);
   }
 

src/compression/inverse_vector_quantization.cc

@@ -62,7 +62,7 @@ bool InverseVectorQuantization::Run(
     const std::vector<std::vector<double> >& codebook_vectors,
     std::vector<double>* reconstructed_vector) const {
   // Check inputs.
-  const int codebook_size(codebook_vectors.size());
+  const int codebook_size(static_cast<int>(codebook_vectors.size()));
   if (!is_valid_ || codebook_index < 0 || codebook_size <= codebook_index ||
       NULL == reconstructed_vector) {
     return false;

src/compression/linde_buzo_gray_algorithm.cc

@@ -85,7 +85,7 @@ bool LindeBuzoGrayAlgorithm::Run(
     std::vector<std::vector<double> >* codebook_vectors,
     std::vector<int>* codebook_indices) const {
   // Check inputs.
-  const int num_input_vector(input_vectors.size());
+  const int num_input_vector(static_cast<int>(input_vectors.size()));
   if (!is_valid_ ||
       num_input_vector < min_num_vector_in_cluster_ * target_codebook_size_ ||
       NULL == codebook_vectors || NULL == codebook_indices ||

src/compression/uniform_quantization.cc

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

src/compression/vector_quantization.cc

@@ -65,7 +65,7 @@ bool VectorQuantization::Run(
     const std::vector<std::vector<double> >& codebook_vectors,
     int* codebook_index) const {
   // Check inputs.
-  const int codebook_size(codebook_vectors.size());
+  const int codebook_size(static_cast<int>(codebook_vectors.size()));
   if (!is_valid_ ||
       input_vector.size() != static_cast<std::size_t>(num_order_ + 1) ||
       0 == codebook_size || NULL == codebook_index) {

src/conversion/autocorrelation_to_composite_sinusoidal_modeling.cc

@@ -52,7 +52,7 @@ namespace {
 
 uint64_t CalculateBinomialCoefficient(int n, int k) {
   if (0 == k || n == k) {
-    return 1.0;
+    return 1;
   }
 
   std::vector<uint64_t> buffer(n);

src/conversion/filter_coefficients_to_group_delay.cc

@@ -113,7 +113,7 @@ bool FilterCoefficientsToGroupDelay::Run(
                             &buffer->convolved_coefficients_)) {
     return false;
   }
-  const int coefficients_length(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/conversion/linear_predictive_coefficients_to_line_spectral_pairs.cc

@@ -54,7 +54,7 @@ double CalculateChebyshevPolynomial(const std::vector<double>& coefficients,
   const double* c(&coefficients[0]);
   double b2(0.0);
   double b1(0.0);
-  for (int i(coefficients.size() - 1); 0 < i; --i) {
+  for (int i(static_cast<int>(coefficients.size()) - 1); 0 < i; --i) {
     const double b0(2.0 * x * b1 - b2 + c[i]);
     b2 = b1;
     b1 = b0;

src/generation/delta_calculation.cc

@@ -54,7 +54,7 @@ DeltaCalculation::DeltaCalculation(
     InputSourceInterface* input_source, bool use_magic_number,
     double magic_number)
     : num_order_(num_order),
-      num_delta_(window_coefficients.size()),
+      num_delta_(static_cast<int>(window_coefficients.size())),
       window_coefficients_(window_coefficients),
       input_source_(input_source),
       use_magic_number_(use_magic_number),
@@ -73,7 +73,7 @@ DeltaCalculation::DeltaCalculation(
       return;
     }
     if (max_window_width_ < static_cast<int>(window_coefficients[d].size())) {
-      max_window_width_ = window_coefficients[d].size();
+      max_window_width_ = static_cast<int>(window_coefficients[d].size());
     }
   }
 

src/generation/nonrecursive_maximum_likelihood_parameter_generation.cc

@@ -61,7 +61,7 @@ bool CheckSize(const std::vector<std::vector<double> >& vectors, int size) {
 }
 
 bool CheckSize(const std::vector<sptk::SymmetricMatrix>& matrices, int size) {
-  const int outer_size(matrices.size());
+  const int outer_size(static_cast<int>(matrices.size()));
   for (int i(0); i < outer_size; ++i) {
     const int inner_size(matrices[i].GetNumDimension());
     if (inner_size != size) {
@@ -125,7 +125,7 @@ bool NonrecursiveMaximumLikelihoodParameterGeneration::Run(
 
   const int sequence_length(static_cast<int>(variance_vectors.size()));
   std::vector<SymmetricMatrix> covariance_matrices(
-      sequence_length, SymmetricMatrix(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;
@@ -163,8 +163,8 @@ bool NonrecursiveMaximumLikelihoodParameterGeneration::Run(
       }
     }
   }
-  const int continuous_length(
-      std::count(is_continuous.begin(), is_continuous.end(), true));
+  const int continuous_length(static_cast<int>(
+      std::count(is_continuous.begin(), is_continuous.end(), true)));
 
   // Prepare memories.
   const int max_window_width(2 * max_half_window_width_ + 1);

src/generation/normal_distributed_random_value_generation.cc

@@ -55,7 +55,7 @@ double PseudoRandomGeneration(std::uint64_t* next) {
   }
 
   *next = (*next) * 1103515245L + 12345;
-  const double r(((*next) / 65536L) % 32768L);
+  const double r(static_cast<double>(((*next) / 65536L) % 32768L));
 
   return r / 32767.0;
 }

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(
-          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(
-        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(),
@@ -154,7 +154,7 @@ bool RecursiveMaximumLikelihoodParameterGeneration::Get(
 }
 
 bool RecursiveMaximumLikelihoodParameterGeneration::Forward() {
-  const int num_delta(window_coefficients_.size());
+  const int num_delta(static_cast<int>(window_coefficients_.size()));
   const int static_size(num_order_ + 1);
   const int dynamic_size(static_size * num_delta);
 

src/input/input_source_from_vector.cc

@@ -53,7 +53,7 @@ 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 : 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/input/input_source_interpolation.cc

@@ -75,7 +75,7 @@ InputSourceInterpolation::InputSourceInterpolation(
   }
 
   remained_num_samples_ = frame_period_ + 1;
-  data_length_ = curr_data_.size();
+  data_length_ = static_cast<int>(curr_data_.size());
 
   if (!source_->Get(&next_data_)) {
     next_data_.resize(data_length_);

src/input/input_source_interpolation_with_magic_number.cc

@@ -84,7 +84,7 @@ InputSourceInterpolationWithMagicNumber::
   }
 
   remained_num_samples_ = frame_period_ + 1;
-  data_length_ = curr_data_.size();
+  data_length_ = static_cast<int>(curr_data_.size());
 
   if (!source_->Get(&next_data_)) {
     next_data_.resize(data_length_);

src/math/dynamic_time_warping.cc

@@ -121,7 +121,7 @@ DynamicTimeWarping::DynamicTimeWarping(
     }
   }
 
-  const int num_candidate(local_path_candidates_.size());
+  const int num_candidate(static_cast<int>(local_path_candidates_.size()));
   local_path_weights_.resize(num_candidate);
   for (int k(0); k < num_candidate; ++k) {
     local_path_weights_[k] =
@@ -141,9 +141,9 @@ bool DynamicTimeWarping::Run(
     return false;
   }
 
-  const int num_candidate(local_path_candidates_.size());
-  const int num_query_vector(query_vector_sequence.size());
-  const int num_reference_vector(reference_vector_sequence.size());
+  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()));
 
   std::vector<std::vector<Cell> > cell(num_query_vector,
                                        std::vector<Cell>(num_reference_vector));

src/math/gaussian_mixture_model_based_conversion.cc

@@ -60,13 +60,13 @@ GaussianMixtureModelBasedConversion::GaussianMixtureModelBasedConversion(
     : num_source_order_(num_source_order),
       num_target_order_(num_target_order),
       source_length_((num_source_order_ + 1) *
-                     (window_coefficients.size() + 1)),
+                     (static_cast<int>(window_coefficients.size() + 1))),
       target_length_((num_target_order_ + 1) *
-                     (window_coefficients.size() + 1)),
+                     (static_cast<int>(window_coefficients.size() + 1))),
       weights_(weights),
       use_magic_number_(use_magic_number),
       magic_number_(magic_number),
-      num_mixture_(weights_.size()),
+      num_mixture_(static_cast<int>(weights_.size())),
       mlpg_(num_target_order_, window_coefficients, use_magic_number_,
             magic_number_),
       is_valid_(true),
@@ -174,10 +174,10 @@ bool GaussianMixtureModelBasedConversion::Run(
         return false;
       }
 
-      const int selected_mixture(
+      const int selected_mixture(static_cast<int>(
           std::max_element(components_of_log_probability.begin(),
                            components_of_log_probability.end()) -
-          components_of_log_probability.begin());
+          components_of_log_probability.begin()));
 
       // Set E.
       for (int l(0); l < target_length_; ++l) {

src/utils/misc_utils.cc

@@ -145,7 +145,7 @@ bool ComputePercentagePointOfTDistribution(double probability,
 
   const double inverse_degrees_of_freedom(1.0 / degrees_of_freedom);
   *percentage_point = 0.0;
-  for (int i(term.size() - 1); 0 <= i; --i) {
+  for (int i(static_cast<int>(term.size()) - 1); 0 <= i; --i) {
     *percentage_point =
         (*percentage_point + term[i]) * inverse_degrees_of_freedom;
   }
@@ -284,8 +284,8 @@ bool Perform1DConvolution(const std::vector<double>& f,
     return false;
   }
 
-  const int m(f.size());
-  const int n(g.size());
+  const int m(static_cast<int>(f.size()));
+  const int n(static_cast<int>(g.size()));
   const int output_size(m + n - 1);
   if (result->size() != static_cast<std::size_t>(output_size)) {
     result->resize(output_size);