CMSIS-DSP: Initial F64 CFFT/RFFT implementation

Include/arm_common_tables.h

@@ -31,243 +31,360 @@
 
 #include "arm_math.h"
 
-#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_FFT_ALLOW_TABLES) 
-
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_FFT_ALLOW_TABLES)
+  /* Double Precision Float CFFT twiddles */
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREV_1024)
     extern const uint16_t armBitRevTable[1024];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
 
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F64_16)
+    extern const uint64_t twiddleCoefF64_16[32];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F64_32)
+    extern const uint64_t twiddleCoefF64_32[64];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F64_64)
+    extern const uint64_t twiddleCoefF64_64[128];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F64_128)
+    extern const uint64_t twiddleCoefF64_128[256];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F64_256)
+    extern const uint64_t twiddleCoefF64_256[512];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F64_512)
+    extern const uint64_t twiddleCoefF64_512[1024];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F64_1024)
+    extern const uint64_t twiddleCoefF64_1024[2048];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F64_2048)
+    extern const uint64_t twiddleCoefF64_2048[4096];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F64_4096)
+    extern const uint64_t twiddleCoefF64_4096[8192];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_16)
     extern const float32_t twiddleCoef_16[32];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_32)
     extern const float32_t twiddleCoef_32[64];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_64)
     extern const float32_t twiddleCoef_64[128];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_128)
     extern const float32_t twiddleCoef_128[256];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_256)
     extern const float32_t twiddleCoef_256[512];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_512)
     extern const float32_t twiddleCoef_512[1024];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_1024)
     extern const float32_t twiddleCoef_1024[2048];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_2048)
     extern const float32_t twiddleCoef_2048[4096];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_F32_4096)
     extern const float32_t twiddleCoef_4096[8192];
     #define twiddleCoef twiddleCoef_4096
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_16)
     extern const q31_t twiddleCoef_16_q31[24];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_32)
     extern const q31_t twiddleCoef_32_q31[48];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_64)
     extern const q31_t twiddleCoef_64_q31[96];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_128)
     extern const q31_t twiddleCoef_128_q31[192];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_256)
     extern const q31_t twiddleCoef_256_q31[384];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_512)
     extern const q31_t twiddleCoef_512_q31[768];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_1024)
     extern const q31_t twiddleCoef_1024_q31[1536];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_2048)
     extern const q31_t twiddleCoef_2048_q31[3072];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q31_4096)
     extern const q31_t twiddleCoef_4096_q31[6144];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_16)
     extern const q15_t twiddleCoef_16_q15[24];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_32)
     extern const q15_t twiddleCoef_32_q15[48];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_64)
     extern const q15_t twiddleCoef_64_q15[96];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_128)
     extern const q15_t twiddleCoef_128_q15[192];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_256)
     extern const q15_t twiddleCoef_256_q15[384];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_512)
     extern const q15_t twiddleCoef_512_q15[768];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_1024)
     extern const q15_t twiddleCoef_1024_q15[1536];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_2048)
     extern const q15_t twiddleCoef_2048_q15[3072];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_Q15_4096)
     extern const q15_t twiddleCoef_4096_q15[6144];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
+  /* Double Precision Float RFFT twiddles */
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_32)
+    extern const uint64_t twiddleCoefF64_rfft_32[32];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_64)
+    extern const uint64_t twiddleCoefF64_rfft_64[64];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_128)
+    extern const uint64_t twiddleCoefF64_rfft_128[128];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_256)
+    extern const uint64_t twiddleCoefF64_rfft_256[256];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_512)
+    extern const uint64_t twiddleCoefF64_rfft_512[512];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_1024)
+    extern const uint64_t twiddleCoefF64_rfft_1024[1024];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_2048)
+    extern const uint64_t twiddleCoefF64_rfft_2048[2048];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_4096)
+    extern const uint64_t twiddleCoefF64_rfft_4096[4096];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_32)
     extern const float32_t twiddleCoef_rfft_32[32];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_64)
     extern const float32_t twiddleCoef_rfft_64[64];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_128)
     extern const float32_t twiddleCoef_rfft_128[128];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_256)
     extern const float32_t twiddleCoef_rfft_256[256];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_512)
     extern const float32_t twiddleCoef_rfft_512[512];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_1024)
     extern const float32_t twiddleCoef_rfft_1024[1024];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_2048)
     extern const float32_t twiddleCoef_rfft_2048[2048];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_4096)
     extern const float32_t twiddleCoef_rfft_4096[4096];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
+
+  /* Double precision floating-point bit reversal tables */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT64_16)
+    #define ARMBITREVINDEXTABLEF64_16_TABLE_LENGTH ((uint16_t)12)
+    extern const uint16_t armBitRevIndexTableF64_16[ARMBITREVINDEXTABLEF64_16_TABLE_LENGTH];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT64_32)
+    #define ARMBITREVINDEXTABLEF64_32_TABLE_LENGTH ((uint16_t)24)
+    extern const uint16_t armBitRevIndexTableF64_32[ARMBITREVINDEXTABLEF64_32_TABLE_LENGTH];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT64_64)
+    #define ARMBITREVINDEXTABLEF64_64_TABLE_LENGTH ((uint16_t)56)
+    extern const uint16_t armBitRevIndexTableF64_64[ARMBITREVINDEXTABLEF64_64_TABLE_LENGTH];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT64_128)
+    #define ARMBITREVINDEXTABLEF64_128_TABLE_LENGTH ((uint16_t)112)
+    extern const uint16_t armBitRevIndexTableF64_128[ARMBITREVINDEXTABLEF64_128_TABLE_LENGTH];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT64_256)
+    #define ARMBITREVINDEXTABLEF64_256_TABLE_LENGTH ((uint16_t)240)
+    extern const uint16_t armBitRevIndexTableF64_256[ARMBITREVINDEXTABLEF64_256_TABLE_LENGTH];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT64_512)
+    #define ARMBITREVINDEXTABLEF64_512_TABLE_LENGTH ((uint16_t)480)
+    extern const uint16_t armBitRevIndexTableF64_512[ARMBITREVINDEXTABLEF64_512_TABLE_LENGTH];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT64_1024)
+    #define ARMBITREVINDEXTABLEF64_1024_TABLE_LENGTH ((uint16_t)992)
+    extern const uint16_t armBitRevIndexTableF64_1024[ARMBITREVINDEXTABLEF64_1024_TABLE_LENGTH];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT64_2048)
+    #define ARMBITREVINDEXTABLEF64_2048_TABLE_LENGTH ((uint16_t)1984)
+    extern const uint16_t armBitRevIndexTableF64_2048[ARMBITREVINDEXTABLEF64_2048_TABLE_LENGTH];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
+
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT64_4096)
+    #define ARMBITREVINDEXTABLEF64_4096_TABLE_LENGTH ((uint16_t)4032)
+    extern const uint16_t armBitRevIndexTableF64_4096[ARMBITREVINDEXTABLEF64_4096_TABLE_LENGTH];
+  #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
   /* floating-point bit reversal tables */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_16)
     #define ARMBITREVINDEXTABLE_16_TABLE_LENGTH ((uint16_t)20)
     extern const uint16_t armBitRevIndexTable16[ARMBITREVINDEXTABLE_16_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_32)
     #define ARMBITREVINDEXTABLE_32_TABLE_LENGTH ((uint16_t)48)
     extern const uint16_t armBitRevIndexTable32[ARMBITREVINDEXTABLE_32_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_64)
     #define ARMBITREVINDEXTABLE_64_TABLE_LENGTH ((uint16_t)56)
     extern const uint16_t armBitRevIndexTable64[ARMBITREVINDEXTABLE_64_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_128)
     #define ARMBITREVINDEXTABLE_128_TABLE_LENGTH ((uint16_t)208)
     extern const uint16_t armBitRevIndexTable128[ARMBITREVINDEXTABLE_128_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_256)
     #define ARMBITREVINDEXTABLE_256_TABLE_LENGTH ((uint16_t)440)
     extern const uint16_t armBitRevIndexTable256[ARMBITREVINDEXTABLE_256_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_512)
     #define ARMBITREVINDEXTABLE_512_TABLE_LENGTH ((uint16_t)448)
     extern const uint16_t armBitRevIndexTable512[ARMBITREVINDEXTABLE_512_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_1024)
     #define ARMBITREVINDEXTABLE_1024_TABLE_LENGTH ((uint16_t)1800)
     extern const uint16_t armBitRevIndexTable1024[ARMBITREVINDEXTABLE_1024_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_2048)
     #define ARMBITREVINDEXTABLE_2048_TABLE_LENGTH ((uint16_t)3808)
     extern const uint16_t armBitRevIndexTable2048[ARMBITREVINDEXTABLE_2048_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FLT_4096)
     #define ARMBITREVINDEXTABLE_4096_TABLE_LENGTH ((uint16_t)4032)
     extern const uint16_t armBitRevIndexTable4096[ARMBITREVINDEXTABLE_4096_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
-  
+
+
   /* fixed-point bit reversal tables */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_16)
     #define ARMBITREVINDEXTABLE_FIXED_16_TABLE_LENGTH ((uint16_t)12)
     extern const uint16_t armBitRevIndexTable_fixed_16[ARMBITREVINDEXTABLE_FIXED_16_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_32)
     #define ARMBITREVINDEXTABLE_FIXED_32_TABLE_LENGTH ((uint16_t)24)
     extern const uint16_t armBitRevIndexTable_fixed_32[ARMBITREVINDEXTABLE_FIXED_32_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_64)
     #define ARMBITREVINDEXTABLE_FIXED_64_TABLE_LENGTH ((uint16_t)56)
     extern const uint16_t armBitRevIndexTable_fixed_64[ARMBITREVINDEXTABLE_FIXED_64_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_128)
     #define ARMBITREVINDEXTABLE_FIXED_128_TABLE_LENGTH ((uint16_t)112)
     extern const uint16_t armBitRevIndexTable_fixed_128[ARMBITREVINDEXTABLE_FIXED_128_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_256)
     #define ARMBITREVINDEXTABLE_FIXED_256_TABLE_LENGTH ((uint16_t)240)
     extern const uint16_t armBitRevIndexTable_fixed_256[ARMBITREVINDEXTABLE_FIXED_256_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_512)
     #define ARMBITREVINDEXTABLE_FIXED_512_TABLE_LENGTH ((uint16_t)480)
     extern const uint16_t armBitRevIndexTable_fixed_512[ARMBITREVINDEXTABLE_FIXED_512_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_1024)
     #define ARMBITREVINDEXTABLE_FIXED_1024_TABLE_LENGTH ((uint16_t)992)
     extern const uint16_t armBitRevIndexTable_fixed_1024[ARMBITREVINDEXTABLE_FIXED_1024_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_2048)
     #define ARMBITREVINDEXTABLE_FIXED_2048_TABLE_LENGTH ((uint16_t)1984)
     extern const uint16_t armBitRevIndexTable_fixed_2048[ARMBITREVINDEXTABLE_FIXED_2048_TABLE_LENGTH];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_BITREVIDX_FXT_4096)
     #define ARMBITREVINDEXTABLE_FIXED_4096_TABLE_LENGTH ((uint16_t)4032)
     extern const uint16_t armBitRevIndexTable_fixed_4096[ARMBITREVINDEXTABLE_FIXED_4096_TABLE_LENGTH];
@@ -328,26 +445,26 @@
     extern const q15_t cos_factorsQ15_8192[8192];
   #endif
 
-  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_128)  
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_128)
     extern const q31_t WeightsQ31_128[256];
     extern const q31_t cos_factorsQ31_128[128];
   #endif
 
-  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_512) 
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_512)
     extern const q31_t WeightsQ31_512[1024];
     extern const q31_t cos_factorsQ31_512[512];
   #endif
 
-  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_2048) 
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_2048)
     extern const q31_t WeightsQ31_2048[4096];
     extern const q31_t cos_factorsQ31_2048[2048];
   #endif
 
-  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_8192) 
+  #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || defined(ARM_TABLE_DCT4_Q31_8192)
     extern const q31_t WeightsQ31_8192[16384];
     extern const q31_t cos_factorsQ31_8192[8192];
   #endif
-    
+
 #endif /* if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_FFT_TABLES) */
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_FAST_ALLOW_TABLES)
@@ -355,20 +472,20 @@
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FAST_TABLES) || defined(ARM_TABLE_RECIP_Q15)
     extern const q15_t armRecipTableQ15[64];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) defined(ARM_ALL_FAST_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FAST_TABLES) || defined(ARM_TABLE_RECIP_Q31)
     extern const q31_t armRecipTableQ31[64];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) defined(ARM_ALL_FAST_TABLES) */
-  
+
   /* Tables for Fast Math Sine and Cosine */
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FAST_TABLES) || defined(ARM_TABLE_SIN_F32)
     extern const float32_t sinTable_f32[FAST_MATH_TABLE_SIZE + 1];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) defined(ARM_ALL_FAST_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FAST_TABLES) || defined(ARM_TABLE_SIN_Q31)
     extern const q31_t sinTable_q31[FAST_MATH_TABLE_SIZE + 1];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) defined(ARM_ALL_FAST_TABLES) */
-  
+
   #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FAST_TABLES) || defined(ARM_TABLE_SIN_Q15)
     extern const q15_t sinTable_q15[FAST_MATH_TABLE_SIZE + 1];
   #endif /* !defined(ARM_DSP_CONFIG_TABLES) defined(ARM_ALL_FAST_TABLES) */

Include/arm_const_structs.h

@@ -33,6 +33,16 @@
 #include "arm_math.h"
 #include "arm_common_tables.h"
 
+   extern const arm_cfft_instance_f64 arm_cfft_sR_f64_len16;
+   extern const arm_cfft_instance_f64 arm_cfft_sR_f64_len32;
+   extern const arm_cfft_instance_f64 arm_cfft_sR_f64_len64;
+   extern const arm_cfft_instance_f64 arm_cfft_sR_f64_len128;
+   extern const arm_cfft_instance_f64 arm_cfft_sR_f64_len256;
+   extern const arm_cfft_instance_f64 arm_cfft_sR_f64_len512;
+   extern const arm_cfft_instance_f64 arm_cfft_sR_f64_len1024;
+   extern const arm_cfft_instance_f64 arm_cfft_sR_f64_len2048;
+   extern const arm_cfft_instance_f64 arm_cfft_sR_f64_len4096;
+
    extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len16;
    extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len32;
    extern const arm_cfft_instance_f32 arm_cfft_sR_f32_len64;

