Diff: fftReal.cpp

Revision:

3:dc123081d491

Parent:

2:9649d0e2bb4a

Child:

4:0b4975fffc90

diff -r 9649d0e2bb4a -r dc123081d491 fftReal.cpp
--- a/fftReal.cpp	Fri Dec 18 10:01:28 2015 +0000
+++ b/fftReal.cpp	Mon Jan 13 08:54:18 2020 +0000
@@ -1,82 +1,70 @@
 //------------------------------------------------------------------------------
-// FFT class for real data usind decimation-in-frequency algorithm
-//      This class can execute FFT and IFFT 
-// Copyright (c) 2015 MIKAMI, Naoki,  2015/10/29
+//  データが実数の場合の FFT class
+//      FFT     複素共役になる部分は計算しない
+//      IFFT    複素共役の部分を除いた値から計算する
+//
+//  2020/01/13, Copyright (c) 2020 MIKAMI, Naoki
 //------------------------------------------------------------------------------
 
 #include "fftReal.hpp"
 
 namespace Mikami
 {
-    // Constructor
+    // コンストラクタ
     FftReal::FftReal(int16_t n)
-            : N_FFT_(n), N_INV_(1.0f/n)
+            : N_FFT_(n), N_INV_(1.0f/n), wTable_(n/2), bTable_(n), u_(n)
     {
-        // __clz(): Count leading zeros
+        // __clz(): リーディング 0 の数を取得する命令に対応
         uint32_t shifted = n << (__clz(n)+1);
-        if (shifted != 0)
-        {
-            fprintf(stderr, "\r\nNot power of 2, in FftReal class.");
-            fprintf(stderr, "\r\nForce to exit the program.");
-            exit(EXIT_FAILURE); // Terminate program
-        }
 
-        wTable_ = new Complex[n/2];
-        bTable_ = new uint16_t[n];
-        u_ = new Complex[n];
-    
-        // calculation of twiddle factor
+        MBED_ASSERT(shifted == 0);
+
+        // 回転子の表を作成
         Complex arg = Complex(0, -6.283185f/N_FFT_);
         for (int k=0; k<N_FFT_/2; k++)
             wTable_[k] = exp(arg*(float)k);
 
-        // for bit reversal table
+        // ビット逆順のための表を作成
         uint16_t nShift = __clz(n) + 1;
         for (int k=0; k<n; k++)
-            // __rbit(k): Reverse the bit order in a 32-bit word
-            bTable_[k] = __rbit(k) >> nShift;        
+            // __rbit(k): ビットの並びを逆にする命令に対応
+            bTable_[k] = __rbit(k) >> nShift;
     }
 
-    // Destructor
-    FftReal::~FftReal()
-    {
-        delete[] wTable_;
-        delete[] bTable_;
-        delete[] u_;    
-    }
-
-    // Execute FFT
+    // FFT の実行
+    //      有効な部分 y[0] ～ y[N_FFT_/2]
+    //      それ以外の部分は複素共役になるので，計算をしていない
     void FftReal::Execute(const float x[], Complex y[])
     {
         for (int n=0; n<N_FFT_; n++) u_[n] = x[n];
 
-        // except for last stage
+        // 最終ステージを除いた部分
         ExcludeLastStage();
 
-        // Last stage
+        // 最終ステージ
         y[0] = u_[0] + u_[1];
         y[N_FFT_/2] = u_[0] - u_[1];
-        for (int k=2; k<N_FFT_; k+=2)
-            u_[k] = u_[k] + u_[k+1];
+        for (int k=2; k<N_FFT_; k+=2) u_[k] = u_[k] + u_[k+1];
 
-        // Reorder to bit reversal
-        for (int k=1; k<N_FFT_/2; k++)
-            y[k] = u_[bTable_[k]];
+        // ビット逆順の並べ替え
+        for (int k=1; k<N_FFT_/2; k++) y[k] = u_[bTable_[k]];
     }
 
-    // Execute IFFT
+    // IFFT の実行
+    //      このクラスで計算された FFT の結果の IFFT を計算する
+    //      実行結果    x[0] ～ x[N_FFT_]
     void FftReal::ExecuteIfft(const Complex y[], float x[])
     {
         int half = N_FFT_/2;
 
         for (int n=0; n<=half; n++) u_[n] = y[n];
         for (int n=half+1; n<N_FFT_; n++)
-            u_[n] = conj(y[N_FFT_-n]);
+            u_[n] = conj(y[N_FFT_-n]);      // 後半は複素共役になっているものとする
 
-        // except for last stage
+        // 最終ステージを除いた部分
         ExcludeLastStage();
 
-        // Last stage including bit reversal
+        // 最終ステージとビット逆順の並べ替え処理
         x[0] = N_INV_*(u_[0].real() + u_[1].real());
         x[half] = N_INV_*(u_[0].real() - u_[1].real());
 
@@ -89,7 +77,7 @@
         }
     }
 
-    // Processing except for last stage
+    // 最終ステージを除いた処理
     void FftReal::ExcludeLastStage()
     {
         uint16_t nHalf = N_FFT_/2;
@@ -111,5 +99,4 @@
             nHalf = nHalf/2;
         }        
     }
-}
-
+}
\ No newline at end of file