Add tests for decimate_f64 and add the function to the pack list of f…

…unctions.

Source/FilteringFunctions/FilteringFunctions.c

@@ -71,9 +71,11 @@
 #include "arm_correlate_q31.c"
 #include "arm_correlate_q7.c"
 #include "arm_fir_decimate_f32.c"
+#include "arm_fir_decimate_f64.c"
 #include "arm_fir_decimate_fast_q15.c"
 #include "arm_fir_decimate_fast_q31.c"
 #include "arm_fir_decimate_init_f32.c"
+#include "arm_fir_decimate_init_f64.c"
 #include "arm_fir_decimate_init_q15.c"
 #include "arm_fir_decimate_init_q31.c"
 #include "arm_fir_decimate_q15.c"

Source/FilteringFunctions/arm_fir_decimate_f64.c

@@ -32,85 +32,6 @@
   @ingroup groupFilters
  */
 
-/**
-  @defgroup FIR_decimate Finite Impulse Response (FIR) Decimator
-
-  These functions combine an FIR filter together with a decimator.
-  They are used in multirate systems for reducing the sample rate of a signal without introducing aliasing distortion.
-  Conceptually, the functions are equivalent to the block diagram below:
-  \image html FIRDecimator.gif "Components included in the FIR Decimator functions"
-  When decimating by a factor of <code>M</code>, the signal should be prefiltered by a lowpass filter with a normalized
-  cutoff frequency of <code>1/M</code> in order to prevent aliasing distortion.
-  The user of the function is responsible for providing the filter coefficients.
-
-  The FIR decimator functions provided in the CMSIS DSP Library combine the FIR filter and the decimator in an efficient manner.
-  Instead of calculating all of the FIR filter outputs and discarding <code>M-1</code> out of every <code>M</code>, only the
-  samples output by the decimator are computed.
-  The functions operate on blocks of input and output data.
-  <code>pSrc</code> points to an array of <code>blockSize</code> input values and
-  <code>pDst</code> points to an array of <code>blockSize/M</code> output values.
-  In order to have an integer number of output samples <code>blockSize</code>
-  must always be a multiple of the decimation factor <code>M</code>.
-
-  The library provides separate functions for Q15, Q31 and floating-point data types.
-
-  @par           Algorithm:
-                   The FIR portion of the algorithm uses the standard form filter:
-  <pre>
-      y[n] = b[0] * x[n] + b[1] * x[n-1] + b[2] * x[n-2] + ...+ b[numTaps-1] * x[n-numTaps+1]
-  </pre>
-                   where, <code>b[n]</code> are the filter coefficients.
-  @par
-                   The <code>pCoeffs</code> points to a coefficient array of size <code>numTaps</code>.
-                   Coefficients are stored in time reversed order.
-  @par
-  <pre>
-      {b[numTaps-1], b[numTaps-2], b[N-2], ..., b[1], b[0]}
-  </pre>
-  @par
-                   <code>pState</code> points to a state array of size <code>numTaps + blockSize - 1</code>.
-                   Samples in the state buffer are stored in the order:
-  @par
-  <pre>
-      {x[n-numTaps+1], x[n-numTaps], x[n-numTaps-1], x[n-numTaps-2]....x[0], x[1], ..., x[blockSize-1]}
-  </pre>
-                   The state variables are updated after each block of data is processed, the coefficients are untouched.
-
-  @par           Instance Structure
-                   The coefficients and state variables for a filter are stored together in an instance data structure.
-                   A separate instance structure must be defined for each filter.
-                   Coefficient arrays may be shared among several instances while state variable array should be allocated separately.
-                   There are separate instance structure declarations for each of the 3 supported data types.
-
- @par            Initialization Functions
-                   There is also an associated initialization function for each data type.
-                   The initialization function performs the following operations:
-                   - Sets the values of the internal structure fields.
-                   - Zeros out the values in the state buffer.
-                   - Checks to make sure that the size of the input is a multiple of the decimation factor.
-                   To do this manually without calling the init function, assign the follow subfields of the instance structure:
-                   numTaps, pCoeffs, M (decimation factor), pState. Also set all of the values in pState to zero.
-  @par
-                   Use of the initialization function is optional.
-                   However, if the initialization function is used, then the instance structure cannot be placed into a const data section.
-                   To place an instance structure into a const data section, the instance structure must be manually initialized.
-                   The code below statically initializes each of the 3 different data type filter instance structures
-  <pre>
-      arm_fir_decimate_instance_f64 S = {M, numTaps, pCoeffs, pState};
-      arm_fir_decimate_instance_q31 S = {M, numTaps, pCoeffs, pState};
-      arm_fir_decimate_instance_q15 S = {M, numTaps, pCoeffs, pState};
-  </pre>
-                   where <code>M</code> is the decimation factor; <code>numTaps</code> is the number of filter coefficients in the filter;
-                   <code>pCoeffs</code> is the address of the coefficient buffer;
-                   <code>pState</code> is the address of the state buffer.
-                   Be sure to set the values in the state buffer to zeros when doing static initialization.
-
-  @par           Fixed-Point Behavior
-                   Care must be taken when using the fixed-point versions of the FIR decimate filter functions.
-                   In particular, the overflow and saturation behavior of the accumulator used in each function must be considered.
-                   Refer to the function specific documentation below for usage guidelines.
- */
-
 /**
   @addtogroup FIR_decimate
   @{
@@ -168,10 +89,10 @@ void arm_fir_decimate_f64(
     } while (--i);
 
     /* Set accumulators to zero */