Include/arm_math.h

@@ -2777,6 +2777,24 @@ void arm_cfft_q31(
         uint8_t ifftFlag,
         uint8_t bitReverseFlag);
 
+
+  /**
+   * @brief Instance structure for the Double Precision Floating-point CFFT/CIFFT function.
+   */
+  typedef struct
+  {
+          uint16_t fftLen;                   /**< length of the FFT. */
+    const float64_t *pTwiddle;         /**< points to the Twiddle factor table. */
+    const uint16_t *pBitRevTable;      /**< points to the bit reversal table. */
+          uint16_t bitRevLength;             /**< bit reversal table length. */
+  } arm_cfft_instance_f64;
+
+  void arm_cfft_f64(
+  const arm_cfft_instance_f64 * S,
+        float64_t * p1,
+        uint8_t ifftFlag,
+        uint8_t bitReverseFlag);
+
   /**
    * @brief Instance structure for the Q15 RFFT/RIFFT function.
    */
@@ -2854,6 +2872,42 @@ void arm_cfft_q31(
         float32_t * pSrc,
         float32_t * pDst);
 
+  /**
+   * @brief Instance structure for the Double Precision Floating-point RFFT/RIFFT function.
+   */
+typedef struct
+  {
+          arm_cfft_instance_f64 Sint;      /**< Internal CFFT structure. */
+          uint16_t fftLenRFFT;             /**< length of the real sequence */
+    const float64_t * pTwiddleRFFT;        /**< Twiddle factors real stage  */
+  } arm_rfft_fast_instance_f64 ;
+
+arm_status arm_rfft_fast_init_f64 (
+         arm_rfft_fast_instance_f64 * S,
+         uint16_t fftLen);
+
+arm_status arm_rfft_32_fast_init_f64 ( arm_rfft_fast_instance_f64 * S );
+
+arm_status arm_rfft_64_fast_init_f64 ( arm_rfft_fast_instance_f64 * S );
+
+arm_status arm_rfft_128_fast_init_f64 ( arm_rfft_fast_instance_f64 * S );
+
+arm_status arm_rfft_256_fast_init_f64 ( arm_rfft_fast_instance_f64 * S );
+
+arm_status arm_rfft_512_fast_init_f64 ( arm_rfft_fast_instance_f64 * S );
+
+arm_status arm_rfft_1024_fast_init_f64 ( arm_rfft_fast_instance_f64 * S );
+
+arm_status arm_rfft_2048_fast_init_f64 ( arm_rfft_fast_instance_f64 * S );
+
+arm_status arm_rfft_4096_fast_init_f64 ( arm_rfft_fast_instance_f64 * S );
+
+void arm_rfft_fast_f64(
+    arm_rfft_fast_instance_f64 * S,
+    float64_t * p, float64_t * pOut,
+    uint8_t ifftFlag);
+
+
   /**
    * @brief Instance structure for the floating-point RFFT/RIFFT function.
    */

PythonWrapper/cmsisdsp_pkg/src/fftinit.c

@@ -29,234 +29,309 @@
 #include "arm_common_tables.h"
 #include "arm_const_structs.h"
 
-#define FFTINIT(SIZE)                                           \
-  S->bitRevLength = arm_cfft_sR_f32_len##SIZE.bitRevLength;        \
-  S->pBitRevTable = arm_cfft_sR_f32_len##SIZE.pBitRevTable;         \
-  S->pTwiddle = arm_cfft_sR_f32_len##SIZE.pTwiddle;
+#define FFTINIT(EXT,SIZE)                                           \
+  S->bitRevLength = arm_cfft_sR_##EXT##_len##SIZE.bitRevLength;        \
+  S->pBitRevTable = arm_cfft_sR_##EXT##_len##SIZE.pBitRevTable;         \
+  S->pTwiddle = arm_cfft_sR_##EXT##_len##SIZE.pTwiddle;
 
 #define FFTFXTINIT(EXT,SIZE)                                           \
   S->bitRevLength = arm_cfft_sR_##EXT##_len##SIZE.bitRevLength;        \
   S->pBitRevTable = arm_cfft_sR_##EXT##_len##SIZE.pBitRevTable;         \
   S->pTwiddle = arm_cfft_sR_##EXT##_len##SIZE.pTwiddle;
 
+
+
+arm_status arm_cfft_init_f64(
+  arm_cfft_instance_f64 * S,
+  uint16_t fftLen)
+{
+        /*  Initialise the default arm status */
+        arm_status status = ARM_MATH_SUCCESS;
+
+        /*  Initialise the FFT length */
+        S->fftLen = fftLen;
+
+        /*  Initialise the Twiddle coefficient pointer */
+        S->pTwiddle = (float64_t *)twiddleCoefF64_4096;
+
+
+        /*  Initializations of Instance structure depending on the FFT length */
+        switch (S->fftLen) {
+            /*  Initializations of structure parameters for 4096 point FFT */
+        case 4096U:
+            /*  Initialise the bit reversal table modifier */
+            FFTINIT(f64,4096);
+            break;
+
+            /*  Initializations of structure parameters for 2048 point FFT */
+        case 2048U:
+            /*  Initialise the bit reversal table modifier */
+            FFTINIT(f64,2048);
+
+            break;
+
+            /*  Initializations of structure parameters for 1024 point FFT */
+        case 1024U:
+            /*  Initialise the bit reversal table modifier */
+            FFTINIT(f64,1024);
+
+            break;
+
+            /*  Initializations of structure parameters for 512 point FFT */
+        case 512U:
+            /*  Initialise the bit reversal table modifier */
+            FFTINIT(f64,512);
+            break;
+
+        case 256U:
+            FFTINIT(f64,256);
+            break;
+
+        case 128U:
+            FFTINIT(f64,128);
+            break;
+
+        case 64U:
+            FFTINIT(f64,64);
+            break;
+
+        case 32U:
+            FFTINIT(f64,32);
+            break;
+
+        case 16U:
+            /*  Initializations of structure parameters for 16 point FFT */
+            FFTINIT(f64,16);
+            break;
+
+
+        default:
+            /*  Reporting argument error if fftSize is not valid value */
+            status = ARM_MATH_ARGUMENT_ERROR;
+            break;
+        }
+
+        return (status);
+}
+
 arm_status arm_cfft_init_f32(
   arm_cfft_instance_f32 * S,
   uint16_t fftLen)
 {
-        /*  Initialise the default arm status */                                
-        arm_status status = ARM_MATH_SUCCESS;                                   
-                                                                                
-        /*  Initialise the FFT length */                                        
-        S->fftLen = fftLen;          
-                                                                                
-        /*  Initialise the Twiddle coefficient pointer */                       
-        S->pTwiddle = (float32_t *)twiddleCoef_4096;                         
-                                                                                
-                                                                                
+        /*  Initialise the default arm status */
+        arm_status status = ARM_MATH_SUCCESS;
+
+        /*  Initialise the FFT length */
+        S->fftLen = fftLen;
+
+        /*  Initialise the Twiddle coefficient pointer */
+        S->pTwiddle = (float32_t *)twiddleCoef_4096;
+
+
         /*  Initializations of Instance structure depending on the FFT length */
-        switch (S->fftLen) {                                                    
-            /*  Initializations of structure parameters for 4096 point FFT */   
-        case 4096U:                                                             
-            /*  Initialise the bit reversal table modifier */                   
-            FFTINIT(4096);      
-            break;                                                              
-                                                                                
-            /*  Initializations of structure parameters for 2048 point FFT */   
-        case 2048U:                                                             
-            /*  Initialise the bit reversal table modifier */                   
-            FFTINIT(2048);                 
-                                                                            
-            break;                                                              
-                                                                                
-            /*  Initializations of structure parameters for 1024 point FFT */   
-        case 1024U:                                                             
-            /*  Initialise the bit reversal table modifier */                   
-            FFTINIT(1024);                 
-                                                                         
-            break;                                                              
-                                                                                
-            /*  Initializations of structure parameters for 512 point FFT */    
-        case 512U:                                                              
-            /*  Initialise the bit reversal table modifier */                   
-            FFTINIT(512);                                                                                   
-            break;                                                              
-                                                                                
-        case 256U:                                                              
-            FFTINIT(256);                                                                                  
-            break;                                                              
-                                                                                
-        case 128U:                                                              
-            FFTINIT(128);                                                                                  
-            break;                                                              
-                                                                                
-        case 64U:                                                               
-            FFTINIT(64);                                                                               
-            break;                                                              
-                                                                                
-        case 32U:                                                               
-            FFTINIT(32);                                                                                
-            break;                                                              
-                                                                                
-        case 16U:                                                               
-            /*  Initializations of structure parameters for 16 point FFT */     
-            FFTINIT(16);   
-            break;                                                              
-                                                                                
-                                                                                
-        default:                                                                
-            /*  Reporting argument error if fftSize is not valid value */       
-            status = ARM_MATH_ARGUMENT_ERROR;                                   
-            break;                                                              
-        }                                                                       
-                                                                                
-                                                                                
-        return (status);    
+        switch (S->fftLen) {
+            /*  Initializations of structure parameters for 4096 point FFT */
+        case 4096U:
+            /*  Initialise the bit reversal table modifier */
+            FFTINIT(f32,4096);
+            break;
+
+            /*  Initializations of structure parameters for 2048 point FFT */
+        case 2048U:
+            /*  Initialise the bit reversal table modifier */
+            FFTINIT(f32,2048);
+
+            break;
+
+            /*  Initializations of structure parameters for 1024 point FFT */
+        case 1024U:
+            /*  Initialise the bit reversal table modifier */
+            FFTINIT(f32,1024);
+
+            break;
+
+            /*  Initializations of structure parameters for 512 point FFT */
+        case 512U:
+            /*  Initialise the bit reversal table modifier */
+            FFTINIT(f32,512);
+            break;
+
+        case 256U:
+            FFTINIT(f32,256);
+            break;
+
+        case 128U:
+            FFTINIT(f32,128);
+            break;
+
+        case 64U:
+            FFTINIT(f32,64);
+            break;
+
+        case 32U:
+            FFTINIT(f32,32);
+            break;
+
+        case 16U:
+            /*  Initializations of structure parameters for 16 point FFT */
+            FFTINIT(f32,16);
+            break;
+
+
+        default:
+            /*  Reporting argument error if fftSize is not valid value */
+            status = ARM_MATH_ARGUMENT_ERROR;
+            break;
+        }
+
+
+        return (status);
 }
 
 arm_status arm_cfft_init_q31(
   arm_cfft_instance_q31 * S,
   uint16_t fftLen)
 {
-        /*  Initialise the default arm status */                                
-        arm_status status = ARM_MATH_SUCCESS;                                   
-                                                                                
-        /*  Initialise the FFT length */                                        
-        S->fftLen = fftLen;          
-                                                                                
-        /*  Initialise the Twiddle coefficient pointer */                       
-        S->pTwiddle = (float32_t *)twiddleCoef_4096;                         
-                                                                                
-                                                                                
+        /*  Initialise the default arm status */
+        arm_status status = ARM_MATH_SUCCESS;
+
+        /*  Initialise the FFT length */
+        S->fftLen = fftLen;
+
+        /*  Initialise the Twiddle coefficient pointer */
+        S->pTwiddle = (float32_t *)twiddleCoef_4096;
+
+
         /*  Initializations of Instance structure depending on the FFT length */
-        switch (S->fftLen) {                                                    
-            /*  Initializations of structure parameters for 4096 point FFT */   
-        case 4096U:                                                             
-            /*  Initialise the bit reversal table modifier */                   
-            FFTFXTINIT(q31,4096);      
-            break;                                                              
-                                                                                
-            /*  Initializations of structure parameters for 2048 point FFT */   
-        case 2048U:                                                             
-            /*  Initialise the bit reversal table modifier */                   
-             FFTFXTINIT(q31,2048);                 
-                                                                            
-            break;                                                              
-                                                                                
-            /*  Initializations of structure parameters for 1024 point FFT */   
-        case 1024U:                                                             
-            /*  Initialise the bit reversal table modifier */                   
-             FFTFXTINIT(q31,1024);                 
-                                                                         
-            break;                                                              
-                                                                                
-            /*  Initializations of structure parameters for 512 point FFT */    
-        case 512U:                                                              
-            /*  Initialise the bit reversal table modifier */                   
-             FFTFXTINIT(q31,512);                                                                                   
-            break;                                                              
-                                                                                
-        case 256U:                                                              
-             FFTFXTINIT(q31,256);                                                                                  
-            break;                                                              
-                                                                                
-        case 128U:                                                              
-             FFTFXTINIT(q31,128);                                                                                  
-            break;                                                              
-                                                                                
-        case 64U:                                                               
-             FFTFXTINIT(q31,64);                                                                               
-            break;                                                              
-                                                                                
-        case 32U:                                                               
-             FFTFXTINIT(q31,32);                                                                                
-            break;                                                              
-                                                                                
-        case 16U:                                                               
-            /*  Initializations of structure parameters for 16 point FFT */     
-             FFTFXTINIT(q31,16);   
-            break;                                                              
-                                                                                
-                                                                                
-        default:                                                                
-            /*  Reporting argument error if fftSize is not valid value */       
-            status = ARM_MATH_ARGUMENT_ERROR;                                   
-            break;                                                              
-        }                                                                       
-                                                                                
-                                                                                
-        return (status);    
+        switch (S->fftLen) {
+            /*  Initializations of structure parameters for 4096 point FFT */
+        case 4096U:
+            /*  Initialise the bit reversal table modifier */
+            FFTFXTINIT(q31,4096);
+            break;
+
+            /*  Initializations of structure parameters for 2048 point FFT */
+        case 2048U:
+            /*  Initialise the bit reversal table modifier */
+             FFTFXTINIT(q31,2048);
+
+            break;
+
+            /*  Initializations of structure parameters for 1024 point FFT */
+        case 1024U:
+            /*  Initialise the bit reversal table modifier */
+             FFTFXTINIT(q31,1024);
+
+            break;
+
+            /*  Initializations of structure parameters for 512 point FFT */
+        case 512U:
+            /*  Initialise the bit reversal table modifier */
+             FFTFXTINIT(q31,512);
+            break;
+
+        case 256U:
+             FFTFXTINIT(q31,256);
+            break;
+
+        case 128U:
+             FFTFXTINIT(q31,128);
+            break;
+
+        case 64U:
+             FFTFXTINIT(q31,64);
+            break;
+
+        case 32U:
+             FFTFXTINIT(q31,32);
+            break;
+
+        case 16U:
+            /*  Initializations of structure parameters for 16 point FFT */
+             FFTFXTINIT(q31,16);
+            break;
+
+
+        default:
+            /*  Reporting argument error if fftSize is not valid value */
+            status = ARM_MATH_ARGUMENT_ERROR;
+            break;
+        }
+
+
+        return (status);
 }
 
 arm_status arm_cfft_init_q15(
   arm_cfft_instance_q15 * S,
   uint16_t fftLen)
 {
-        /*  Initialise the default arm status */                                
-        arm_status status = ARM_MATH_SUCCESS;                                   
-                                                                                
-        /*  Initialise the FFT length */                                        
-        S->fftLen = fftLen;          
-                                                                                
-        /*  Initialise the Twiddle coefficient pointer */                       
-        S->pTwiddle = (float32_t *)twiddleCoef_4096;                         
-                                                                                
-                                                                                
+        /*  Initialise the default arm status */
+        arm_status status = ARM_MATH_SUCCESS;
+
+        /*  Initialise the FFT length */
+        S->fftLen = fftLen;
+
+        /*  Initialise the Twiddle coefficient pointer */
+        S->pTwiddle = (float32_t *)twiddleCoef_4096;
+
+
         /*  Initializations of Instance structure depending on the FFT length */
-        switch (S->fftLen) {                                                    
-            /*  Initializations of structure parameters for 4096 point FFT */   
-        case 4096U:                                                             
-            /*  Initialise the bit reversal table modifier */                   
-            FFTFXTINIT(q15,4096);      
-            break;                                                              
-                                                                                
-            /*  Initializations of structure parameters for 2048 point FFT */   
-        case 2048U:                                                             
-            /*  Initialise the bit reversal table modifier */                   
-             FFTFXTINIT(q15,2048);                 
-                                                                            
-            break;                                                              
-                                                                                
-            /*  Initializations of structure parameters for 1024 point FFT */   
-        case 1024U:                                                             
-            /*  Initialise the bit reversal table modifier */                   
-             FFTFXTINIT(q15,1024);                 
-                                                                         
-            break;                                                              
-                                                                                
-            /*  Initializations of structure parameters for 512 point FFT */    
-        case 512U:                                                              
-            /*  Initialise the bit reversal table modifier */                   
-            FFTFXTINIT(q15,512);                                                                                   
-            break;                                                              
-                                                                                
-        case 256U:                                                              
-            FFTFXTINIT(q15,256);                                                                                  
-            break;                                                              
-                                                                                
-        case 128U:                                                              
-            FFTFXTINIT(q15,128);                                                                                  
-            break;                                                              
-                                                                                
-        case 64U:                                                               
-            FFTFXTINIT(q15,64);                                                                               
-            break;                                                              
-                                                                                
-        case 32U:                                                               
-            FFTFXTINIT(q15,32);                                                                                
-            break;                                                              
-                                                                                
-        case 16U:                                                               
-            /*  Initializations of structure parameters for 16 point FFT */     
-            FFTFXTINIT(q15,16);   
-            break;                                                              
-                                                                                
-                                                                                
-        default:                                                                
-            /*  Reporting argument error if fftSize is not valid value */       
-            status = ARM_MATH_ARGUMENT_ERROR;                                   
-            break;                                                              
-        }                                                                       
-                                                                                
-                                                                                
-        return (status);    
-}
+        switch (S->fftLen) {
+            /*  Initializations of structure parameters for 4096 point FFT */
+        case 4096U:
+            /*  Initialise the bit reversal table modifier */
+            FFTFXTINIT(q15,4096);
+            break;
+
+            /*  Initializations of structure parameters for 2048 point FFT */
+        case 2048U:
+            /*  Initialise the bit reversal table modifier */
+             FFTFXTINIT(q15,2048);
+
+            break;
+
+            /*  Initializations of structure parameters for 1024 point FFT */
+        case 1024U:
+            /*  Initialise the bit reversal table modifier */
+             FFTFXTINIT(q15,1024);
+
+            break;
+
+            /*  Initializations of structure parameters for 512 point FFT */
+        case 512U:
+            /*  Initialise the bit reversal table modifier */
+            FFTFXTINIT(q15,512);
+            break;
+
+        case 256U:
+            FFTFXTINIT(q15,256);
+            break;
+
+        case 128U:
+            FFTFXTINIT(q15,128);
+            break;
+
+        case 64U:
+            FFTFXTINIT(q15,64);
+            break;
+
+        case 32U:
+            FFTFXTINIT(q15,32);
+            break;
+
+        case 16U:
+            /*  Initializations of structure parameters for 16 point FFT */
+            FFTFXTINIT(q15,16);
+            break;
+
+
+        default:
+            /*  Reporting argument error if fftSize is not valid value */
+            status = ARM_MATH_ARGUMENT_ERROR;
+            break;
+        }
+
+
+        return (status);
+}

