update ifft

doc/Doxyfile

@@ -853,6 +853,7 @@ INPUT                  = \
                          ../include/SPTK/filter/all_zero_digital_filter.h \
                          ../include/SPTK/math/fast_fourier_transform.h \
                          ../include/SPTK/math/frequency_transform.h \
+                         ../include/SPTK/math/inverse_fast_fourier_transform.h \
                          ../include/SPTK/math/real_valued_fast_fourier_transform.h \
                          ../include/SPTK/math/real_valued_inverse_fast_fourier_transform.h \
                          ../include/SPTK/normalizer/generalized_cepstrum_gain_normalization.h \
@@ -863,6 +864,7 @@ INPUT                  = \
                          ../src/main/fftr.cc \
                          ../src/main/freqt.cc \
                          ../src/main/gnorm.cc \
+                         ../src/main/ifft.cc \
                          ../src/main/ignorm.cc \
                          ../src/main/iulaw.cc \
                          ../src/main/mc2b.cc \

doc/cmd/ifft.rst

@@ -0,0 +1,7 @@
+ifft
+====
+
+.. doxygenfile:: ifft.cc
+
+.. doxygenclass:: sptk::InverseFastFourierTransform
+   :members:

include/SPTK/math/fast_fourier_transform.h

@@ -73,6 +73,11 @@ namespace sptk {
  */
 class FastFourierTransform {
  public:
+  /**
+   * @param[in] fft_length FFT length, \f$L\f$.
+   */
+  explicit FastFourierTransform(int fft_length);
+
   /**
    * @param[in] num_order Order of input, \f$M\f$.
    * @param[in] fft_length FFT length, \f$L\f$.
@@ -114,6 +119,7 @@ class FastFourierTransform {
            const std::vector<double>& imag_part_input,
            std::vector<double>* real_part_output,
            std::vector<double>* imag_part_output) const;
+
   /**
    * @param[in,out] real_part Real part.
    * @param[in,out] imag_part Imaginary part.

include/SPTK/math/inverse_fast_fourier_transform.h

@@ -8,7 +8,7 @@
 //                           Interdisciplinary Graduate School of    //
 //                           Science and Engineering                 //
 //                                                                   //
-//                1996-2019  Nagoya Institute of Technology          //
+//                1996-2020  Nagoya Institute of Technology          //
 //                           Department of Computer Science          //
 //                                                                   //
 // All rights reserved.                                              //
@@ -52,40 +52,86 @@
 
 namespace sptk {
 
+/**
+ * Calculate inverse DFT of complex-valued input data.
+ *
+ * The input is \f$M\f$-th order complex-valued data:
+ * \f[
+ *   \begin{array}{cccc}
+ *   \mathrm{Re}(x(0)), & \mathrm{Re}(x(1)), & \ldots, & \mathrm{Re}(x(M)), \\
+ *   \mathrm{Im}(x(0)), & \mathrm{Im}(x(1)), & \ldots, & \mathrm{Im}(x(M)),
+ *   \end{array}
+ * \f]
+ * The outputs are
+ * \f[
+ *   \begin{array}{cccc}
+ *   \mathrm{Re}(X(0)), & \mathrm{Re}(X(1)), & \ldots, & \mathrm{Re}(X(L-1)), \\
+ *   \mathrm{Im}(X(0)), & \mathrm{Im}(X(1)), & \ldots, & \mathrm{Im}(X(L-1)),
+ *   \end{array}
+ * \f]
+ * where \f$L\f$ is the FFT length and \f$X\f$ is the complex-valued inverse FFT
+ * sequence of \f$x\f$.
+ */
 class InverseFastFourierTransform {
  public:
-  //
+  /**
+   * @param[in] fft_length FFT length, \f$L\f$.
+   */
+  explicit InverseFastFourierTransform(int fft_length);
+
+  /**
+   * @param[in] num_order Order of input, \f$M\f$.
+   * @param[in] fft_length FFT length, \f$L\f$.
+   */
   InverseFastFourierTransform(int num_order, int fft_length);
 
-  //
   virtual ~InverseFastFourierTransform() {
   }
 
+  /**
+   * @return Order of input.
+   */
   int GetNumOrder() const {
     return fast_fourier_transform_.GetNumOrder();
   }
 
-  //
+  /**
+   * @return FFT length.
+   */
   int GetFftLength() const {
     return fast_fourier_transform_.GetFftLength();
   }
 
-  //
+  /**
+   * @return True if this obejct is valid.
+   */
   bool IsValid() const {
     return fast_fourier_transform_.IsValid();
   }
 
-  //
+  /**
+   * @param[in] real_part_input \f$M\f$-th order real part of input.
+   * @param[in] imag_part_input \f$M\f$-th order imaginary part of input.
+   * @param[out] real_part_output Real part of output.
+   * @param[out] imag_part_output Imaginary part of output.
+   * @return True on success, false on failure.
+   */
   bool Run(const std::vector<double>& real_part_input,
-           const std::vector<double>& imaginary_part_input,
+           const std::vector<double>& imag_part_input,
            std::vector<double>* real_part_output,
-           std::vector<double>* imaginary_part_output) const;
+           std::vector<double>* imag_part_output) const;
+
+  /**
+   * @param[in,out] real_part Real part.
+   * @param[in,out] imag_part Imaginary part.
+   * @return True on success, false on failure.
+   */
+  bool Run(std::vector<double>* real_part,
+           std::vector<double>* imag_part) const;
 
  private:
-  //
   const FastFourierTransform fast_fourier_transform_;
 
-  //
   DISALLOW_COPY_AND_ASSIGN(InverseFastFourierTransform);
 };
 

include/SPTK/math/real_valued_fast_fourier_transform.h

@@ -92,6 +92,11 @@ class RealValuedFastFourierTransform {
     DISALLOW_COPY_AND_ASSIGN(Buffer);
   };
 
+  /**
+   * @param[in] fft_length FFT length, \f$L\f$.
+   */
+  explicit RealValuedFastFourierTransform(int fft_length);
+
   /**
    * @param[in] num_order Order of input, \f$M\f$.
    * @param[in] fft_length FFT length, \f$L\f$.

include/SPTK/math/real_valued_inverse_fast_fourier_transform.h

@@ -78,6 +78,11 @@ class RealValuedInverseFastFourierTransform {
     DISALLOW_COPY_AND_ASSIGN(Buffer);
   };
 
+  /**
+   * @param[in] fft_length FFT length, \f$L\f$.
+   */
+  explicit RealValuedInverseFastFourierTransform(int fft_length);
+
   /**
    * @param[in] num_order Order of input, \f$M\f$.
    * @param[in] fft_length FFT length, \f$L\f$.

src/analyzer/fast_fourier_transform_cepstral_analysis.cc

@@ -54,8 +54,8 @@ FastFourierTransformCepstralAnalysis::FastFourierTransformCepstralAnalysis(
     : num_order_(num_order),
       num_iteration_(num_iteration),
       acceleration_factor_(acceleration_factor),
-      fast_fourier_transform_(fft_length - 1, fft_length),
-      inverse_fast_fourier_transform_(fft_length - 1, fft_length),
+      fast_fourier_transform_(fft_length),
+      inverse_fast_fourier_transform_(fft_length),
       is_valid_(true) {
   if (num_order_ < 0 || fft_length < 2 * num_order_ || num_iteration_ <= 0 ||
       acceleration_factor_ < 0.0 || !fast_fourier_transform_.IsValid() ||

src/analyzer/mel_cepstral_analysis.cc

@@ -102,8 +102,8 @@ MelCepstralAnalysis::MelCepstralAnalysis(int fft_length, int num_order,
       alpha_(alpha),
       num_iteration_(num_iteration),
       convergence_threshold_(convergence_threshold),
-      fourier_transform_(fft_length_ - 1, fft_length_),
-      inverse_fourier_transform_(fft_length_ - 1, fft_length_),
+      fourier_transform_(fft_length_),
+      inverse_fourier_transform_(fft_length_),
       frequency_transform_(fft_length_ / 2, num_order_, alpha_),
       inverse_frequency_transform_(num_order_, fft_length_ / 2, -alpha_),
       toeplitz_plus_hankel_system_solver_(num_order_, true),

src/analyzer/mel_generalized_cepstral_analysis.cc

@@ -139,9 +139,9 @@ MelGeneralizedCepstralAnalysis::MelGeneralizedCepstralAnalysis(
       gamma_(gamma),
       num_iteration_(num_iteration),
       convergence_threshold_(convergence_threshold),
-      fourier_transform_(fft_length_ - 1, fft_length_),
-      inverse_fourier_transform_(fft_length_ - 1, fft_length_),
-      complex_valued_inverse_fourier_transform_(fft_length_ - 1, fft_length_),
+      fourier_transform_(fft_length_),
+      inverse_fourier_transform_(fft_length_),
+      complex_valued_inverse_fourier_transform_(fft_length_),
       toeplitz_plus_hankel_system_solver_(num_order_ - 1, true),
       generalized_cepstrum_gain_normalization_(num_order_, gamma_),
       generalized_cepstrum_inverse_gain_normalization_gamma_minus_one_(

src/converter/cepstrum_to_autocorrelation.cc

@@ -56,7 +56,7 @@ CepstrumToAutocorrelation::CepstrumToAutocorrelation(int num_input_order,
                                                      int fft_length)
     : num_input_order_(num_input_order),
       num_output_order_(num_output_order),
-      fast_fourier_transform_(fft_length - 1, fft_length),
+      fast_fourier_transform_(fft_length),
       is_valid_(true) {
   if (num_input_order_ < 0 || num_output_order_ < 0 ||
       fft_length <= num_input_order_ || fft_length <= num_output_order_ ||

src/converter/cepstrum_to_negative_derivative_of_phase_spectrum.cc

@@ -52,7 +52,7 @@ namespace sptk {
 CepstrumToNegativeDerivativeOfPhaseSpectrum::
     CepstrumToNegativeDerivativeOfPhaseSpectrum(int num_order, int fft_length)
     : num_order_(num_order),
-      fast_fourier_transform_(fft_length - 1, fft_length),
+      fast_fourier_transform_(fft_length),
       is_valid_(true) {
   if (num_order_ < 0 || fft_length < 2 * num_order_ ||
       !fast_fourier_transform_.IsValid()) {

src/converter/filter_coefficients_to_spectrum.cc

@@ -62,7 +62,7 @@ FilterCoefficientsToSpectrum::FilterCoefficientsToSpectrum(
       output_format_(output_format),
       epsilon_for_calculating_logarithms_(epsilon_for_calculating_logarithms),
       relative_floor_in_decibels_(relative_floor_in_decibels),
-      fast_fourier_transform_(fft_length_ - 1, fft_length_),
+      fast_fourier_transform_(fft_length_),
       is_valid_(true) {
   if (num_numerator_order_ < 0 || num_denominator_order_ < 0 ||
       fft_length_ <= num_numerator_order_ ||

src/converter/negative_derivative_of_phase_spectrum_to_cepstrum.cc

@@ -52,7 +52,7 @@ namespace sptk {
 NegativeDerivativeOfPhaseSpectrumToCepstrum::
     NegativeDerivativeOfPhaseSpectrumToCepstrum(int fft_length, int num_order)
     : num_order_(num_order),
-      fast_fourier_transform_(fft_length - 1, fft_length),
+      fast_fourier_transform_(fft_length),
       is_valid_(true) {
   if (num_order_ < 0 || fft_length < 2 * num_order_ ||
       !fast_fourier_transform_.IsValid()) {