-    acc0 = 0.0f;
-    acc1 = 0.0f;
-    acc2 = 0.0f;
-    acc3 = 0.0f;
+    acc0 = 0.0;
+    acc1 = 0.0;
+    acc2 = 0.0;
+    acc3 = 0.0;
 
     /* Initialize state pointer for all the samples */
     px0 = pState;
@@ -314,7 +235,7 @@ void arm_fir_decimate_f64(
     } while (--i);
 
     /* Set accumulator to zero */
-    acc0 = 0.0f;
+    acc0 = 0.0;
 
     /* Initialize state pointer */
     px0 = pState;

Testing/Include/Tests/DECIMF64.h

@@ -0,0 +1,34 @@
+#include "Test.h"
+#include "Pattern.h"
+
+#include "dsp/filtering_functions.h"
+
+class DECIMF64:public Client::Suite
+    {
+        public:
+            DECIMF64(Testing::testID_t id);
+            virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr);
+            virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "DECIMF64_decl.h"
+
+            Client::Pattern<float64_t> input;
+            Client::Pattern<float64_t> coefs;
+            Client::Pattern<uint32_t> config;
+
+            Client::LocalPattern<float64_t> output;
+            Client::LocalPattern<float64_t> state;
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<float64_t> ref;
+
+
+            arm_fir_decimate_instance_f64 S;
+            //arm_fir_interpolate_instance_f64 SI;
+
+            int q;
+            int numTaps;
+            int blocksize;
+            int refsize;
+
+            arm_status status;
+    };

Testing/PatternGeneration/Decimate.py

@@ -46,6 +46,11 @@ def generateBenchmarkPatterns():
     configq31=Tools.Config(PATTERNDIR,PARAMDIR,"q31")
     configq15=Tools.Config(PATTERNDIR,PARAMDIR,"q15")
 
+    configf32.setOverwrite(False)
+    configf16.setOverwrite(False)
+    configq31.setOverwrite(False)
+    configq15.setOverwrite(False)
+
 
 
     writeBenchmarks(configf32)
@@ -144,7 +149,6 @@ def writeDecimateTests(config,startNb,format):
 
         ref += [q,len(b),len(samples),len(output)]
 
-
     config.writeInput(startNb, allsamples)
     config.writeInput(startNb, allcoefs,"Coefs")
     config.writeReference(startNb, alloutput)
@@ -224,15 +228,23 @@ def generateTestPatterns():
     PATTERNDIR = os.path.join("Patterns","DSP","Filtering","DECIM","DECIM")
     PARAMDIR = os.path.join("Parameters","DSP","Filtering","DECIM","DECIM")
 
+    configf64=Tools.Config(PATTERNDIR,PARAMDIR,"f64")
     configf32=Tools.Config(PATTERNDIR,PARAMDIR,"f32")
     configf16=Tools.Config(PATTERNDIR,PARAMDIR,"f16")
     configq31=Tools.Config(PATTERNDIR,PARAMDIR,"q31")
     configq15=Tools.Config(PATTERNDIR,PARAMDIR,"q15")
 
-    writeTests(configf32,0)
-    writeTests(configf16,16)
-    writeTests(configq31,31)
-    writeTests(configq15,15)
+    configf64.setOverwrite(False)
+    configf32.setOverwrite(False)
+    configf16.setOverwrite(False)
+    configq31.setOverwrite(False)
+    configq15.setOverwrite(False)
+
+    writeTests(configf64,Tools.F64)
+    #writeTests(configf32,0)
+    #writeTests(configf16,16)
+    #writeTests(configq31,31)
+    #writeTests(configq15,15)
 
 if __name__ == '__main__':
   generateBenchmarkPatterns()

Testing/PatternGeneration/FIR.py

@@ -105,6 +105,7 @@ def generatePatterns():
     configq15=Tools.Config(PATTERNDIR,PARAMDIR,"q15")
     configq7=Tools.Config(PATTERNDIR,PARAMDIR,"q7")
 
+    configf64.setOverwrite(False)
     configf32.setOverwrite(False)
     configf16.setOverwrite(False)
     configq31.setOverwrite(False)