Source/CMakeLists.txt

@@ -58,10 +58,20 @@ option(ARM_SIN_Q31          "sin q31"                           OFF)
 option(ARM_SIN_Q15          "sin q15"                           OFF)
 option(ARM_SIN_COS_F32      "sin cos f32"                       OFF)
 option(ARM_SIN_COS_Q31      "sin cos q31"                       OFF)
-             
+
 option(ARM_LMS_NORM_Q31     "lms norm q31"                      OFF)
 option(ARM_LMS_NORM_Q15     "lms norm q15"                      OFF)
-             
+
+option(CFFT_F64_16          "cfft f64 16"                       OFF)
+option(CFFT_F64_32          "cfft f64 32"                       OFF)
+option(CFFT_F64_64          "cfft f64 64"                       OFF)
+option(CFFT_F64_128         "cfft f64 128"                      OFF)
+option(CFFT_F64_256         "cfft f64 256"                      OFF)
+option(CFFT_F64_512         "cfft f64 512"                      OFF)
+option(CFFT_F64_1024        "cfft f64 1024"                     OFF)
+option(CFFT_F64_2048        "cfft f64 2048"                     OFF)
+option(CFFT_F64_4096        "cfft f64 4096"                     OFF)
+
 option(CFFT_F32_16          "cfft f32 16"                       OFF)
 option(CFFT_F32_32          "cfft f32 32"                       OFF)
 option(CFFT_F32_64          "cfft f32 64"                       OFF)
@@ -71,7 +81,7 @@ option(CFFT_F32_512         "cfft f32 512"                      OFF)
 option(CFFT_F32_1024        "cfft f32 1024"                     OFF)
 option(CFFT_F32_2048        "cfft f32 2048"                     OFF)
 option(CFFT_F32_4096        "cfft f32 4096"                     OFF)
-                  
+
 option(CFFT_Q31_16          "cfft q31 16"                       OFF)
 option(CFFT_Q31_32          "cfft q31 32"                       OFF)
 option(CFFT_Q31_64          "cfft q31 64"                       OFF)
@@ -81,7 +91,7 @@ option(CFFT_Q31_512         "cfft q31 512"                      OFF)
 option(CFFT_Q31_1024        "cfft q31 1024"                     OFF)
 option(CFFT_Q31_2048        "cfft q31 2048"                     OFF)
 option(CFFT_Q31_4096        "cfft q31 4096"                     OFF)
-                  
+
 option(CFFT_Q15_16          "cfft q15 16"                       OFF)
 option(CFFT_Q15_32          "cfft q15 32"                       OFF)
 option(CFFT_Q15_64          "cfft q15 64"                       OFF)
@@ -91,7 +101,7 @@ option(CFFT_Q15_512         "cfft q15 512"                      OFF)
 option(CFFT_Q15_1024        "cfft q15 1024"                     OFF)
 option(CFFT_Q15_2048        "cfft q15 2048"                     OFF)
 option(CFFT_Q15_4096        "cfft q15 4096"                     OFF)
-             
+
 option(RFFT_FAST_F32_32     "rfft fast f32 32"                  OFF)
 option(RFFT_FAST_F32_64     "rfft fast f32 64"                  OFF)
 option(RFFT_FAST_F32_128    "rfft fast f32 128"                 OFF)
@@ -100,13 +110,28 @@ option(RFFT_FAST_F32_512    "rfft fast f32 512"                 OFF)
 option(RFFT_FAST_F32_1024   "rfft fast f32 1024"                OFF)
 option(RFFT_FAST_F32_2048   "rfft fast f32 2048"                OFF)
 option(RFFT_FAST_F32_4096   "rfft fast f32 4096"                OFF)
-             
-             
+
+
 option(RFFT_F32_128         "rfft f32 128"                      OFF)
 option(RFFT_F32_512         "rfft f32 512"                      OFF)
 option(RFFT_F32_2048        "rfft f32 2048"                     OFF)
 option(RFFT_F32_8192        "rfft f32 8192"                     OFF)
-             
+
+option(RFFT_FAST_F64_32     "rfft fast f64 32"                  OFF)
+option(RFFT_FAST_F64_64     "rfft fast f64 64"                  OFF)
+option(RFFT_FAST_F64_128    "rfft fast f64 128"                 OFF)
+option(RFFT_FAST_F64_256    "rfft fast f64 256"                 OFF)
+option(RFFT_FAST_F64_512    "rfft fast f64 512"                 OFF)
+option(RFFT_FAST_F64_1024   "rfft fast f64 1024"                OFF)
+option(RFFT_FAST_F64_2048   "rfft fast f64 2048"                OFF)
+option(RFFT_FAST_F64_4096   "rfft fast f64 4096"                OFF)
+
+
+option(RFFT_F64_128         "rfft f64 128"                      OFF)
+option(RFFT_F64_512         "rfft f64 512"                      OFF)
+option(RFFT_F64_2048        "rfft f64 2048"                     OFF)
+option(RFFT_F64_8192        "rfft f64 8192"                     OFF)
+
 option(RFFT_Q31_32          "rfft q31 32"                       OFF)
 option(RFFT_Q31_64          "rfft q31 64"                       OFF)
 option(RFFT_Q31_128         "rfft q31 128"                      OFF)
@@ -116,7 +141,7 @@ option(RFFT_Q31_1024        "rfft q31 1024"                     OFF)
 option(RFFT_Q31_2048        "rfft q31 2048"                     OFF)
 option(RFFT_Q31_4096        "rfft q31 4096"                     OFF)
 option(RFFT_Q31_8192        "rfft q31 8192"                     OFF)
-             
+
 option(RFFT_Q15_32          "rfft q15 32"                       OFF)
 option(RFFT_Q15_64          "rfft q15 64"                       OFF)
 option(RFFT_Q15_128         "rfft q15 128"                      OFF)
@@ -126,17 +151,17 @@ option(RFFT_Q15_1024        "rfft q15 1024"                     OFF)
 option(RFFT_Q15_2048        "rfft q15 2048"                     OFF)
 option(RFFT_Q15_4096        "rfft q15 4096"                     OFF)
 option(RFFT_Q15_8192        "rfft q15 8192"                     OFF)
-             
+
 option(DCT4_F32_128          "dct4 f32 128"                     OFF)
 option(DCT4_F32_512          "dct4 f32 512"                     OFF)
 option(DCT4_F32_2048         "dct4 f32 2048"                    OFF)
 option(DCT4_F32_8192         "dct4 f32 8192"                    OFF)
-             
+
 option(DCT4_Q31_128          "dct4 q31 128"                     OFF)
 option(DCT4_Q31_512          "dct4 q31 512"                     OFF)
 option(DCT4_Q31_2048         "dct4 q31 2048"                    OFF)
 option(DCT4_Q31_8192         "dct4 q31 8192"                    OFF)
-             
+
 option(DCT4_Q15_128          "dct4 q15 128"                     OFF)
 option(DCT4_Q15_512          "dct4 q15 512"                     OFF)
 option(DCT4_Q15_2048         "dct4 q15 2048"                    OFF)
@@ -167,7 +192,7 @@ if (CONTROLLER)
   add_subdirectory(ControllerFunctions)
   # Fast tables inclusion is allowed
   if (CONFIGTABLE)
-    target_compile_definitions(CMSISDSPController PUBLIC ARM_FAST_ALLOW_TABLES) 
+    target_compile_definitions(CMSISDSPController PUBLIC ARM_FAST_ALLOW_TABLES)
   endif()
   target_link_libraries(CMSISDSP INTERFACE CMSISDSPController)
 endif()
@@ -176,7 +201,7 @@ if (FASTMATH)
   add_subdirectory(FastMathFunctions)
   # Fast tables inclusion is allowed
   if (CONFIGTABLE)
-    target_compile_definitions(CMSISDSPFastMath PUBLIC ARM_FAST_ALLOW_TABLES) 
+    target_compile_definitions(CMSISDSPFastMath PUBLIC ARM_FAST_ALLOW_TABLES)
   endif()
   target_link_libraries(CMSISDSP INTERFACE CMSISDSPFastMath)
 endif()
@@ -186,7 +211,7 @@ if (FILTERING)
   # Fast tables inclusion is allowed
   if (CONFIGTABLE)
     target_compile_definitions(CMSISDSPFiltering PUBLIC ARM_FAST_ALLOW_TABLES)
-  endif() 
+  endif()
   target_link_libraries(CMSISDSP INTERFACE CMSISDSPFiltering)
 endif()
 
@@ -219,13 +244,13 @@ if (FILTERING OR CONTROLLER OR FASTMATH OR TRANSFORM OR SVM OR DISTANCE)
   if (TRANSFORM)
     # FFT tables inclusion is allowed
     if (CONFIGTABLE)
-      target_compile_definitions(CMSISDSPCommon PUBLIC ARM_FFT_ALLOW_TABLES) 
+      target_compile_definitions(CMSISDSPCommon PUBLIC ARM_FFT_ALLOW_TABLES)
     endif()
   endif()
   if (FILTERING OR CONTROLLER OR FASTMATH)
     # Select which tables to include
     if (CONFIGTABLE)
-      target_compile_definitions(CMSISDSPCommon PUBLIC ARM_FAST_ALLOW_TABLES) 
+      target_compile_definitions(CMSISDSPCommon PUBLIC ARM_FAST_ALLOW_TABLES)
     endif()
   endif()
   target_link_libraries(CMSISDSP INTERFACE CMSISDSPCommon)

Source/CommonTables/arm_const_structs.c

@@ -29,7 +29,62 @@
 
 #include "arm_const_structs.h"
 
-#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_FFT_ALLOW_TABLES) 
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_FFT_ALLOW_TABLES)
+
+/* Floating-point structs */
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_16) && defined(ARM_TABLE_BITREVIDX_FLT64_16))
+const arm_cfft_instance_f64 arm_cfft_sR_f64_len16 = {
+  16, (const float64_t *)twiddleCoefF64_16, armBitRevIndexTableF64_16, ARMBITREVINDEXTABLEF64_16_TABLE_LENGTH
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_32) && defined(ARM_TABLE_BITREVIDX_FLT64_32))
+const arm_cfft_instance_f64 arm_cfft_sR_f64_len32 = {
+  32, (const float64_t *)twiddleCoefF64_32, armBitRevIndexTableF64_32, ARMBITREVINDEXTABLEF64_32_TABLE_LENGTH
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_64) && defined(ARM_TABLE_BITREVIDX_FLT64_64))
+const arm_cfft_instance_f64 arm_cfft_sR_f64_len64 = {
+  64, (const float64_t *)twiddleCoefF64_64, armBitRevIndexTableF64_64, ARMBITREVINDEXTABLEF64_64_TABLE_LENGTH
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_128) && defined(ARM_TABLE_BITREVIDX_FLT64_128))
+const arm_cfft_instance_f64 arm_cfft_sR_f64_len128 = {
+  128, (const float64_t *)twiddleCoefF64_128, armBitRevIndexTableF64_128, ARMBITREVINDEXTABLEF64_128_TABLE_LENGTH
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_256) && defined(ARM_TABLE_BITREVIDX_FLT64_256))
+const arm_cfft_instance_f64 arm_cfft_sR_f64_len256 = {
+  256, (const float64_t *)twiddleCoefF64_256, armBitRevIndexTableF64_256, ARMBITREVINDEXTABLEF64_256_TABLE_LENGTH
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_512) && defined(ARM_TABLE_BITREVIDX_FLT64_512))
+const arm_cfft_instance_f64 arm_cfft_sR_f64_len512 = {
+  512, (const float64_t *)twiddleCoefF64_512, armBitRevIndexTableF64_512, ARMBITREVINDEXTABLEF64_512_TABLE_LENGTH
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_1024) && defined(ARM_TABLE_BITREVIDX_FLT64_1024))
+const arm_cfft_instance_f64 arm_cfft_sR_f64_len1024 = {
+  1024, (const float64_t *)twiddleCoefF64_1024, armBitRevIndexTableF64_1024, ARMBITREVINDEXTABLEF64_1024_TABLE_LENGTH
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_2048) && defined(ARM_TABLE_BITREVIDX_FLT64_2048))
+const arm_cfft_instance_f64 arm_cfft_sR_f64_len2048 = {
+  2048, (const float64_t *)twiddleCoefF64_2048, armBitRevIndexTableF64_2048, ARMBITREVINDEXTABLEF64_2048_TABLE_LENGTH
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_4096) && defined(ARM_TABLE_BITREVIDX_FLT64_4096))
+const arm_cfft_instance_f64 arm_cfft_sR_f64_len4096 = {
+  4096, (const float64_t *)twiddleCoefF64_4096, armBitRevIndexTableF64_4096, ARMBITREVINDEXTABLEF64_4096_TABLE_LENGTH
+};
+#endif
 
 /* Floating-point structs */
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F32_16) && defined(ARM_TABLE_BITREVIDX_FLT_16))
@@ -92,103 +147,103 @@ const arm_cfft_instance_f32 arm_cfft_sR_f32_len4096 = {
 const arm_cfft_instance_q31 arm_cfft_sR_q31_len16 = {
   16, twiddleCoef_16_q31, armBitRevIndexTable_fixed_16, ARMBITREVINDEXTABLE_FIXED_16_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q31_32) && defined(ARM_TABLE_BITREVIDX_FXT_32))
 const arm_cfft_instance_q31 arm_cfft_sR_q31_len32 = {
   32, twiddleCoef_32_q31, armBitRevIndexTable_fixed_32, ARMBITREVINDEXTABLE_FIXED_32_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q31_64) && defined(ARM_TABLE_BITREVIDX_FXT_64))
 const arm_cfft_instance_q31 arm_cfft_sR_q31_len64 = {
   64, twiddleCoef_64_q31, armBitRevIndexTable_fixed_64, ARMBITREVINDEXTABLE_FIXED_64_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q31_128) && defined(ARM_TABLE_BITREVIDX_FXT_128))
 const arm_cfft_instance_q31 arm_cfft_sR_q31_len128 = {
   128, twiddleCoef_128_q31, armBitRevIndexTable_fixed_128, ARMBITREVINDEXTABLE_FIXED_128_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q31_256) && defined(ARM_TABLE_BITREVIDX_FXT_256))
 const arm_cfft_instance_q31 arm_cfft_sR_q31_len256 = {
   256, twiddleCoef_256_q31, armBitRevIndexTable_fixed_256, ARMBITREVINDEXTABLE_FIXED_256_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q31_512) && defined(ARM_TABLE_BITREVIDX_FXT_512))
 const arm_cfft_instance_q31 arm_cfft_sR_q31_len512 = {
   512, twiddleCoef_512_q31, armBitRevIndexTable_fixed_512, ARMBITREVINDEXTABLE_FIXED_512_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q31_1024) && defined(ARM_TABLE_BITREVIDX_FXT_1024))
 const arm_cfft_instance_q31 arm_cfft_sR_q31_len1024 = {
   1024, twiddleCoef_1024_q31, armBitRevIndexTable_fixed_1024, ARMBITREVINDEXTABLE_FIXED_1024_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q31_2048) && defined(ARM_TABLE_BITREVIDX_FXT_2048))
 const arm_cfft_instance_q31 arm_cfft_sR_q31_len2048 = {
   2048, twiddleCoef_2048_q31, armBitRevIndexTable_fixed_2048, ARMBITREVINDEXTABLE_FIXED_2048_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q31_4096) && defined(ARM_TABLE_BITREVIDX_FXT_4096))
 const arm_cfft_instance_q31 arm_cfft_sR_q31_len4096 = {
   4096, twiddleCoef_4096_q31, armBitRevIndexTable_fixed_4096, ARMBITREVINDEXTABLE_FIXED_4096_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q15_16) && defined(ARM_TABLE_BITREVIDX_FXT_16))
 const arm_cfft_instance_q15 arm_cfft_sR_q15_len16 = {
   16, twiddleCoef_16_q15, armBitRevIndexTable_fixed_16, ARMBITREVINDEXTABLE_FIXED_16_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q15_32) && defined(ARM_TABLE_BITREVIDX_FXT_32))
 const arm_cfft_instance_q15 arm_cfft_sR_q15_len32 = {
   32, twiddleCoef_32_q15, armBitRevIndexTable_fixed_32, ARMBITREVINDEXTABLE_FIXED_32_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q15_64) && defined(ARM_TABLE_BITREVIDX_FXT_64))
 const arm_cfft_instance_q15 arm_cfft_sR_q15_len64 = {
   64, twiddleCoef_64_q15, armBitRevIndexTable_fixed_64, ARMBITREVINDEXTABLE_FIXED_64_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q15_128) && defined(ARM_TABLE_BITREVIDX_FXT_128))
 const arm_cfft_instance_q15 arm_cfft_sR_q15_len128 = {
   128, twiddleCoef_128_q15, armBitRevIndexTable_fixed_128, ARMBITREVINDEXTABLE_FIXED_128_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q15_256) && defined(ARM_TABLE_BITREVIDX_FXT_256))
 const arm_cfft_instance_q15 arm_cfft_sR_q15_len256 = {
   256, twiddleCoef_256_q15, armBitRevIndexTable_fixed_256, ARMBITREVINDEXTABLE_FIXED_256_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q15_512) && defined(ARM_TABLE_BITREVIDX_FXT_512))
 const arm_cfft_instance_q15 arm_cfft_sR_q15_len512 = {
   512, twiddleCoef_512_q15, armBitRevIndexTable_fixed_512, ARMBITREVINDEXTABLE_FIXED_512_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q15_1024) && defined(ARM_TABLE_BITREVIDX_FXT_1024))
 const arm_cfft_instance_q15 arm_cfft_sR_q15_len1024 = {
   1024, twiddleCoef_1024_q15, armBitRevIndexTable_fixed_1024, ARMBITREVINDEXTABLE_FIXED_1024_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q15_2048) && defined(ARM_TABLE_BITREVIDX_FXT_2048))
 const arm_cfft_instance_q15 arm_cfft_sR_q15_len2048 = {
   2048, twiddleCoef_2048_q15, armBitRevIndexTable_fixed_2048, ARMBITREVINDEXTABLE_FIXED_2048_TABLE_LENGTH
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_Q15_4096) && defined(ARM_TABLE_BITREVIDX_FXT_4096))
 const arm_cfft_instance_q15 arm_cfft_sR_q15_len4096 = {
@@ -197,6 +252,72 @@ const arm_cfft_instance_q15 arm_cfft_sR_q15_len4096 = {
 #endif
 
 /* Structure for real-value inputs */
+/* Double precision strucs */
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_32) && defined(ARM_TABLE_BITREVIDX_FLT64_32) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_32))
+const arm_rfft_fast_instance_f64 arm_rfft_fast_sR_f64_len32 = {
+  { 16, (const float64_t *)twiddleCoefF64_32, armBitRevIndexTableF64_32, ARMBITREVINDEXTABLEF64_16_TABLE_LENGTH },
+  32U,
+  (float64_t *)twiddleCoefF64_rfft_32
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_64) && defined(ARM_TABLE_BITREVIDX_FLT64_64) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_64))
+const arm_rfft_fast_instance_f64 arm_rfft_fast_sR_f64_len64 = {
+   { 32, (const float64_t *)twiddleCoefF64_32, armBitRevIndexTableF64_32, ARMBITREVINDEXTABLEF64_32_TABLE_LENGTH },
+  64U,
+  (float64_t *)twiddleCoefF64_rfft_64
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_128) && defined(ARM_TABLE_BITREVIDX_FLT64_128) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_128))
+const arm_rfft_fast_instance_f64 arm_rfft_fast_sR_f64_len128 = {
+  { 64, (const float64_t *)twiddleCoefF64_64, armBitRevIndexTableF64_64, ARMBITREVINDEXTABLEF64_64_TABLE_LENGTH },
+  128U,
+  (float64_t *)twiddleCoefF64_rfft_128
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_256) && defined(ARM_TABLE_BITREVIDX_FLT64_256) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_256))
+const arm_rfft_fast_instance_f64 arm_rfft_fast_sR_f64_len256 = {
+  { 128, (const float64_t *)twiddleCoefF64_128, armBitRevIndexTableF64_128, ARMBITREVINDEXTABLEF64_128_TABLE_LENGTH },
+  256U,
+  (float64_t *)twiddleCoefF64_rfft_256
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_512) && defined(ARM_TABLE_BITREVIDX_FLT64_512) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_512))
+const arm_rfft_fast_instance_f64 arm_rfft_fast_sR_f64_len512 = {
+  { 256, (const float64_t *)twiddleCoefF64_256, armBitRevIndexTableF64_256, ARMBITREVINDEXTABLEF64_256_TABLE_LENGTH },
+  512U,
+  (float64_t *)twiddleCoefF64_rfft_512
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_1024) && defined(ARM_TABLE_BITREVIDX_FLT64_1024) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_1024))
+const arm_rfft_fast_instance_f64 arm_rfft_fast_sR_f64_len1024 = {
+  { 512, (const float64_t *)twiddleCoefF64_512, armBitRevIndexTableF64_512, ARMBITREVINDEXTABLEF64_512_TABLE_LENGTH },
+  1024U,
+  (float64_t *)twiddleCoefF64_rfft_1024
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_2048) && defined(ARM_TABLE_BITREVIDX_FLT64_2048) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_2048))
+const arm_rfft_fast_instance_f64 arm_rfft_fast_sR_f64_len2048 = {
+  { 1024, (const float64_t *)twiddleCoefF64_1024, armBitRevIndexTableF64_1024, ARMBITREVINDEXTABLEF64_1024_TABLE_LENGTH },
+  2048U,
+  (float64_t *)twiddleCoefF64_rfft_2048
+};
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_4096) && defined(ARM_TABLE_BITREVIDX_FLT64_4096) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_4096))
+const arm_rfft_fast_instance_f64 arm_rfft_fast_sR_f64_len4096 = {
+  { 2048, (const float64_t *)twiddleCoefF64_2048, armBitRevIndexTableF64_2048, ARMBITREVINDEXTABLEF64_2048_TABLE_LENGTH },
+  4096U,
+  (float64_t *)twiddleCoefF64_rfft_4096
+};
+#endif
+
 /* Floating-point structs */
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F32_32) && defined(ARM_TABLE_BITREVIDX_FLT_32) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_32))
@@ -205,7 +326,7 @@ const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len32 = {
   32U,
   (float32_t *)twiddleCoef_rfft_32
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F32_64) && defined(ARM_TABLE_BITREVIDX_FLT_64) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_64))
 const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len64 = {
@@ -213,7 +334,7 @@ const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len64 = {
   64U,
   (float32_t *)twiddleCoef_rfft_64
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F32_128) && defined(ARM_TABLE_BITREVIDX_FLT_128) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_128))
 const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len128 = {
@@ -221,7 +342,7 @@ const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len128 = {
   128U,
   (float32_t *)twiddleCoef_rfft_128
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F32_256) && defined(ARM_TABLE_BITREVIDX_FLT_256) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_256))
 const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len256 = {
@@ -229,7 +350,7 @@ const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len256 = {
   256U,
   (float32_t *)twiddleCoef_rfft_256
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F32_512) && defined(ARM_TABLE_BITREVIDX_FLT_512) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_512))
 const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len512 = {
@@ -237,7 +358,7 @@ const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len512 = {
   512U,
   (float32_t *)twiddleCoef_rfft_512
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F32_1024) && defined(ARM_TABLE_BITREVIDX_FLT_1024) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_1024))
 const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len1024 = {
@@ -245,7 +366,7 @@ const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len1024 = {
   1024U,
   (float32_t *)twiddleCoef_rfft_1024
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F32_2048) && defined(ARM_TABLE_BITREVIDX_FLT_2048) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_2048))
 const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len2048 = {
@@ -253,7 +374,7 @@ const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len2048 = {
   2048U,
   (float32_t *)twiddleCoef_rfft_2048
 };
-#endif 
+#endif
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F32_4096) && defined(ARM_TABLE_BITREVIDX_FLT_4096) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F32_4096))
 const arm_rfft_fast_instance_f32 arm_rfft_fast_sR_f32_len4096 = {

Source/TransformFunctions/CMakeLists.txt

@@ -27,6 +27,11 @@ target_sources(CMSISDSPTransform PRIVATE arm_cfft_radix8_f32.c)
 target_sources(CMSISDSPTransform PRIVATE arm_cfft_f32.c)
 endif()
 
+if (NOT CONFIGTABLE OR ALLFFT OR CFFT_F64_16 OR CFFT_F64_32 OR CFFT_F64_64 OR CFFT_F64_128 OR CFFT_F64_256 OR CFFT_F64_512 
+    OR CFFT_F64_1024 OR CFFT_F64_2048 OR CFFT_F64_4096)
+target_sources(CMSISDSPTransform PRIVATE arm_cfft_f64.c)
+endif()
+
 if (NOT CONFIGTABLE OR ALLFFT OR CFFT_Q15_16 OR CFFT_Q15_32 OR CFFT_Q15_64 OR CFFT_Q15_128 OR CFFT_Q15_256 OR CFFT_Q15_512 
     OR CFFT_Q15_1024 OR CFFT_Q15_2048 OR CFFT_Q15_4096)
 target_sources(CMSISDSPTransform PRIVATE arm_cfft_radix2_q15.c)
@@ -87,6 +92,15 @@ target_sources(CMSISDSPTransform PRIVATE arm_cfft_f32.c)
 target_sources(CMSISDSPTransform PRIVATE arm_cfft_radix8_f32.c)
 endif()
 
+if (NOT CONFIGTABLE OR ALLFFT OR RFFT_FAST_F64_32 OR RFFT_FAST_F64_64 OR RFFT_FAST_F64_128
+   OR RFFT_FAST_F64_256 OR RFFT_FAST_F64_512 OR RFFT_FAST_F64_1024 OR RFFT_FAST_F64_2048
+   OR RFFT_FAST_F64_4096 )
+target_sources(CMSISDSPTransform PRIVATE arm_rfft_fast_f64.c)
+target_sources(CMSISDSPTransform PRIVATE arm_rfft_fast_init_f64.c)
+endif()
+
+
+
 if (NOT CONFIGTABLE OR ALLFFT OR RFFT_F32_128 OR RFFT_F32_512 OR RFFT_F32_2048 OR RFFT_F32_8192)
 target_sources(CMSISDSPTransform PRIVATE arm_rfft_init_f32.c)
 target_sources(CMSISDSPTransform PRIVATE arm_rfft_f32.c)

Source/TransformFunctions/arm_bitreversal2.c

@@ -29,6 +29,41 @@
 #include "arm_math.h"
 #include "arm_common_tables.h"
 
+
+/**
+  @brief         In-place 64 bit reversal function.
+  @param[in,out] pSrc        points to in-place buffer of unknown 64-bit data type
+  @param[in]     bitRevLen   bit reversal table length
+  @param[in]     pBitRevTab  points to bit reversal table
+  @return        none
+*/
+
+void arm_bitreversal_64(
+        uint64_t *pSrc,
+  const uint16_t bitRevLen,
+  const uint16_t *pBitRevTab)
+{
+  uint64_t a, b, i, tmp;
+
+  for (i = 0; i < bitRevLen; )
+  {
+     a = pBitRevTab[i    ] >> 2;
+     b = pBitRevTab[i + 1] >> 2;
+
+     //real
+     tmp = pSrc[a];
+     pSrc[a] = pSrc[b];
+     pSrc[b] = tmp;
+
+     //complex
+     tmp = pSrc[a+1];
+     pSrc[a+1] = pSrc[b+1];
+     pSrc[b+1] = tmp;
+
+    i += 2;
+  }
+}
+
 /**
   @brief         In-place 32 bit reversal function.
   @param[in,out] pSrc        points to in-place buffer of unknown 32-bit data type
@@ -38,8 +73,8 @@
 */
 
 void arm_bitreversal_32(
-        uint32_t *pSrc, 
-  const uint16_t bitRevLen, 
+        uint32_t *pSrc,
+  const uint16_t bitRevLen,
   const uint16_t *pBitRevTab)
 {
   uint32_t a, b, i, tmp;
@@ -73,8 +108,8 @@ void arm_bitreversal_32(
 */
 
 void arm_bitreversal_16(
-        uint16_t *pSrc, 
-  const uint16_t bitRevLen, 
+        uint16_t *pSrc,
+  const uint16_t bitRevLen,
   const uint16_t *pBitRevTab)
 {
   uint16_t a, b, i, tmp;

Source/TransformFunctions/arm_cfft_f64.c

@@ -0,0 +1,318 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_cfft_f64.c
+ * Description:  Combined Radix Decimation in Frequency CFFT Double Precision Floating point processing function
+ *
+ * $Date:        29. November 2019
+ * $Revision:    V1.0.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arm_math.h"
+#include "arm_common_tables.h"
+
+
+extern void arm_radix4_butterfly_f64(
+        float64_t * pSrc,
+        uint16_t fftLen,
+  const float64_t * pCoef,
+        uint16_t twidCoefModifier);
+
+extern void arm_bitreversal_64(
+        uint64_t * pSrc,
+  const uint16_t   bitRevLen,
+  const uint16_t * pBitRevTable);
+
+/**
+* @} end of ComplexFFT group
+*/
+
+/* ----------------------------------------------------------------------
+ * Internal helper function used by the FFTs
+ * ---------------------------------------------------------------------- */
+
+/*
+* @brief  Core function for the Double Precision floating-point CFFT butterfly process.
+* @param[in, out] *pSrc            points to the in-place buffer of F64 data type.
+* @param[in]      fftLen           length of the FFT.
+* @param[in]      *pCoef           points to the twiddle coefficient buffer.
+* @param[in]      twidCoefModifier twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table.
+* @return none.
+*/
+
+void arm_radix4_butterfly_f64(
+        float64_t * pSrc,
+        uint16_t fftLen,
+  const float64_t * pCoef,
+        uint16_t twidCoefModifier)
+{
+
+   float64_t co1, co2, co3, si1, si2, si3;
+   uint32_t ia1, ia2, ia3;
+   uint32_t i0, i1, i2, i3;
+   uint32_t n1, n2, j, k;
+
+   float64_t t1, t2, r1, r2, s1, s2;
+
+
+   /*  Initializations for the fft calculation */
+   n2 = fftLen;
+   n1 = n2;
+   for (k = fftLen; k > 1U; k >>= 2U)
+   {
+      /*  Initializations for the fft calculation */
+      n1 = n2;
+      n2 >>= 2U;
+      ia1 = 0U;
+
+      /*  FFT Calculation */
+      j = 0;
+      do
+      {
+         /*  index calculation for the coefficients */
+         ia2 = ia1 + ia1;
+         ia3 = ia2 + ia1;
+         co1 = pCoef[ia1 * 2U];
+         si1 = pCoef[(ia1 * 2U) + 1U];
+         co2 = pCoef[ia2 * 2U];
+         si2 = pCoef[(ia2 * 2U) + 1U];
+         co3 = pCoef[ia3 * 2U];
+         si3 = pCoef[(ia3 * 2U) + 1U];
+
+         /*  Twiddle coefficients index modifier */
+         ia1 = ia1 + twidCoefModifier;
+
+         i0 = j;
+         do
+         {
+            /*  index calculation for the input as, */
+            /*  pSrc[i0 + 0], pSrc[i0 + fftLen/4], pSrc[i0 + fftLen/2], pSrc[i0 + 3fftLen/4] */
+            i1 = i0 + n2;
+            i2 = i1 + n2;
+            i3 = i2 + n2;
+
+            /* xa + xc */
+            r1 = pSrc[(2U * i0)] + pSrc[(2U * i2)];
+
+            /* xa - xc */
+            r2 = pSrc[(2U * i0)] - pSrc[(2U * i2)];
+
+            /* ya + yc */
+            s1 = pSrc[(2U * i0) + 1U] + pSrc[(2U * i2) + 1U];
+
+            /* ya - yc */
+            s2 = pSrc[(2U * i0) + 1U] - pSrc[(2U * i2) + 1U];
+
+            /* xb + xd */
+            t1 = pSrc[2U * i1] + pSrc[2U * i3];
+
+            /* xa' = xa + xb + xc + xd */
+            pSrc[2U * i0] = r1 + t1;
+
+            /* xa + xc -(xb + xd) */
+            r1 = r1 - t1;
+
+            /* yb + yd */
+            t2 = pSrc[(2U * i1) + 1U] + pSrc[(2U * i3) + 1U];
+
+            /* ya' = ya + yb + yc + yd */
+            pSrc[(2U * i0) + 1U] = s1 + t2;
+
+            /* (ya + yc) - (yb + yd) */
+            s1 = s1 - t2;
+
+            /* (yb - yd) */
+            t1 = pSrc[(2U * i1) + 1U] - pSrc[(2U * i3) + 1U];
+
+            /* (xb - xd) */
+            t2 = pSrc[2U * i1] - pSrc[2U * i3];
+
+            /* xc' = (xa-xb+xc-xd)co2 + (ya-yb+yc-yd)(si2) */
+            pSrc[2U * i1] = (r1 * co2) + (s1 * si2);
+
+            /* yc' = (ya-yb+yc-yd)co2 - (xa-xb+xc-xd)(si2) */
+            pSrc[(2U * i1) + 1U] = (s1 * co2) - (r1 * si2);
+
+            /* (xa - xc) + (yb - yd) */
+            r1 = r2 + t1;
+
+            /* (xa - xc) - (yb - yd) */
+            r2 = r2 - t1;
+
+            /* (ya - yc) -  (xb - xd) */
+            s1 = s2 - t2;
+
+            /* (ya - yc) +  (xb - xd) */
+            s2 = s2 + t2;
+
+            /* xb' = (xa+yb-xc-yd)co1 + (ya-xb-yc+xd)(si1) */
+            pSrc[2U * i2] = (r1 * co1) + (s1 * si1);
+
+            /* yb' = (ya-xb-yc+xd)co1 - (xa+yb-xc-yd)(si1) */
+            pSrc[(2U * i2) + 1U] = (s1 * co1) - (r1 * si1);
+
+            /* xd' = (xa-yb-xc+yd)co3 + (ya+xb-yc-xd)(si3) */
+            pSrc[2U * i3] = (r2 * co3) + (s2 * si3);
+
+            /* yd' = (ya+xb-yc-xd)co3 - (xa-yb-xc+yd)(si3) */
+            pSrc[(2U * i3) + 1U] = (s2 * co3) - (r2 * si3);
+
+            i0 += n1;
+         } while ( i0 < fftLen);
+         j++;
+      } while (j <= (n2 - 1U));
+      twidCoefModifier <<= 2U;
+   }
+}
+
+/*
+* @brief  Core function for the Double Precision floating-point CFFT butterfly process.
+* @param[in, out] *pSrc            points to the in-place buffer of F64 data type.
+* @param[in]      fftLen           length of the FFT.
+* @param[in]      *pCoef           points to the twiddle coefficient buffer.
+* @param[in]      twidCoefModifier twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table.
+* @return none.
+*/
+
+void arm_cfft_radix4by2_f64(
+    float64_t * pSrc,
+    uint32_t fftLen,
+    const float64_t * pCoef)
+{
+    uint32_t i, l;
+    uint32_t n2, ia;
+    float64_t xt, yt, cosVal, sinVal;
+    float64_t p0, p1,p2,p3,a0,a1;
+
+    n2 = fftLen >> 1;
+    ia = 0;
+    for (i = 0; i < n2; i++)
+    {
+        cosVal = pCoef[2*ia];
+        sinVal = pCoef[2*ia + 1];
+        ia++;
+
+        l = i + n2;
+
+        /*  Butterfly implementation */
+        a0 = pSrc[2 * i] + pSrc[2 * l];
+        xt = pSrc[2 * i] - pSrc[2 * l];
+
+        yt = pSrc[2 * i + 1] - pSrc[2 * l + 1];
+        a1 = pSrc[2 * l + 1] + pSrc[2 * i + 1];
+
+        p0 = xt * cosVal;
+        p1 = yt * sinVal;
+        p2 = yt * cosVal;
+        p3 = xt * sinVal;
+
+        pSrc[2 * i]     = a0;
+        pSrc[2 * i + 1] = a1;
+
+        pSrc[2 * l]     = p0 + p1;
+        pSrc[2 * l + 1] = p2 - p3;
+
+    }
+
+    // first col
+    arm_radix4_butterfly_f64( pSrc, n2, (float64_t*)pCoef, 2U);
+    // second col
+    arm_radix4_butterfly_f64( pSrc + fftLen, n2, (float64_t*)pCoef, 2U);
+
+}
+
+/**
+  @addtogroup ComplexFFT
+  @{
+ */
+
+/**
+  @brief         Processing function for the Double Precision floating-point complex FFT.
+  @param[in]     S              points to an instance of the Double Precision floating-point CFFT structure
+  @param[in,out] p1             points to the complex data buffer of size <code>2*fftLen</code>. Processing occurs in-place
+  @param[in]     ifftFlag       flag that selects transform direction
+                   - value = 0: forward transform
+                   - value = 1: inverse transform
+  @param[in]     bitReverseFlag flag that enables / disables bit reversal of output
+                   - value = 0: disables bit reversal of output
+                   - value = 1: enables bit reversal of output
+  @return        none
+ */
+
+void arm_cfft_f64(
+  const arm_cfft_instance_f64 * S,
+        float64_t * p1,
+        uint8_t ifftFlag,
+        uint8_t bitReverseFlag)
+{
+    uint32_t  L = S->fftLen, l;
+    float64_t invL, * pSrc;
+
+    if (ifftFlag == 1U)
+    {
+        /*  Conjugate input data  */
+        pSrc = p1 + 1;
+        for(l=0; l<L; l++)
+        {
+            *pSrc = -*pSrc;
+            pSrc += 2;
+        }
+    }
+
+    switch (L)
+    {
+        case 16:
+        case 64:
+        case 256:
+        case 1024:
+        case 4096:
+        arm_radix4_butterfly_f64  (p1, L, (float64_t*)S->pTwiddle, 1U);
+        break;
+
+        case 32:
+        case 128:
+        case 512:
+        case 2048:
+        arm_cfft_radix4by2_f64  ( p1, L, (float64_t*)S->pTwiddle);
+        break;
+
+    }
+
+    if ( bitReverseFlag )
+        arm_bitreversal_64((uint64_t*)p1, S->bitRevLength,S->pBitRevTable);
+
+    if (ifftFlag == 1U)
+    {
+        invL = 1.0 / (float64_t)L;
+        /*  Conjugate and scale output data */
+        pSrc = p1;
+        for(l=0; l<L; l++)
+        {
+            *pSrc++ *=   invL ;
+            *pSrc  = -(*pSrc) * invL;
+            pSrc++;
+        }
+    }
+}
+
+/**
+  @} end of ComplexFFT group
+ */

Source/TransformFunctions/arm_rfft_fast_f64.c

@@ -0,0 +1,228 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_rfft_f64.c
+ * Description:  RFFT & RIFFT Double precision Floating point process function
+ *
+ * $Date:        29. November 2019
+ * $Revision:    V1.0.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arm_math.h"
+
+void stage_rfft_f64(
+  const arm_rfft_fast_instance_f64 * S,
+        float64_t * p,
+        float64_t * pOut)
+{
+        uint32_t  k;                                /* Loop Counter */
+        float64_t twR, twI;                         /* RFFT Twiddle coefficients */
+  const float64_t * pCoeff = S->pTwiddleRFFT;       /* Points to RFFT Twiddle factors */
+        float64_t *pA = p;                          /* increasing pointer */
+        float64_t *pB = p;                          /* decreasing pointer */
+        float64_t xAR, xAI, xBR, xBI;               /* temporary variables */
+        float64_t t1a, t1b;                         /* temporary variables */
+        float64_t p0, p1, p2, p3;                   /* temporary variables */
+
+
+   k = (S->Sint).fftLen - 1;
+
+   /* Pack first and last sample of the frequency domain together */
+
+   xBR = pB[0];
+   xBI = pB[1];
+   xAR = pA[0];
+   xAI = pA[1];
+
+   twR = *pCoeff++ ;
+   twI = *pCoeff++ ;
+
+   // U1 = XA(1) + XB(1); % It is real
+   t1a = xBR + xAR  ;
+
+   // U2 = XB(1) - XA(1); % It is imaginary
+   t1b = xBI + xAI  ;
+
+   // real(tw * (xB - xA)) = twR * (xBR - xAR) - twI * (xBI - xAI);
+   // imag(tw * (xB - xA)) = twI * (xBR - xAR) + twR * (xBI - xAI);
+   *pOut++ = 0.5 * ( t1a + t1b );
+   *pOut++ = 0.5 * ( t1a - t1b );
+
+   // XA(1) = 1/2*( U1 - imag(U2) +  i*( U1 +imag(U2) ));
+   pB  = p + 2*k;
+   pA += 2;
+
+   do
+   {
+      /*
+         function X = my_split_rfft(X, ifftFlag)
+         % X is a series of real numbers
+         L  = length(X);
+         XC = X(1:2:end) +i*X(2:2:end);
+         XA = fft(XC);
+         XB = conj(XA([1 end:-1:2]));
+         TW = i*exp(-2*pi*i*[0:L/2-1]/L).';
+         for l = 2:L/2
+            XA(l) = 1/2 * (XA(l) + XB(l) + TW(l) * (XB(l) - XA(l)));
+         end
+         XA(1) = 1/2* (XA(1) + XB(1) + TW(1) * (XB(1) - XA(1))) + i*( 1/2*( XA(1) + XB(1) + i*( XA(1) - XB(1))));
+         X = XA;
+      */
+
+      xBI = pB[1];
+      xBR = pB[0];
+      xAR = pA[0];
+      xAI = pA[1];
+
+      twR = *pCoeff++;
+      twI = *pCoeff++;
+
+      t1a = xBR - xAR ;
+      t1b = xBI + xAI ;
+
+      // real(tw * (xB - xA)) = twR * (xBR - xAR) - twI * (xBI - xAI);
+      // imag(tw * (xB - xA)) = twI * (xBR - xAR) + twR * (xBI - xAI);
+      p0 = twR * t1a;
+      p1 = twI * t1a;
+      p2 = twR * t1b;
+      p3 = twI * t1b;
+
+      *pOut++ = 0.5 * (xAR + xBR + p0 + p3 ); //xAR
+      *pOut++ = 0.5 * (xAI - xBI + p1 - p2 ); //xAI
+
+      pA += 2;
+      pB -= 2;
+      k--;
+   } while (k > 0U);
+}
+
+/* Prepares data for inverse cfft */
+void merge_rfft_f64(
+  const arm_rfft_fast_instance_f64 * S,
+        float64_t * p,
+        float64_t * pOut)
+{
+        uint32_t  k;                                /* Loop Counter */
+        float64_t twR, twI;                         /* RFFT Twiddle coefficients */
+  const float64_t *pCoeff = S->pTwiddleRFFT;        /* Points to RFFT Twiddle factors */
+        float64_t *pA = p;                          /* increasing pointer */
+        float64_t *pB = p;                          /* decreasing pointer */
+        float64_t xAR, xAI, xBR, xBI;               /* temporary variables */
+        float64_t t1a, t1b, r, s, t, u;             /* temporary variables */
+
+   k = (S->Sint).fftLen - 1;
+
+   xAR = pA[0];
+   xAI = pA[1];
+
+   pCoeff += 2 ;
+
+   *pOut++ = 0.5 * ( xAR + xAI );
+   *pOut++ = 0.5 * ( xAR - xAI );
+
+   pB  =  p + 2*k ;
+   pA +=  2	   ;
+
+   while (k > 0U)
+   {
+      /* G is half of the frequency complex spectrum */
+      //for k = 2:N
+      //    Xk(k) = 1/2 * (G(k) + conj(G(N-k+2)) + Tw(k)*( G(k) - conj(G(N-k+2))));
+      xBI =   pB[1]    ;
+      xBR =   pB[0]    ;
+      xAR =  pA[0];
+      xAI =  pA[1];
+
+      twR = *pCoeff++;
+      twI = *pCoeff++;
+
+      t1a = xAR - xBR ;
+      t1b = xAI + xBI ;
+
+      r = twR * t1a;
+      s = twI * t1b;
+      t = twI * t1a;
+      u = twR * t1b;
+
+      // real(tw * (xA - xB)) = twR * (xAR - xBR) - twI * (xAI - xBI);
+      // imag(tw * (xA - xB)) = twI * (xAR - xBR) + twR * (xAI - xBI);
+      *pOut++ = 0.5 * (xAR + xBR - r - s ); //xAR
+      *pOut++ = 0.5 * (xAI - xBI + t - u ); //xAI
+
+      pA += 2;
+      pB -= 2;
+      k--;
+   }
+
+}
+
+/**
+  @ingroup groupTransforms
+*/
+
+
+/**
+  @addtogroup RealFFT
+  @{
+*/
+
+/**
+  @brief         Processing function for the Double Precision floating-point real FFT.
+  @param[in]     S         points to an arm_rfft_fast_instance_f64 structure
+  @param[in]     p         points to input buffer (Source buffer is modified by this function.)
+  @param[in]     pOut      points to output buffer
+  @param[in]     ifftFlag
+                   - value = 0: RFFT
+                   - value = 1: RIFFT
+  @return        none
+*/
+
+void arm_rfft_fast_f64(
+  arm_rfft_fast_instance_f64 * S,
+  float64_t * p,
+  float64_t * pOut,
+  uint8_t ifftFlag)
+{
+   arm_cfft_instance_f64 * Sint = &(S->Sint);
+   Sint->fftLen = S->fftLenRFFT / 2;
+
+   /* Calculation of Real FFT */
+   if (ifftFlag)
+   {
+      /*  Real FFT compression */
+      merge_rfft_f64(S, p, pOut);
+
+      /* Complex radix-4 IFFT process */
+      arm_cfft_f64( Sint, pOut, ifftFlag, 1);
+   }
+   else
+   {
+      /* Calculation of RFFT of input */
+      arm_cfft_f64( Sint, p, ifftFlag, 1);
+
+      /*  Real FFT extraction */
+      stage_rfft_f64(S, p, pOut);
+   }
+}
+
+/**
+* @} end of RealFFT group
+*/

Source/TransformFunctions/arm_rfft_fast_init_f64.c

@@ -0,0 +1,344 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_cfft_init_f64.c
+ * Description:  Split Radix Decimation in Frequency CFFT Double Precision Floating point processing function
+ *
+ * $Date:        29. November 2019
+ * $Revision:    V1.0.0
+ *
+ * Target Processor: Cortex-M cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arm_math.h"
+#include "arm_common_tables.h"
+
+/**
+  @ingroup groupTransforms
+ */
+
+/**
+  @addtogroup RealFFT
+  @{
+ */
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_16) && defined(ARM_TABLE_BITREVIDX_FLT64_16) && defined(ARM_TABLE_TWIDDLECOEF_F64_16) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_32))
+
+/**
+  @brief         Initialization function for the 32pt double precision floating-point real FFT.
+  @param[in,out] S  points to an arm_rfft_fast_instance_f64 structure
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : Operation successful
+                   - \ref ARM_MATH_ARGUMENT_ERROR : an error is detected
+ */
+
+arm_status arm_rfft_32_fast_init_f64( arm_rfft_fast_instance_f64 * S ) {
+
+  arm_cfft_instance_f64 * Sint;
+
+  if( !S ) return ARM_MATH_ARGUMENT_ERROR;
+
+  Sint = &(S->Sint);
+  Sint->fftLen = 16U;
+  S->fftLenRFFT = 32U;
+
+  Sint->bitRevLength = ARMBITREVINDEXTABLEF64_16_TABLE_LENGTH;
+  Sint->pBitRevTable = (uint16_t *)armBitRevIndexTableF64_16;
+  Sint->pTwiddle     = (float64_t *) twiddleCoefF64_16;
+  S->pTwiddleRFFT    = (float64_t *) twiddleCoefF64_rfft_32;
+
+  return ARM_MATH_SUCCESS;
+}
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_32) && defined(ARM_TABLE_BITREVIDX_FLT64_32) && defined(ARM_TABLE_TWIDDLECOEF_F64_32) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_64))
+
+/**
+  @brief         Initialization function for the 64pt Double Precision floating-point real FFT.
+  @param[in,out] S  points to an arm_rfft_fast_instance_f64 structure
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : Operation successful
+                   - \ref ARM_MATH_ARGUMENT_ERROR : an error is detected
+ */
+
+arm_status arm_rfft_64_fast_init_f64( arm_rfft_fast_instance_f64 * S ) {
+
+  arm_cfft_instance_f64 * Sint;
+
+  if( !S ) return ARM_MATH_ARGUMENT_ERROR;
+
+  Sint = &(S->Sint);
+  Sint->fftLen = 32U;
+  S->fftLenRFFT = 64U;
+
+  Sint->bitRevLength = ARMBITREVINDEXTABLEF64_32_TABLE_LENGTH;
+  Sint->pBitRevTable = (uint16_t *)armBitRevIndexTableF64_32;
+  Sint->pTwiddle     = (float64_t *) twiddleCoefF64_32;
+  S->pTwiddleRFFT    = (float64_t *) twiddleCoefF64_rfft_64;
+
+  return ARM_MATH_SUCCESS;
+}
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_64) && defined(ARM_TABLE_BITREVIDX_FLT64_64) && defined(ARM_TABLE_TWIDDLECOEF_F64_64) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_128))
+
+/**
+  @brief         Initialization function for the 128pt Double Precision floating-point real FFT.
+  @param[in,out] S  points to an arm_rfft_fast_instance_f64 structure
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : Operation successful
+                   - \ref ARM_MATH_ARGUMENT_ERROR : an error is detected
+ */
+
+arm_status arm_rfft_128_fast_init_f64( arm_rfft_fast_instance_f64 * S ) {
+
+  arm_cfft_instance_f64 * Sint;
+
+  if( !S ) return ARM_MATH_ARGUMENT_ERROR;
+
+  Sint = &(S->Sint);
+  Sint->fftLen = 64U;
+  S->fftLenRFFT = 128U;
+
+  Sint->bitRevLength = ARMBITREVINDEXTABLEF64_64_TABLE_LENGTH;
+  Sint->pBitRevTable = (uint16_t *)armBitRevIndexTableF64_64;
+  Sint->pTwiddle     = (float64_t *) twiddleCoefF64_64;
+  S->pTwiddleRFFT    = (float64_t *) twiddleCoefF64_rfft_128;
+
+  return ARM_MATH_SUCCESS;
+}
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_128) && defined(ARM_TABLE_BITREVIDX_FLT64_128) && defined(ARM_TABLE_TWIDDLECOEF_F64_128) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_256))
+
+/**
+  @brief         Initialization function for the 256pt Double Precision floating-point real FFT.
+  @param[in,out] S  points to an arm_rfft_fast_instance_f64 structure
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : Operation successful
+                   - \ref ARM_MATH_ARGUMENT_ERROR : an error is detected
+*/
+
+arm_status arm_rfft_256_fast_init_f64( arm_rfft_fast_instance_f64 * S ) {
+
+  arm_cfft_instance_f64 * Sint;
+
+  if( !S ) return ARM_MATH_ARGUMENT_ERROR;
+
+  Sint = &(S->Sint);
+  Sint->fftLen = 128U;
+  S->fftLenRFFT = 256U;
+
+  Sint->bitRevLength = ARMBITREVINDEXTABLEF64_128_TABLE_LENGTH;
+  Sint->pBitRevTable = (uint16_t *)armBitRevIndexTableF64_128;
+  Sint->pTwiddle     = (float64_t *) twiddleCoefF64_128;
+  S->pTwiddleRFFT    = (float64_t *) twiddleCoefF64_rfft_256;
+
+  return ARM_MATH_SUCCESS;
+}
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_256) && defined(ARM_TABLE_BITREVIDX_FLT64_256) && defined(ARM_TABLE_TWIDDLECOEF_F64_256) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_512))
+
+/**
+  @brief         Initialization function for the 512pt Double Precision floating-point real FFT.
+  @param[in,out] S  points to an arm_rfft_fast_instance_f64 structure
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : Operation successful
+                   - \ref ARM_MATH_ARGUMENT_ERROR : an error is detected
+ */
+
+arm_status arm_rfft_512_fast_init_f64( arm_rfft_fast_instance_f64 * S ) {
+
+  arm_cfft_instance_f64 * Sint;
+
+  if( !S ) return ARM_MATH_ARGUMENT_ERROR;
+
+  Sint = &(S->Sint);
+  Sint->fftLen = 256U;
+  S->fftLenRFFT = 512U;
+
+  Sint->bitRevLength = ARMBITREVINDEXTABLEF64_256_TABLE_LENGTH;
+  Sint->pBitRevTable = (uint16_t *)armBitRevIndexTableF64_256;
+  Sint->pTwiddle     = (float64_t *) twiddleCoefF64_256;
+  S->pTwiddleRFFT    = (float64_t *) twiddleCoefF64_rfft_512;
+
+  return ARM_MATH_SUCCESS;
+}
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_512) && defined(ARM_TABLE_BITREVIDX_FLT64_512) && defined(ARM_TABLE_TWIDDLECOEF_F64_512) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_1024))
+/**
+  @brief         Initialization function for the 1024pt Double Precision floating-point real FFT.
+  @param[in,out] S  points to an arm_rfft_fast_instance_f64 structure
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : Operation successful
+                   - \ref ARM_MATH_ARGUMENT_ERROR : an error is detected
+ */
+
+arm_status arm_rfft_1024_fast_init_f64( arm_rfft_fast_instance_f64 * S ) {
+
+  arm_cfft_instance_f64 * Sint;
+
+  if( !S ) return ARM_MATH_ARGUMENT_ERROR;
+
+  Sint = &(S->Sint);
+  Sint->fftLen = 512U;
+  S->fftLenRFFT = 1024U;
+
+  Sint->bitRevLength = ARMBITREVINDEXTABLEF64_512_TABLE_LENGTH;
+  Sint->pBitRevTable = (uint16_t *)armBitRevIndexTableF64_512;
+  Sint->pTwiddle     = (float64_t *) twiddleCoefF64_512;
+  S->pTwiddleRFFT    = (float64_t *) twiddleCoefF64_rfft_1024;
+
+  return ARM_MATH_SUCCESS;
+}
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_1024) && defined(ARM_TABLE_BITREVIDX_FLT64_1024) && defined(ARM_TABLE_TWIDDLECOEF_F64_1024) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_2048))
+/**
+  @brief         Initialization function for the 2048pt Double Precision floating-point real FFT.
+  @param[in,out] S  points to an arm_rfft_fast_instance_f64 structure
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : Operation successful
+                   - \ref ARM_MATH_ARGUMENT_ERROR : an error is detected
+ */
+arm_status arm_rfft_2048_fast_init_f64( arm_rfft_fast_instance_f64 * S ) {
+
+  arm_cfft_instance_f64 * Sint;
+
+  if( !S ) return ARM_MATH_ARGUMENT_ERROR;
+
+  Sint = &(S->Sint);
+  Sint->fftLen = 1024U;
+  S->fftLenRFFT = 2048U;
+
+  Sint->bitRevLength = ARMBITREVINDEXTABLEF64_1024_TABLE_LENGTH;
+  Sint->pBitRevTable = (uint16_t *)armBitRevIndexTableF64_1024;
+  Sint->pTwiddle     = (float64_t *) twiddleCoefF64_1024;
+  S->pTwiddleRFFT    = (float64_t *) twiddleCoefF64_rfft_2048;
+
+  return ARM_MATH_SUCCESS;
+}
+#endif
+
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_2048) && defined(ARM_TABLE_BITREVIDX_FLT64_2048) && defined(ARM_TABLE_TWIDDLECOEF_F64_2048) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_4096))
+/**
+* @brief         Initialization function for the 4096pt Double Precision floating-point real FFT.
+* @param[in,out] S  points to an arm_rfft_fast_instance_f64 structure
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : Operation successful
+                   - \ref ARM_MATH_ARGUMENT_ERROR : an error is detected
+ */
+
+arm_status arm_rfft_4096_fast_init_f64( arm_rfft_fast_instance_f64 * S ) {
+
+  arm_cfft_instance_f64 * Sint;
+
+  if( !S ) return ARM_MATH_ARGUMENT_ERROR;
+
+  Sint = &(S->Sint);
+  Sint->fftLen = 2048U;
+  S->fftLenRFFT = 4096U;
+
+  Sint->bitRevLength = ARMBITREVINDEXTABLEF64_2048_TABLE_LENGTH;
+  Sint->pBitRevTable = (uint16_t *)armBitRevIndexTableF64_2048;
+  Sint->pTwiddle     = (float64_t *) twiddleCoefF64_2048;
+  S->pTwiddleRFFT    = (float64_t *) twiddleCoefF64_rfft_4096;
+
+  return ARM_MATH_SUCCESS;
+}
+#endif
+
+/**
+  @brief         Initialization function for the Double Precision floating-point real FFT.
+  @param[in,out] S       points to an arm_rfft_fast_instance_f64 structure
+  @param[in]     fftLen  length of the Real Sequence
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : Operation successful
+                   - \ref ARM_MATH_ARGUMENT_ERROR : <code>fftLen</code> is not a supported length
+
+  @par           Description
+                   The parameter <code>fftLen</code> specifies the length of RFFT/CIFFT process.
+                   Supported FFT Lengths are 32, 64, 128, 256, 512, 1024, 2048, 4096.
+  @par
+                   This Function also initializes Twiddle factor table pointer and Bit reversal table pointer.
+ */
+
+arm_status arm_rfft_fast_init_f64(
+  arm_rfft_fast_instance_f64 * S,
+  uint16_t fftLen)
+{
+  typedef arm_status(*fft_init_ptr)( arm_rfft_fast_instance_f64 *);
+  fft_init_ptr fptr = 0x0;
+
+  switch (fftLen)
+  {
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_2048) && defined(ARM_TABLE_BITREVIDX_FLT64_2048) && defined(ARM_TABLE_TWIDDLECOEF_F64_2048) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_4096))
+  case 4096U:
+    fptr = arm_rfft_4096_fast_init_f64;
+    break;
+#endif
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_1024) && defined(ARM_TABLE_BITREVIDX_FLT64_1024) && defined(ARM_TABLE_TWIDDLECOEF_F64_1024) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_2048))
+  case 2048U:
+    fptr = arm_rfft_2048_fast_init_f64;
+    break;
+#endif
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_512) && defined(ARM_TABLE_BITREVIDX_FLT64_512) && defined(ARM_TABLE_TWIDDLECOEF_F64_512) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_1024))
+  case 1024U:
+    fptr = arm_rfft_1024_fast_init_f64;
+    break;
+#endif
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_256) && defined(ARM_TABLE_BITREVIDX_FLT64_256) && defined(ARM_TABLE_TWIDDLECOEF_F64_256) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_512))
+  case 512U:
+    fptr = arm_rfft_512_fast_init_f64;
+    break;
+#endif
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_128) && defined(ARM_TABLE_BITREVIDX_FLT64_128) && defined(ARM_TABLE_TWIDDLECOEF_F64_128) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_256))
+  case 256U:
+    fptr = arm_rfft_256_fast_init_f64;
+    break;
+#endif
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_64) && defined(ARM_TABLE_BITREVIDX_FLT64_64) && defined(ARM_TABLE_TWIDDLECOEF_F64_64) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_128))
+  case 128U:
+    fptr = arm_rfft_128_fast_init_f64;
+    break;
+#endif
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_32) && defined(ARM_TABLE_BITREVIDX_FLT64_32) && defined(ARM_TABLE_TWIDDLECOEF_F64_32) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_64))
+  case 64U:
+    fptr = arm_rfft_64_fast_init_f64;
+    break;
+#endif
+#if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FFT_TABLES) || (defined(ARM_TABLE_TWIDDLECOEF_F64_16) && defined(ARM_TABLE_BITREVIDX_FLT64_16) && defined(ARM_TABLE_TWIDDLECOEF_F64_16) && defined(ARM_TABLE_TWIDDLECOEF_RFFT_F64_32))
+  case 32U:
+    fptr = arm_rfft_32_fast_init_f64;
+    break;
+#endif
+  default:
+    return ARM_MATH_ARGUMENT_ERROR;
+  }
+
+  if( ! fptr ) return ARM_MATH_ARGUMENT_ERROR;
+  return fptr( S );
+
+}
+
+/**
+  @} end of RealFFT group
+ */

Source/fft.cmake

@@ -50,6 +50,58 @@ if (CONFIGTABLE AND CFFT_F32_4096)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_4096)
 endif()
 
+
+#######################################
+#
+# CFFT F64
+#
+
+
+if (CONFIGTABLE AND CFFT_F64_16)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_16)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_16)
+endif()
+
+if (CONFIGTABLE AND CFFT_F64_32)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_32)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_64)
+endif()
+
+if (CONFIGTABLE AND CFFT_F64_64)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_64)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_64)
+endif()
+
+if (CONFIGTABLE AND CFFT_F64_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_128)
+endif()
+
+if (CONFIGTABLE AND CFFT_F64_256)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_256)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_256)
+endif()
+
+if (CONFIGTABLE AND CFFT_F64_512)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_512)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_512)
+endif()
+
+if (CONFIGTABLE AND CFFT_F64_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_1024)
+endif()
+
+if (CONFIGTABLE AND CFFT_F64_2048)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_2048)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_2048)
+endif()
+
+if (CONFIGTABLE AND CFFT_F64_4096)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_4096)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_4096)
+endif()
+
 #######################################
 #
 # CFFT Q31
@@ -150,65 +202,126 @@ if (CONFIGTABLE AND CFFT_Q15_4096)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_4096)
 endif()
 
+#######################################
+#
+# RFFT FAST F64
+#
+
+if (CONFIGTABLE AND RFFT_FAST_F64_32)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_16)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_16)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F64_32)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_16)
+endif()
+
+if (CONFIGTABLE AND RFFT_FAST_F64_64)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_32)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_32)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F64_64)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_32)
+endif()
+
+if (CONFIGTABLE AND RFFT_FAST_F64_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_64)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_64)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F64_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_64)
+endif()
+
+if (CONFIGTABLE AND RFFT_FAST_F64_256)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F64_256)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_128)
+endif()
+
+if (CONFIGTABLE AND RFFT_FAST_F64_512)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_256)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_256)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F64_512)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_256)
+endif()
+
+if (CONFIGTABLE AND RFFT_FAST_F64_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_512)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_512)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F64_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_512)
+endif()
+
+if (CONFIGTABLE AND RFFT_FAST_F64_2048)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F64_2048)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_1024)
+endif()
+
+if (CONFIGTABLE AND RFFT_FAST_F64_4096)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_2048)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT64_2048)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F64_4096)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F64_2048)
+endif()
+
 #######################################
 #
 # RFFT FAST F32
 #
 
 if (CONFIGTABLE AND RFFT_FAST_F32_32)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_16) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_16) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_32) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_16)  
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_16)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_16)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_32)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_16)
 endif()
 
 if (CONFIGTABLE AND RFFT_FAST_F32_64)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_32) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_32) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_64) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_32)  
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_32)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_32)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_64)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_32)
 endif()
 
 if (CONFIGTABLE AND RFFT_FAST_F32_128)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_64) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_64) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_128) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_64) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_64)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_64)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_64)
 endif()
 
 if (CONFIGTABLE AND RFFT_FAST_F32_256)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_128) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_128) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_128)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_256)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_128) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_128)
 endif()
 
 if (CONFIGTABLE AND RFFT_FAST_F32_512)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_256) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_256) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_512) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_256) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_256)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_256)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_512)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_256)
 endif()
 
 if (CONFIGTABLE AND RFFT_FAST_F32_1024)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_512) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_512) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_512) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_512)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_512)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_512)
 endif()
 
 if (CONFIGTABLE AND RFFT_FAST_F32_2048)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_2048) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_1024) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_2048)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_1024)
 endif()
 
 if (CONFIGTABLE AND RFFT_FAST_F32_4096)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_2048) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_2048) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_4096) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_2048) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_2048)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FLT_2048)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_RFFT_F32_4096)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_2048)
 endif()
 
 #######################################
@@ -217,66 +330,66 @@ endif()
 #
 
 if (CONFIGTABLE AND RFFT_F32_32)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 if (CONFIGTABLE AND RFFT_F32_64)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 if (CONFIGTABLE AND RFFT_F32_128)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)  
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 if (CONFIGTABLE AND RFFT_F32_256)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 if (CONFIGTABLE AND RFFT_F32_512)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)  
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 if (CONFIGTABLE AND RFFT_F32_1024)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)  
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 if (CONFIGTABLE AND RFFT_F32_2048)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 if (CONFIGTABLE AND RFFT_F32_4096)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)  
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 if (CONFIGTABLE AND RFFT_F32_8192)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 #######################################
@@ -285,55 +398,55 @@ endif()
 #
 
 if (CONFIGTABLE AND RFFT_Q31_32)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_16)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_16)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q31_64)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_32)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_32)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q31_128)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_64)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_64)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q31_256)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_128)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_128)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q31_512)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_256)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_256)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q31_1024)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_512)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_512)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q31_2048)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_1024)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_1024)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q31_4096)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_2048)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_2048)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q31_8192)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_4096)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_4096)
 endif()
@@ -346,35 +459,35 @@ endif()
 if (CONFIGTABLE AND RFFT_Q15_32)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_16)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_16) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_16)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q15_64)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_32)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_32)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q15_128)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_64)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_64)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q15_256)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_128)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_128)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q15_512)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_256)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_256)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q15_1024)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_512)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_512)
 endif()
@@ -382,17 +495,17 @@ endif()
 if (CONFIGTABLE AND RFFT_Q15_2048)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_1024)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_1024) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_1024)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q15_4096)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_2048)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_2048)
 endif()
 
 if (CONFIGTABLE AND RFFT_Q15_8192)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_4096)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREVIDX_FXT_4096)
 endif()
@@ -403,38 +516,38 @@ endif()
 #
 
 if (CONFIGTABLE AND DCT4_F32_128)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_F32_128) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_F32_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 if (CONFIGTABLE AND DCT4_F32_512)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_F32_512)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 if (CONFIGTABLE AND DCT4_F32_2048)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_F32_2048) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_F32_2048)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
 if (CONFIGTABLE AND DCT4_F32_8192)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_F32_8192) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_F32_8192)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_F32)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_F32_4096)
 endif()
 
@@ -444,39 +557,39 @@ endif()
 #
 
 if (CONFIGTABLE AND DCT4_Q31_128)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q31_128) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q31_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_4096)
 endif()
 
-if (CONFIGTABLE AND DCT4_Q31_512) 
+if (CONFIGTABLE AND DCT4_Q31_512)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q31_512)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_4096)  
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_4096)
 endif()
 
 if (CONFIGTABLE AND DCT4_Q31_2048)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q31_2048)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_4096)
 endif()
 
 if (CONFIGTABLE AND DCT4_Q31_8192)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q31_8192)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q31)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_4096) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q31_4096)
 endif()
 
 #######################################
@@ -484,39 +597,39 @@ endif()
 # DCT4 Q15
 #
 
-if (CONFIGTABLE AND DCT4_Q15_128) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q15_128) 
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15) 
+if (CONFIGTABLE AND DCT4_Q15_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q15_128)
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_4096)
 endif()
 
-if (CONFIGTABLE AND DCT4_Q15_512) 
+if (CONFIGTABLE AND DCT4_Q15_512)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q15_512)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_4096)
 endif()
 
 if (CONFIGTABLE AND DCT4_Q15_2048)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q15_2048) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q15_2048)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_4096)
 endif()
 
 if (CONFIGTABLE AND DCT4_Q15_8192)
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q15_8192) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_DCT4_Q15_8192)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_REALCOEF_Q15)
 
     # For cfft_radix4_init
-    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024) 
+    target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_BITREV_1024)
     target_compile_definitions(${PROJECT} PUBLIC ARM_TABLE_TWIDDLECOEF_Q15_4096)
 endif()
 

Testing/Include/Tests/TransformCF64.h

@@ -14,7 +14,7 @@ class TransformCF64:public Client::Suite
 
             Client::RefPattern<float64_t> ref;
 
-            //const arm_cfft_instance_f64 *instCfftF64;
+            const arm_cfft_instance_f64 *instCfftF64;
 
             int ifft;
             

Testing/Include/Tests/TransformRF64.h

@@ -15,7 +15,7 @@ class TransformRF64:public Client::Suite
 
             Client::RefPattern<float64_t> ref;
 
-            //arm_rfft_fast_instance_f64 instRfftF64;
+            arm_rfft_fast_instance_f64 instRfftF64;
 
             int ifft;
             

Testing/Source/Tests/TransformCF64.cpp

@@ -6,7 +6,7 @@
 
 #include <cstdio>
 
-#define SNR_THRESHOLD 120
+#define SNR_THRESHOLD 250
 
     void TransformCF64::test_cfft_f64()
     {
@@ -16,13 +16,12 @@
 
         memcpy(outfftp,inp,sizeof(float64_t)*input.nbSamples());
    
-        /*
         arm_cfft_f64(
              this->instCfftF64,
              outfftp,
              this->ifft,
              1);
-             */
+
           
         ASSERT_SNR(outputfft,ref,(float64_t)SNR_THRESHOLD);
         ASSERT_EMPTY_TAIL(outputfft);
@@ -43,7 +42,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_NOISY_16_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_NOISY_16_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len16;
+            instCfftF64 = &arm_cfft_sR_f64_len16;
 
             this->ifft=0;
 
@@ -54,7 +53,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_NOISY_16_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_NOISY_16_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len16;
+            instCfftF64 = &arm_cfft_sR_f64_len16;
 
             this->ifft=1;
 
@@ -65,7 +64,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_NOISY_32_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_NOISY_32_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len32;
+            instCfftF64 = &arm_cfft_sR_f64_len32;
 
             this->ifft=0;
 
@@ -76,7 +75,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_NOISY_32_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_NOISY_32_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len32;
+            instCfftF64 = &arm_cfft_sR_f64_len32;
 
             this->ifft=1;
 
@@ -87,7 +86,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_NOISY_64_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_NOISY_64_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len64;
+            instCfftF64 = &arm_cfft_sR_f64_len64;
 
             this->ifft=0;
 
@@ -98,7 +97,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_NOISY_64_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_NOISY_64_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len64;
+            instCfftF64 = &arm_cfft_sR_f64_len64;
 
             this->ifft=1;
 
@@ -109,7 +108,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_NOISY_128_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_NOISY_128_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len128;
+            instCfftF64 = &arm_cfft_sR_f64_len128;
 
             this->ifft=0;
 
@@ -120,7 +119,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_NOISY_128_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_NOISY_128_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len128;
+            instCfftF64 = &arm_cfft_sR_f64_len128;
 
             this->ifft=1;
 
@@ -131,7 +130,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_NOISY_256_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_NOISY_256_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len256;
+            instCfftF64 = &arm_cfft_sR_f64_len256;
 
             this->ifft=0;
 
@@ -142,7 +141,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_NOISY_256_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_NOISY_256_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len256;
+            instCfftF64 = &arm_cfft_sR_f64_len256;
 
             this->ifft=1;
 
@@ -153,7 +152,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_NOISY_512_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_NOISY_512_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len512;
+            instCfftF64 = &arm_cfft_sR_f64_len512;
 
             this->ifft=0;
 
@@ -164,7 +163,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_NOISY_512_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_NOISY_512_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len512;
+            instCfftF64 = &arm_cfft_sR_f64_len512;
 
             this->ifft=1;
 
@@ -175,7 +174,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_NOISY_1024_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_NOISY_1024_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len1024;
+            instCfftF64 = &arm_cfft_sR_f64_len1024;
 
             this->ifft=0;
 
@@ -186,7 +185,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_NOISY_1024_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_NOISY_1024_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len1024;
+            instCfftF64 = &arm_cfft_sR_f64_len1024;
 
             this->ifft=1;
 
@@ -197,7 +196,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_NOISY_2048_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_NOISY_2048_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len2048;
+            instCfftF64 = &arm_cfft_sR_f64_len2048;
 
             this->ifft=0;
 
@@ -208,7 +207,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_NOISY_2048_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_NOISY_2048_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len2048;
+            instCfftF64 = &arm_cfft_sR_f64_len2048;
 
             this->ifft=1;
 
@@ -219,7 +218,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_NOISY_4096_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_NOISY_4096_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len4096;
+            instCfftF64 = &arm_cfft_sR_f64_len4096;
 
             this->ifft=0;
 
@@ -230,7 +229,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_NOISY_4096_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_NOISY_4096_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len4096;
+            instCfftF64 = &arm_cfft_sR_f64_len4096;
 
             this->ifft=1;
 
@@ -243,7 +242,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_STEP_16_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_STEP_16_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len16;
+            instCfftF64 = &arm_cfft_sR_f64_len16;
 
             this->ifft=0;
 
@@ -254,7 +253,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_STEP_16_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_STEP_16_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len16;
+            instCfftF64 = &arm_cfft_sR_f64_len16;
 
             this->ifft=1;
 
@@ -265,7 +264,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_STEP_32_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_STEP_32_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len32;
+            instCfftF64 = &arm_cfft_sR_f64_len32;
 
             this->ifft=0;
 
@@ -276,7 +275,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_STEP_32_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_STEP_32_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len32;
+            instCfftF64 = &arm_cfft_sR_f64_len32;
 
             this->ifft=1;
 
@@ -287,7 +286,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_STEP_64_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_STEP_64_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len64;
+            instCfftF64 = &arm_cfft_sR_f64_len64;
 
             this->ifft=0;
 
@@ -298,7 +297,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_STEP_64_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_STEP_64_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len64;
+            instCfftF64 = &arm_cfft_sR_f64_len64;
 
             this->ifft=1;
 
@@ -309,7 +308,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_STEP_128_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_STEP_128_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len128;
+            instCfftF64 = &arm_cfft_sR_f64_len128;
 
             this->ifft=0;
 
@@ -320,7 +319,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_STEP_128_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_STEP_128_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len128;
+            instCfftF64 = &arm_cfft_sR_f64_len128;
 
             this->ifft=1;
 
@@ -331,7 +330,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_STEP_256_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_STEP_256_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len256;
+            instCfftF64 = &arm_cfft_sR_f64_len256;
 
             this->ifft=0;
 
@@ -342,7 +341,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_STEP_256_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_STEP_256_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len256;
+            instCfftF64 = &arm_cfft_sR_f64_len256;
 
             this->ifft=1;
 
@@ -353,7 +352,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_STEP_512_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_STEP_512_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len512;
+            instCfftF64 = &arm_cfft_sR_f64_len512;
 
             this->ifft=0;
 
@@ -364,7 +363,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_STEP_512_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_STEP_512_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len512;
+            instCfftF64 = &arm_cfft_sR_f64_len512;
 
             this->ifft=1;
 
@@ -375,7 +374,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_STEP_1024_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_STEP_1024_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len1024;
+            instCfftF64 = &arm_cfft_sR_f64_len1024;
 
             this->ifft=0;
 
@@ -386,7 +385,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_STEP_1024_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_STEP_1024_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len1024;
+            instCfftF64 = &arm_cfft_sR_f64_len1024;
 
             this->ifft=1;
 
@@ -397,7 +396,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_STEP_2048_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_STEP_2048_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len2048;
+            instCfftF64 = &arm_cfft_sR_f64_len2048;
 
             this->ifft=0;
 
@@ -408,7 +407,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_STEP_2048_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_STEP_2048_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len2048;
+            instCfftF64 = &arm_cfft_sR_f64_len2048;
 
             this->ifft=1;
 
@@ -419,7 +418,7 @@
             input.reload(TransformCF64::INPUTS_CFFT_STEP_4096_F64_ID,mgr);
             ref.reload(  TransformCF64::REF_CFFT_STEP_4096_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len4096;
+            instCfftF64 = &arm_cfft_sR_f64_len4096;
 
             this->ifft=0;
 
@@ -430,7 +429,7 @@
             input.reload(TransformCF64::INPUTS_CIFFT_STEP_4096_F64_ID,mgr);
             ref.reload(  TransformCF64::INPUTS_CFFT_STEP_4096_F64_ID,mgr);
 
-            //instCfftF64 = &arm_cfft_sR_f64_len4096;
+            instCfftF64 = &arm_cfft_sR_f64_len4096;
 
             this->ifft=1;
 

Testing/Source/Tests/TransformRF64.cpp

@@ -6,7 +6,7 @@
 
 #include <cstdio>
 
-#define SNR_THRESHOLD 120
+#define SNR_THRESHOLD 250
 
 
 
@@ -19,24 +19,24 @@
        float64_t *outp = outputfft.ptr();
 
        memcpy(tmp,inp,sizeof(float64_t)*input.nbSamples());
-   /*
+
         arm_rfft_fast_f64(
              &this->instRfftF64,
              tmp,
              outp,
              this->ifft);
-          */
+
         ASSERT_SNR(outputfft,ref,(float64_t)SNR_THRESHOLD);
         ASSERT_EMPTY_TAIL(outputfft);
-        
-    } 
 
-  
+    }
+
+
     void TransformRF64::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
     {
 
 
-       
+
 
        switch(id)
        {
@@ -46,7 +46,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_NOISY_32_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_NOISY_32_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,32);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,32);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -59,7 +59,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_NOISY_64_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_NOISY_64_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -72,7 +72,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_NOISY_64_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_NOISY_64_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -85,7 +85,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_NOISY_64_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_NOISY_64_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -98,7 +98,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_NOISY_128_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_NOISY_128_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,128);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,128);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -111,7 +111,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_NOISY_128_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_NOISY_128_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,128);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,128);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -124,7 +124,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_NOISY_256_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_NOISY_256_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,256);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,256);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -137,7 +137,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_NOISY_256_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_NOISY_256_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,256);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,256);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -150,7 +150,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_NOISY_512_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_NOISY_512_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,512);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,512);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -163,7 +163,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_NOISY_512_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_NOISY_512_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,512);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,512);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -176,7 +176,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_NOISY_1024_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_NOISY_1024_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,1024);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,1024);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -189,7 +189,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_NOISY_1024_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_NOISY_1024_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,1024);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,1024);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -202,7 +202,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_NOISY_2048_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_NOISY_2048_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,2048);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,2048);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -215,7 +215,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_NOISY_2048_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_NOISY_2048_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,2048);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,2048);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -228,7 +228,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_NOISY_4096_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_NOISY_4096_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,4096);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,4096);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -241,7 +241,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_NOISY_4096_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_NOISY_4096_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,4096);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,4096);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -256,7 +256,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_STEP_32_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_STEP_32_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,32);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,32);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -269,7 +269,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_STEP_64_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_STEP_64_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -282,7 +282,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_STEP_64_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_STEP_64_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -295,7 +295,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_STEP_64_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_STEP_64_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,64);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -308,7 +308,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_STEP_128_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_STEP_128_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,128);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,128);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
             this->ifft=0;
@@ -320,7 +320,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_STEP_128_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_STEP_128_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,128);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,128);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -333,7 +333,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_STEP_256_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_STEP_256_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,256);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,256);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -346,7 +346,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_STEP_256_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_STEP_256_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,256);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,256);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -359,7 +359,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_STEP_512_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_STEP_512_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,512);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,512);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -372,7 +372,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_STEP_512_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_STEP_512_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,512);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,512);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -385,7 +385,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_STEP_1024_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_STEP_1024_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,1024);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,1024);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -398,7 +398,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_STEP_1024_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_STEP_1024_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,1024);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,1024);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -411,7 +411,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_STEP_2048_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_STEP_2048_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,2048);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,2048);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -424,7 +424,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_STEP_2048_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_STEP_2048_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,2048);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,2048);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -437,7 +437,7 @@
             input.reload(TransformRF64::INPUTS_RFFT_STEP_4096_F64_ID,mgr);
             ref.reload(  TransformRF64::REF_RFFT_STEP_4096_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,4096);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,4096);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -450,7 +450,7 @@
             input.reload(TransformRF64::INPUTS_RIFFT_STEP_4096_F64_ID,mgr);
             ref.reload(  TransformRF64::INPUTS_RFFT_STEP_4096_F64_ID,mgr);
 
-            //arm_rfft_fast_init_f64(&this->instRfftF64 ,4096);
+            arm_rfft_fast_init_f64(&this->instRfftF64 ,4096);
 
             inputchanged.create(input.nbSamples(),TransformRF64::TEMP_F64_ID,mgr);
 
@@ -462,9 +462,9 @@
 
        }
 
-       
+
       outputfft.create(ref.nbSamples(),TransformRF64::OUTPUT_RFFT_F64_ID,mgr);
-       
+
 
     }