commit 6f8eee9fdc3cbb7d1402f9ee946f92c57cd3654a
author Christophe Favergeon <Christophe.Favergeon@arm.com> Wed Oct 09 12:21:27 2019 +0100
committer Christophe Favergeon <Christophe.Favergeon@arm.com> Fri Oct 11 14:06:20 2019 +0200
tree d6045f58e9546aade1d359f132fb3ac7c06b9a82
parent 8a25cc1122439a6c42d5f2faf5cf850c8ffab222

CMSIS-DSP: Added test patterns for Statistics functions.
Added MVE code for statistics functions.
Improvement to test framework.

CMSIS/DSP/.gitignore

diff --git a/CMSIS/DSP/.gitignore b/CMSIS/DSP/.gitignore
index 387ded4..552df48 100644
--- a/CMSIS/DSP/.gitignore
+++ b/CMSIS/DSP/.gitignore
@@ -2,3 +2,4 @@
 PythonWrapper/build/
 PythonWrapper/cmsisdsp.cp36-win_amd64.pyd
 PythonWrapper/rec_2.dat
+Output.pickle

CMSIS/DSP/Include/arm_helium_utils.h

diff --git a/CMSIS/DSP/Include/arm_helium_utils.h b/CMSIS/DSP/Include/arm_helium_utils.h
index c549735..8076b7d 100755
--- a/CMSIS/DSP/Include/arm_helium_utils.h
+++ b/CMSIS/DSP/Include/arm_helium_utils.h
@@ -79,6 +79,15 @@
 ***************************************/
 #if defined (ARM_MATH_HELIUM) || defined(ARM_MATH_MVEI)
 
+#include <limits.h>
+
+#define Q31_MAX   LONG_MAX
+#define Q15_MAX   SHRT_MAX
+#define Q7_MAX    SCHAR_MAX
+#define Q31_MIN   LONG_MIN
+#define Q15_MIN   SHRT_MIN
+#define Q7_MIN    SCHAR_MIN
+
 #include "arm_common_tables.h"
 
 #if !defined(ARM_DSP_CONFIG_TABLES) || defined(ARM_ALL_FAST_TABLES) || defined(ARM_TABLE_FAST_SQRT_Q31_MVE)

CMSIS/DSP/Include/arm_math.h

diff --git a/CMSIS/DSP/Include/arm_math.h b/CMSIS/DSP/Include/arm_math.h
index 98b6258..15c22bf 100644
--- a/CMSIS/DSP/Include/arm_math.h
+++ b/CMSIS/DSP/Include/arm_math.h
@@ -1211,6 +1211,91 @@
     return(r);
 }
 
+/**
+ * @brief  64-bit to 32-bit unsigned normalization
+ * @param[in]  in           is input unsigned long long value
+ * @param[out] normalized   is the 32-bit normalized value
+ * @param[out] norm         is norm scale
+ */
+__STATIC_INLINE  void arm_norm_64_to_32u(uint64_t in, q31_t * normalized, int *norm)
+{
+    q31_t     n1;
+    q31_t     hi = (q31_t) (in >> 32);
+    q31_t     lo = (q31_t) ((in << 32) >> 32);
+
+    n1 = __CLZ(hi) - 32;
+    if (!n1)
+    {
+        /*
+         * input fits in 32-bit
+         */
+        n1 = __CLZ(lo);
+        if (!n1)
+        {
+            /*
+             * MSB set, need to scale down by 1
+             */
+            *norm = -1;
+            *normalized = (((unsigned long) lo) >> 1);
+        } else
+        {
+            if (n1 == 32)
+            {
+                /*
+                 * input is zero
+                 */
+                *norm = 0;
+                *normalized = 0;
+            } else
+            {
+                /*
+                 * 32-bit normalization
+                 */
+                *norm = n1 - 1;
+                *normalized = lo << *norm;
+            }
+        }
+    } else
+    {
+        /*
+         * input fits in 64-bit
+         */
+        n1 = 1 - n1;
+        *norm = -n1;
+        /*
+         * 64 bit normalization
+         */
+        *normalized = (((unsigned long) lo) >> n1) | (hi << (32 - n1));
+    }
+}
+
+__STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
+{
+    q31_t   result;
+    q63_t   absNum;
+    q31_t   normalized;
+    q31_t   norm;
+
+    /*
+     * if sum fits in 32bits
+     * avoid costly 64-bit division
+     */
+    absNum = num > 0 ? num : -num;
+    arm_norm_64_to_32u(absNum, &normalized, &norm);
+    if (norm > 0)
+        /*
+         * 32-bit division
+         */
+        result = (q31_t) num / den;
+    else
+        /*
+         * 64-bit division
+         */
+        result = num / den;
+
+    return result;
+}
+
 #if defined(ARM_MATH_NEON)
 
 /**

CMSIS/DSP/Source/StatisticsFunctions/arm_entropy_f32.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_entropy_f32.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_entropy_f32.c
index c93319e..4195587 100755
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_entropy_f32.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_entropy_f32.c
@@ -43,8 +43,7 @@
  * @return     Entropy      -Sum(p ln p)
  *
  */
-
-#if defined(ARM_MATH_NEON)
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
 
 #include "NEMath.h"
 
@@ -116,6 +115,7 @@
     return(-accum);
 }
 #endif
+
 /**
  * @} end of groupStats group
  */

CMSIS/DSP/Source/StatisticsFunctions/arm_kullback_leibler_f32.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_kullback_leibler_f32.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_kullback_leibler_f32.c
index 9963713..b9ecbac 100755
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_kullback_leibler_f32.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_kullback_leibler_f32.c
@@ -50,7 +50,7 @@
  *
  */
 
-#if defined(ARM_MATH_NEON)
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
 
 #include "NEMath.h"
 

CMSIS/DSP/Source/StatisticsFunctions/arm_logsumexp_f32.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_logsumexp_f32.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_logsumexp_f32.c
index 08723a6..21b8549 100755
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_logsumexp_f32.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_logsumexp_f32.c
@@ -59,7 +59,7 @@
  *
  */
 
-#if defined(ARM_MATH_NEON)
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
 
 #include "NEMath.h"
 float32_t arm_logsumexp_f32(const float32_t *in, uint32_t blockSize)

CMSIS/DSP/Source/StatisticsFunctions/arm_max_f32.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_max_f32.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_max_f32.c
index 1b7139f..2f2d63d 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_max_f32.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_max_f32.c
@@ -27,7 +27,7 @@
  */
 
 #include "arm_math.h"
-#if defined(ARM_MATH_NEON)
+#if (defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF)) && !defined(ARM_MATH_AUTOVECTORIZE)
 #include <limits.h>
 #endif
 
@@ -56,7 +56,93 @@
   @param[out]    pIndex     index of maximum value returned here
   @return        none
  */
-#if defined(ARM_MATH_NEON)
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+void arm_max_f32(
+  const float32_t * pSrc,
+  uint32_t blockSize,
+  float32_t * pResult,
+  uint32_t * pIndex)
+{
+    uint32_t blkCnt; 
+    f32x4_t vecSrc;
+    f32x4_t curExtremValVec = vdupq_n_f32(FLT_MIN);
+    float32_t maxValue = FLT_MIN;
+    uint32_t idx = blockSize;
+    uint32x4_t indexVec;
+    uint32x4_t curExtremIdxVec;
+    uint32_t curIdx = 0;
+    mve_pred16_t p0;
+    float32_t tmp;
+
+
+    indexVec = vidupq_wb_u32(&curIdx, 1);
+    curExtremIdxVec = vdupq_n_u32(0);
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrwq_f32(pSrc);
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+        p0 = vcmpgeq(vecSrc, curExtremValVec);
+        curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
+        curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
+
+        indexVec = vidupq_wb_u32(&curIdx, 1);
+
+        pSrc += 4;
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxnmvq(maxValue, curExtremValVec);
+    /*
+     * set index for lower values to max possible index
+     */
+    p0 = vcmpgeq(curExtremValVec, maxValue);
+    indexVec = vpselq(curExtremIdxVec, vdupq_n_u32(blockSize), p0);
+    /*
+     * Get min index which is thus for a max value
+     */
+    idx = vminvq(idx, indexVec);
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+
+    while (blkCnt > 0U)
+    {
+      /* Initialize tmp to the next consecutive values one by one */
+      tmp = *pSrc++;
+
+      /* compare for the maximum value */
+      if (maxValue < tmp)
+      {
+        /* Update the maximum value and it's index */
+        maxValue = tmp;
+        idx = blockSize - blkCnt;
+      }
+
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+
+    /*
+     * Save result
+     */
+    *pIndex = idx;
+    *pResult = maxValue;
+}
+
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
 void arm_max_f32(
   const float32_t * pSrc,
   uint32_t blockSize,
@@ -177,7 +263,7 @@
         float32_t maxVal, out;                         /* Temporary variables to store the output value. */
         uint32_t blkCnt, outIndex;                     /* Loop counter */
 
-#if defined (ARM_MATH_LOOPUNROLL)
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
         uint32_t index;                                /* index of maximum value */
 #endif
 
@@ -187,7 +273,7 @@
   /* Load first input value that act as reference value for comparision */
   out = *pSrc++;
 
-#if defined (ARM_MATH_LOOPUNROLL)
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
   /* Initialise index of maximum value. */
   index = 0U;
 
@@ -266,6 +352,8 @@
   *pIndex = outIndex;
 }
 #endif /* #if defined(ARM_MATH_NEON) */
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
 /**
   @} end of Max group
  */

CMSIS/DSP/Source/StatisticsFunctions/arm_max_q15.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q15.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q15.c
index 329b0c8..b09811b 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q15.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q15.c
@@ -45,7 +45,89 @@
   @param[out]    pIndex     index of maximum value returned here
   @return        none
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_max_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult,
+        uint32_t * pIndex)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q15x8_t vecSrc;
+    q15x8_t curExtremValVec = vdupq_n_s16(Q15_MIN);
+    q15_t maxValue = Q15_MIN, temp;
+    uint32_t  idx = blockSize;
+    uint16x8_t indexVec;
+    uint16x8_t curExtremIdxVec;
+    mve_pred16_t p0;
+
+
+    indexVec = vidupq_u16(0, 1);
+    curExtremIdxVec = vdupq_n_u16(0);
+
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrhq_s16(pSrc);  
+        pSrc += 8;
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+        p0 = vcmpgeq(vecSrc, curExtremValVec);
+        curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
+        curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
+
+        indexVec = indexVec +  8;
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+   
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxvq(maxValue, curExtremValVec);
+    /*
+     * set index for lower values to max possible index
+     */
+    p0 = vcmpgeq(curExtremValVec, maxValue);
+    indexVec = vpselq(curExtremIdxVec, vdupq_n_u16(blockSize), p0);
+    /*
+     * Get min index which is thus for a max value
+     */
+    idx = vminvq(idx, indexVec);
+
+    /* Tail */
+    blkCnt = blockSize & 0x7;
+    while (blkCnt > 0U)
+    {
+      /* Initialize temp to the next consecutive values one by one */
+      temp = *pSrc++;
+  
+      /* compare for the maximum value */
+      if (maxValue < temp)
+      {
+        /* Update the maximum value and it's index */
+        maxValue = temp;
+        idx = blockSize - blkCnt;
+      }
+  
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+
+    /*
+     * Save result
+     */
+    *pIndex = idx;
+    *pResult = maxValue;
+}
+#else
 void arm_max_q15(
   const q15_t * pSrc,
         uint32_t blockSize,
@@ -142,7 +224,7 @@
   *pResult = out;
   *pIndex = outIndex;
 }
-
+#endif /* defined(ARM_MATH_MVEI) */
 /**
   @} end of Max group
  */

CMSIS/DSP/Source/StatisticsFunctions/arm_max_q31.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q31.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q31.c
index 99de13e..bb5ce93 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q31.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q31.c
@@ -45,7 +45,92 @@
   @param[out]    pIndex     index of maximum value returned here
   @return        none
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_max_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult,
+        uint32_t * pIndex)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q31x4_t vecSrc;
+    q31x4_t curExtremValVec = vdupq_n_s32( Q31_MIN);
+    q31_t maxValue = Q31_MIN;
+    q31_t temp;
+    uint32_t  idx = blockSize;
+    uint32x4_t indexVec;
+    uint32x4_t curExtremIdxVec;
+    mve_pred16_t p0;
+
+
+    indexVec = vidupq_u32(0, 1);
+    curExtremIdxVec = vdupq_n_u32(0);
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrwq_s32(pSrc);  
+        pSrc += 4;
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+        p0 = vcmpgeq(vecSrc, curExtremValVec);
+        curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
+        curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
+
+        indexVec = indexVec +  4;
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+   
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxvq(maxValue, curExtremValVec);
+    /*
+     * set index for lower values to max possible index
+     */
+    p0 = vcmpgeq(curExtremValVec, maxValue);
+    indexVec = vpselq(curExtremIdxVec, vdupq_n_u32(blockSize), p0);
+    /*
+     * Get min index which is thus for a max value
+     */
+    idx = vminvq(idx, indexVec);
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+
+    while (blkCnt > 0U)
+    {
+       /* Initialize maxVal to the next consecutive values one by one */
+       temp = *pSrc++;
+   
+       /* compare for the maximum value */
+       if (maxValue < temp)
+       {
+         /* Update the maximum value and it's index */
+         maxValue = temp;
+         idx = blockSize - blkCnt;
+       }
+
+       /* Decrement loop counter */
+       blkCnt--;
+    }
+
+    /*
+     * Save result
+     */
+    *pIndex = idx;
+    *pResult = maxValue;
+}
+#else
 void arm_max_q31(
   const q31_t * pSrc,
         uint32_t blockSize,
@@ -142,6 +227,7 @@
   *pResult = out;
   *pIndex = outIndex;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of Max group

CMSIS/DSP/Source/StatisticsFunctions/arm_max_q7.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q7.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q7.c
index 9c8b6d3..0e7309e 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q7.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_max_q7.c
@@ -45,7 +45,146 @@
   @param[out]    pIndex     index of maximum value returned here
   @return        none
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+static void arm_small_blk_max_q7(
+    const q7_t * pSrc,
+    uint8_t blockSize,
+    q7_t * pResult,
+    uint32_t * pIndex)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q7x16_t        vecSrc;
+    q7x16_t        curExtremValVec = vdupq_n_s8( Q7_MIN);
+    q7_t            maxValue = Q7_MIN, temp;
+    uint32_t        idx = blockSize;
+    uint8x16_t      indexVec;
+    uint8x16_t      curExtremIdxVec;
+    mve_pred16_t    p0;
+
+
+    indexVec = vidupq_u8(0, 1);
+    curExtremIdxVec = vdupq_n_u8(0);
+
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrbq_s8(pSrc);  
+        pSrc += 16;
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+        p0 = vcmpgeq(vecSrc, curExtremValVec);
+        curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
+        curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
+
+        indexVec = indexVec +  16;
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+   
+    
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxvq(maxValue, curExtremValVec);
+    /*
+     * set index for lower values to max possible index
+     */
+    p0 = vcmpgeq(curExtremValVec, maxValue);
+    indexVec = vpselq(curExtremIdxVec, vdupq_n_u8(blockSize), p0);
+    /*
+     * Get min index which is thus for a max value
+     */
+    idx = vminvq(idx, indexVec);
+
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0xF;
+
+    while (blkCnt > 0U)
+    {
+      /* Initialize temp to the next consecutive values one by one */
+      temp = *pSrc++;
+  
+      /* compare for the maximum value */
+      if (maxValue < temp)
+      {
+        /* Update the maximum value and it's index */
+        maxValue = temp;
+        idx = blockSize - blkCnt;
+      }
+  
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+    /*
+     * Save result
+     */
+    *pIndex = idx;
+    *pResult = maxValue;
+}
+
+void arm_max_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult,
+        uint32_t * pIndex)
+{
+    int32_t   totalSize = blockSize;
+
+    if (totalSize <= UINT8_MAX)
+    {
+        arm_small_blk_max_q7(pSrc, blockSize, pResult, pIndex);
+    }
+    else
+    {
+        uint32_t  curIdx = 0;
+        q7_t      curBlkExtr = Q7_MIN;
+        uint32_t  curBlkPos = 0;
+        uint32_t  curBlkIdx = 0;
+        /*
+         * process blocks of 255 elts
+         */
+        while (totalSize >= UINT8_MAX)
+        {
+            const q7_t     *curSrc = pSrc;
+
+            arm_small_blk_max_q7(curSrc, UINT8_MAX, pResult, pIndex);
+            if (*pResult > curBlkExtr)
+            {
+                /*
+                 * update partial extrema
+                 */
+                curBlkExtr = *pResult;
+                curBlkPos = *pIndex;
+                curBlkIdx = curIdx;
+            }
+            curIdx++;
+            pSrc += UINT8_MAX;
+            totalSize -= UINT8_MAX;
+        }
+        /*
+         * remainder
+         */
+        arm_small_blk_max_q7(pSrc, totalSize, pResult, pIndex);
+        if (*pResult > curBlkExtr)
+        {
+            curBlkExtr = *pResult;
+            curBlkPos = *pIndex;
+            curBlkIdx = curIdx;
+        }
+        *pIndex = curBlkIdx * UINT8_MAX + curBlkPos;
+        *pResult = curBlkExtr;
+    }
+}
+#else
 void arm_max_q7(
   const q7_t * pSrc,
         uint32_t blockSize,
@@ -142,6 +281,7 @@
   *pResult = out;
   *pIndex = outIndex;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of Max group

CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f32.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f32.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f32.c
index 63d9652..6a8d5c9 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f32.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f32.c
@@ -57,7 +57,51 @@
   @param[out]    pResult    mean value returned here.
   @return        none
  */
-#if defined(ARM_MATH_NEON_EXPERIMENTAL)
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_mean_f32(
+  const float32_t * pSrc,
+  uint32_t blockSize,
+  float32_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    f32x4_t vecSrc;
+    f32x4_t sumVec = vdupq_n_f32(0.0f);
+    float32_t sum = 0.0f; 
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrwq_f32(pSrc);
+        sumVec = vaddq_f32(sumVec, vecSrc);
+
+        blkCnt --;
+        pSrc += 4;
+    }
+
+    sum = vecAddAcrossF32Mve(sumVec);
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+
+    while (blkCnt > 0U)
+    {
+      /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) */
+      sum += *pSrc++;
+  
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+
+    *pResult = sum / (float32_t) blockSize;
+}
+
+
+#else
+#if defined(ARM_MATH_NEON_EXPERIMENTAL) && !defined(ARM_MATH_AUTOVECTORIZE)
 void arm_mean_f32(
   const float32_t * pSrc,
   uint32_t blockSize,
@@ -116,7 +160,7 @@
         uint32_t blkCnt;                               /* Loop counter */
         float32_t sum = 0.0f;                          /* Temporary result storage */
 
-#if defined (ARM_MATH_LOOPUNROLL)
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
 
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
@@ -160,6 +204,7 @@
   *pResult = (sum / blockSize);
 }
 #endif /* #if defined(ARM_MATH_NEON) */
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of mean group

CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q15.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q15.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q15.c
index 463aa84..61ad835 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q15.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q15.c
@@ -53,6 +53,47 @@
                    Finally, the accumulator is truncated to yield a result of 1.15 format.
  */
 
+#if defined(ARM_MATH_MVEI)
+void arm_mean_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q15x8_t  vecSrc;
+    q31_t     sum = 0L;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3U;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrhq_s16(pSrc);
+        /*
+         * sum lanes
+         */
+        sum = vaddvaq(sum, vecSrc);
+
+        blkCnt--;
+        pSrc += 8;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0x7;
+
+    while (blkCnt > 0U)
+    {
+       /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) */
+       sum += *pSrc++;
+
+       /* Decrement loop counter */
+       blkCnt--;
+    }
+
+    /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) / blockSize  */
+    /* Store the result to the destination */
+    *pResult = (q15_t) (sum / (int32_t) blockSize);
+}
+#else
 void arm_mean_q15(
   const q15_t * pSrc,
         uint32_t blockSize,
@@ -108,6 +149,7 @@
   /* Store result to destination */
   *pResult = (q15_t) (sum / (int32_t) blockSize);
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of mean group

CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q31.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q31.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q31.c
index 4b0ed6e..ff1abd0 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q31.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q31.c
@@ -52,7 +52,45 @@
                    full precision of intermediate result is preserved.
                    Finally, the accumulator is truncated to yield a result of 1.31 format.
  */
+#if defined(ARM_MATH_MVEI)
+void arm_mean_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q31x4_t vecSrc;
+    q63_t     sum = 0LL;
 
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+
+        vecSrc = vldrwq_s32(pSrc);
+        /*
+         * sum lanes
+         */
+        sum = vaddlvaq(sum, vecSrc);
+
+        blkCnt --;
+        pSrc += 4;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+
+    while (blkCnt > 0U)
+    {
+      /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) */
+      sum += *pSrc++;
+      blkCnt --;
+    }
+
+    *pResult = arm_div_q63_to_q31(sum, blockSize);
+}
+#else
 void arm_mean_q31(
   const q31_t * pSrc,
         uint32_t blockSize,
@@ -104,6 +142,7 @@
   /* Store result to destination */
   *pResult = (q31_t) (sum / blockSize);
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of mean group

CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q7.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q7.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q7.c
index 8f52211..73ed0a2 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q7.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_q7.c
@@ -53,6 +53,46 @@
                    Finally, the accumulator is truncated to yield a result of 1.7 format.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+void arm_mean_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q7x16_t vecSrc;
+    q31_t     sum = 0L;
+
+
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrbq_s8(pSrc);
+        /*
+         * sum lanes
+         */
+        sum = vaddvaq(sum, vecSrc);
+
+        blkCnt--;
+        pSrc += 16;
+    }
+
+    blkCnt = blockSize & 0xF;
+    while (blkCnt > 0U)
+    {
+      /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) */
+      sum += *pSrc++;
+  
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+
+    /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) / blockSize  */
+    /* Store the result to the destination */
+    *pResult = (q7_t) (sum / (int32_t) blockSize);
+}
+#else
 void arm_mean_q7(
   const q7_t * pSrc,
         uint32_t blockSize,
@@ -106,6 +146,7 @@
   /* Store result to destination */
   *pResult = (q7_t) (sum / (int32_t) blockSize);
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of mean group

CMSIS/DSP/Source/StatisticsFunctions/arm_min_f32.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_min_f32.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_min_f32.c
index 6e9ff4b..38587e3 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_min_f32.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_min_f32.c
@@ -27,7 +27,11 @@
  */
 
 #include "arm_math.h"
+
+#if (defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF)) && !defined(ARM_MATH_AUTOVECTORIZE)
 #include <limits.h>
+#endif
+
 
 /**
   @ingroup groupStats
@@ -54,7 +58,93 @@
   @param[out]    pIndex     index of minimum value returned here
   @return        none
  */
-#if defined(ARM_MATH_NEON)
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+void arm_min_f32(
+  const float32_t * pSrc,
+  uint32_t blockSize,
+  float32_t * pResult,
+  uint32_t * pIndex)
+{
+    int32_t  blkCnt;           /* loop counters */
+    f32x4_t vecSrc;
+    float32_t const *pSrcVec;
+    f32x4_t curExtremValVec = vdupq_n_f32(FLT_MAX);
+    float32_t minValue = FLT_MAX;
+    uint32_t  idx = blockSize;
+    uint32x4_t indexVec;
+    uint32x4_t curExtremIdxVec;
+    float32_t tmp;
+    mve_pred16_t p0;
+
+    indexVec = vidupq_u32(0, 1);
+    curExtremIdxVec = vdupq_n_u32(0);
+
+    pSrcVec = (float32_t const *) pSrc;
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrwq_f32(pSrcVec);  
+        pSrcVec += 4;
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+        p0 = vcmpleq(vecSrc, curExtremValVec);
+        curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
+        curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
+
+        indexVec = indexVec +  4;
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminnmvq(minValue, curExtremValVec);
+    /*
+     * set index for lower values to max possible index
+     */
+    p0 = vcmpleq(curExtremValVec, minValue);
+    indexVec = vpselq(curExtremIdxVec, vdupq_n_u32(blockSize), p0);
+    /*
+     * Get min index which is thus for a max value
+     */
+    idx = vminvq(idx, indexVec);
+
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0x3;
+
+    while (blkCnt > 0U)
+    {
+      /* Initialize minVal to the next consecutive values one by one */
+      tmp = *pSrc++;
+  
+      /* compare for the minimum value */
+      if (minValue > tmp)
+      {
+        /* Update the minimum value and it's index */
+        minValue = tmp;
+        idx = blockSize - blkCnt;
+      }
+      blkCnt--;
+    }
+    /*
+     * Save result
+     */
+    *pIndex = idx;
+    *pResult = minValue;
+}
+
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
 void arm_min_f32(
   const float32_t * pSrc,
   uint32_t blockSize,
@@ -173,7 +263,7 @@
         float32_t minVal, out;                         /* Temporary variables to store the output value. */
         uint32_t blkCnt, outIndex;                     /* Loop counter */
 
-#if defined (ARM_MATH_LOOPUNROLL)
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
         uint32_t index;                                /* index of maximum value */
 #endif
 
@@ -183,7 +273,7 @@
   /* Load first input value that act as reference value for comparision */
   out = *pSrc++;
 
-#if defined (ARM_MATH_LOOPUNROLL)
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
   /* Initialise index of maximum value. */
   index = 0U;
 
@@ -262,6 +352,7 @@
   *pIndex = outIndex;
 }
 #endif /* #if defined(ARM_MATH_NEON) */
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of Min group

CMSIS/DSP/Source/StatisticsFunctions/arm_min_q15.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q15.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q15.c
index 9450383..3537bea 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q15.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q15.c
@@ -46,7 +46,91 @@
   @param[out]    pIndex     index of minimum value returned here
   @return        none
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_min_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult,
+        uint32_t * pIndex)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q15x8_t vecSrc;
+    q15x8_t curExtremValVec = vdupq_n_s16(Q15_MAX);
+    q15_t minValue = Q15_MAX,temp;
+    uint32_t  idx = blockSize;
+    uint16x8_t indexVec;
+    uint16x8_t curExtremIdxVec;
+    mve_pred16_t p0;
+
+
+    indexVec = vidupq_u16(0, 1);
+    curExtremIdxVec = vdupq_n_u16(0);
+
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrhq_s16(pSrc);  
+        pSrc += 8;
+        /*
+         * Get current min per lane and current index per lane
+         * when a min is selected
+         */
+        p0 = vcmpleq(vecSrc, curExtremValVec);
+        curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
+        curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
+
+        indexVec = indexVec +  8;
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+   
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminvq(minValue, curExtremValVec);
+    /*
+     * set index for lower values to min possible index
+     */
+    p0 = vcmpleq(curExtremValVec, minValue);
+    indexVec = vpselq(curExtremIdxVec, vdupq_n_u16(blockSize), p0);
+    /*
+     * Get min index which is thus for a min value
+     */
+    idx = vminvq(idx, indexVec);
+
+    /*
+     * tail
+    */
+    blkCnt = blockSize & 7;
+    while (blkCnt > 0U)
+    {
+      /* Initialize minVal to the next consecutive values one by one */
+      temp = *pSrc++;
+  
+      /* compare for the minimum value */
+      if (minValue > temp)
+      {
+        /* Update the minimum value and it's index */
+        minValue = temp;
+        idx = blockSize - blkCnt;
+      }
+  
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+
+    /*
+     * Save result
+     */
+    *pIndex = idx;
+    *pResult = minValue;
+}
+#else
 void arm_min_q15(
   const q15_t * pSrc,
         uint32_t blockSize,
@@ -143,6 +227,7 @@
   *pResult = out;
   *pIndex = outIndex;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of Min group

CMSIS/DSP/Source/StatisticsFunctions/arm_min_q31.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q31.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q31.c
index e25eb47..d8c1e48 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q31.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q31.c
@@ -46,7 +46,90 @@
   @param[out]    pIndex     index of minimum value returned here
   @return        none
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_min_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult,
+        uint32_t * pIndex)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q31x4_t vecSrc;
+    q31x4_t curExtremValVec = vdupq_n_s32(Q31_MAX);
+    q31_t minValue = Q31_MAX, temp;
+    uint32_t  idx = blockSize;
+    uint32x4_t indexVec;
+    uint32x4_t curExtremIdxVec;
+    mve_pred16_t p0;
+
+
+    indexVec = vidupq_u32(0, 1);
+    curExtremIdxVec = vdupq_n_u32(0);
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrwq_s32(pSrc);  
+        pSrc += 4;
+        /*
+         * Get current min per lane and current index per lane
+         * when a min is selected
+         */
+        p0 = vcmpleq(vecSrc, curExtremValVec);
+        curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
+        curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
+
+        indexVec = indexVec +  4;
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminvq(minValue, curExtremValVec);
+    /*
+     * set index for lower values to min possible index
+     */
+    p0 = vcmpleq(curExtremValVec, minValue);
+    indexVec = vpselq(curExtremIdxVec, vdupq_n_u32(blockSize), p0);
+    /*
+     * Get min index which is thus for a min value
+     */
+    idx = vminvq(idx, indexVec);
+
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+    while (blkCnt > 0U)
+    {
+      /* Initialize temp to the next consecutive values one by one */
+      temp = *pSrc++;
+  
+      /* compare for the minimum value */
+      if (minValue > temp)
+      {
+        /* Update the minimum value and it's index */
+        minValue = temp;
+        idx = blockSize - blkCnt;
+      }
+  
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+    /*
+     * Save result
+     */
+    *pIndex = idx;
+    *pResult = minValue;
+}
+#else
 void arm_min_q31(
   const q31_t * pSrc,
         uint32_t blockSize,
@@ -143,6 +226,7 @@
   *pResult = out;
   *pIndex = outIndex;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of Min group

CMSIS/DSP/Source/StatisticsFunctions/arm_min_q7.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q7.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q7.c
index 2b171f0..c09225b 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q7.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_min_q7.c
@@ -46,7 +46,141 @@
   @param[out]    pIndex     index of minimum value returned here
   @return        none
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+static void arm_small_blk_min_q7(
+    const q7_t * pSrc,
+    uint8_t blockSize,
+    q7_t * pResult,
+    uint32_t * pIndex)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q7x16_t        vecSrc;
+    q7x16_t        curExtremValVec = vdupq_n_s8(Q7_MAX);
+    q7_t            minValue = Q7_MAX,temp;
+    uint32_t        idx = blockSize;
+    uint8x16_t      indexVec;
+    uint8x16_t      curExtremIdxVec;
+    mve_pred16_t    p0;
+
+
+    indexVec = vidupq_u8(0, 1);
+    curExtremIdxVec = vdupq_n_u8(0);
+
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrbq_s8(pSrc);  
+        pSrc += 16;
+        /*
+         * Get current min per lane and current index per lane
+         * when a min is selected
+         */
+        p0 = vcmpleq(vecSrc, curExtremValVec);
+        curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
+        curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
+
+        indexVec = indexVec +  16;
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminvq(minValue, curExtremValVec);
+    /*
+     * set index for lower values to min possible index
+     */
+    p0 = vcmpleq(curExtremValVec, minValue);
+    indexVec = vpselq(curExtremIdxVec, vdupq_n_u8(blockSize), p0);
+    /*
+     * Get min index which is thus for a min value
+     */
+    idx = vminvq(idx, indexVec);
+
+    blkCnt = blockSize & 0xF;
+    while (blkCnt > 0U)
+    {
+      /* Initialize minVal to the next consecutive values one by one */
+      temp = *pSrc++;
+  
+      /* compare for the minimum value */
+      if (minValue > temp)
+      {
+        /* Update the minimum value and it's index */
+        minValue = temp;
+        idx = blockSize - blkCnt;
+      }
+  
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+    /*
+     * Save result
+     */
+    *pIndex = idx;
+    *pResult = minValue;
+}
+
+void arm_min_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult,
+        uint32_t * pIndex)
+{
+    int32_t   totalSize = blockSize;
+
+    if (totalSize <= UINT8_MAX)
+    {
+        arm_small_blk_min_q7(pSrc, blockSize, pResult, pIndex);
+    }
+    else
+    {
+        uint32_t  curIdx = 0;
+        q7_t      curBlkExtr = Q7_MAX;
+        uint32_t  curBlkPos = 0;
+        uint32_t  curBlkIdx = 0;
+        /*
+         * process blocks of 255 elts
+         */
+        while (totalSize >= UINT8_MAX)
+        {
+            const q7_t     *curSrc = pSrc;
+
+            arm_small_blk_min_q7(curSrc, UINT8_MAX, pResult, pIndex);
+            if (*pResult < curBlkExtr)
+            {
+                /*
+                 * update partial extrema
+                 */
+                curBlkExtr = *pResult;
+                curBlkPos = *pIndex;
+                curBlkIdx = curIdx;
+            }
+            curIdx++;
+            pSrc += UINT8_MAX;
+            totalSize -= UINT8_MAX;
+        }
+        /*
+         * remainder
+         */
+        arm_small_blk_min_q7(pSrc, totalSize, pResult, pIndex);
+        if (*pResult < curBlkExtr)
+        {
+            curBlkExtr = *pResult;
+            curBlkPos = *pIndex;
+            curBlkIdx = curIdx;
+        }
+        *pIndex = curBlkIdx * UINT8_MAX + curBlkPos;
+        *pResult = curBlkExtr;
+    }
+}
+#else
 void arm_min_q7(
   const q7_t * pSrc,
         uint32_t blockSize,
@@ -143,6 +277,7 @@
   *pResult = out;
   *pIndex = outIndex;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of Min group

CMSIS/DSP/Source/StatisticsFunctions/arm_power_f32.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_power_f32.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_power_f32.c
index a4825a5..1f17ecc 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_power_f32.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_power_f32.c
@@ -57,7 +57,56 @@
   @param[out]    pResult    sum of the squares value returned here
   @return        none
  */
-#if defined(ARM_MATH_NEON)
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_power_f32(
+  const float32_t * pSrc,
+  uint32_t blockSize,
+  float32_t * pResult)
+{
+    int32_t         blkCnt;     /* loop counters */
+    f32x4_t         vecSrc;
+    f32x4_t         sumVec = vdupq_n_f32(0.0f);
+    float32_t       sum = 0.0f;
+    float32_t in;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrwq_f32(pSrc);
+        /*
+         * sum lanes
+         */
+        sumVec = vfmaq(sumVec, vecSrc, vecSrc);
+
+        blkCnt --;
+        pSrc += 4;
+    }
+    sum = vecAddAcrossF32Mve(sumVec);
+
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0x3;
+    while (blkCnt > 0U)
+    {
+      /* C = A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1] */
+  
+      /* Compute Power and store result in a temporary variable, sum. */
+      in = *pSrc++;
+      sum += in * in;
+  
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+
+    *pResult = sum;
+}
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
 void arm_power_f32(
   const float32_t * pSrc,
   uint32_t blockSize,
@@ -117,7 +166,7 @@
         float32_t sum = 0.0f;                          /* Temporary result storage */
         float32_t in;                                  /* Temporary variable to store input value */
 
-#if defined (ARM_MATH_LOOPUNROLL)
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
 
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
@@ -169,6 +218,7 @@
   *pResult = sum;
 }
 #endif /* #if defined(ARM_MATH_NEON) */
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of power group

CMSIS/DSP/Source/StatisticsFunctions/arm_power_q15.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q15.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q15.c
index 12f524d..5d15535 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q15.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q15.c
@@ -53,12 +53,56 @@
                    full precision of the intermediate multiplication is preserved.
                    Finally, the return result is in 34.30 format.
  */
+#if defined(ARM_MATH_MVEI)
 
 void arm_power_q15(
   const q15_t * pSrc,
         uint32_t blockSize,
         q63_t * pResult)
 {
+    int32_t  blkCnt;           /* loop counters */
+    q15x8_t vecSrc;
+    q63_t     sum = 0LL;
+    q15_t in;
+
+   /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3U;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrhq_s16(pSrc);
+        /*
+         * sum lanes
+         */
+        sum = vmlaldavaq(sum, vecSrc, vecSrc);
+
+        blkCnt --;
+        pSrc += 8;
+    }
+
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0x7;
+    while (blkCnt > 0U)
+    {
+      /* C = A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1] */
+  
+      /* Compute Power and store result in a temporary variable, sum. */
+      in = *pSrc++;
+      sum += ((q31_t) in * in);
+  
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+
+    *pResult = sum;
+}
+#else
+void arm_power_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q63_t * pResult)
+{
         uint32_t blkCnt;                               /* Loop counter */
         q63_t sum = 0;                                 /* Temporary result storage */
         q15_t in;                                      /* Temporary variable to store input value */
@@ -126,6 +170,7 @@
   /* Store result in 34.30 format */
   *pResult = sum;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of power group

CMSIS/DSP/Source/StatisticsFunctions/arm_power_q31.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q31.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q31.c
index 1e193b3..3a451bc 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q31.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q31.c
@@ -54,7 +54,50 @@
                    full precision of the intermediate multiplication is preserved.
                    Finally, the return result is in 16.48 format.
  */
+#if defined(ARM_MATH_MVEI)
+void arm_power_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q63_t * pResult)
+{
+    int32_t     blkCnt;           /* loop counters */
+    q31x4_t     vecSrc;
+    q63_t       sum = 0LL;
+    q31_t       in;
 
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrwq_s32(pSrc);
+        /*
+         * sum lanes
+         */
+        sum = vrmlaldavhaq(sum, vecSrc, vecSrc);
+
+        blkCnt --;
+        pSrc += 4;
+    }
+
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0x3;
+    while (blkCnt > 0U)
+    {
+       /* C = A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1] */
+
+       /* Compute Power and store result in a temporary variable, sum. */
+       in = *pSrc++;
+       sum += ((q63_t) in * in) >> 8;
+
+       /* Decrement loop counter */
+       blkCnt--;
+    }
+
+    *pResult = asrl(sum, 6);
+}
+#else
 void arm_power_q31(
   const q31_t * pSrc,
         uint32_t blockSize,
@@ -115,6 +158,7 @@
   /* Store results in 16.48 format */
   *pResult = sum;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of power group

CMSIS/DSP/Source/StatisticsFunctions/arm_power_q7.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q7.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q7.c
index 47405cd..fafe836 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q7.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_power_q7.c
@@ -53,7 +53,50 @@
                    full precision of the intermediate multiplication is preserved.
                    Finally, the return result is in 18.14 format.
  */
+#if defined(ARM_MATH_MVEI)
+void arm_power_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q7x16_t vecSrc;
+    q31_t   sum = 0LL;
+    q7_t in;
 
+   /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4U;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrbq_s8(pSrc);
+        /*
+         * sum lanes
+         */
+        sum = vmladavaq(sum, vecSrc, vecSrc);
+
+        blkCnt--;
+        pSrc += 16;
+    }
+
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0xF;
+    while (blkCnt > 0U)
+    {
+       /* C = A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1] */
+
+       /* Compute Power and store result in a temporary variable, sum. */
+       in = *pSrc++;
+       sum += ((q15_t) in * in);
+
+       /* Decrement loop counter */
+       blkCnt--;
+    }
+
+    *pResult = sum;
+}
+#else
 void arm_power_q7(
   const q7_t * pSrc,
         uint32_t blockSize,
@@ -130,6 +173,7 @@
   /* Store result in 18.14 format */
   *pResult = sum;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of power group

CMSIS/DSP/Source/StatisticsFunctions/arm_rms_f32.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_f32.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_f32.c
index 4546510..118f539 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_f32.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_f32.c
@@ -57,7 +57,22 @@
   @param[out]    pResult    root mean square value returned here
   @return        none
  */
-#if defined(ARM_MATH_NEON)
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+void arm_rms_f32(
+  const float32_t * pSrc,
+  uint32_t blockSize,
+  float32_t * pResult)
+{
+    float32_t pow = 0.0f;
+
+    arm_power_f32(pSrc, blockSize, &pow);
+
+    /* Compute Rms and store the result in the destination */
+    arm_sqrt_f32(pow / (float32_t) blockSize, pResult);
+}
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
 void arm_rms_f32(
   const float32_t * pSrc,
   uint32_t blockSize,
@@ -118,7 +133,7 @@
         float32_t sum = 0.0f;                          /* Temporary result storage */
         float32_t in;                                  /* Temporary variable to store input value */
 
-#if defined (ARM_MATH_LOOPUNROLL)
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
 
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
@@ -170,6 +185,7 @@
   arm_sqrt_f32(sum / (float32_t) blockSize, pResult);
 }
 #endif /* #if defined(ARM_MATH_NEON) */
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of RMS group

CMSIS/DSP/Source/StatisticsFunctions/arm_rms_q15.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_q15.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_q15.c
index 9fcd964..8097771 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_q15.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_q15.c
@@ -54,7 +54,21 @@
                    Finally, the 34.30 result is truncated to 34.15 format by discarding the lower
                    15 bits, and then saturated to yield a result in 1.15 format.
  */
+#if defined(ARM_MATH_MVEI)
+void arm_rms_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+    q63_t pow = 0.0f;
+    q15_t normalizedPower;
 
+    arm_power_q15(pSrc, blockSize, &pow);
+
+    normalizedPower=__SSAT((pow / (q63_t) blockSize) >> 15,16);
+    arm_sqrt_q15(normalizedPower, pResult);
+}
+#else
 void arm_rms_q15(
   const q15_t * pSrc,
         uint32_t blockSize,
@@ -128,6 +142,7 @@
   /* Store result in destination */
   arm_sqrt_q15(__SSAT((sum / (q63_t)blockSize) >> 15, 16), pResult);
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of RMS group

CMSIS/DSP/Source/StatisticsFunctions/arm_rms_q31.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_q31.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_q31.c
index 5a3e8f3..3c1c692 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_q31.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_q31.c
@@ -56,12 +56,28 @@
                    log2(blockSize) bits, as a total of blockSize additions are performed internally.
                    Finally, the 2.62 accumulator is right shifted by 31 bits to yield a 1.31 format value.
  */
+#if defined(ARM_MATH_MVEI)
 
 void arm_rms_q31(
   const q31_t * pSrc,
         uint32_t blockSize,
         q31_t * pResult)
 {
+    q63_t pow = 0.0f;
+    q31_t normalizedPower;
+    arm_power_q31(pSrc, blockSize, &pow);
+
+    normalizedPower=clip_q63_to_q31((pow / (q63_t) blockSize) >> 17);
+    arm_sqrt_q31(normalizedPower, pResult);
+
+}
+
+#else
+void arm_rms_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
         uint32_t blkCnt;                               /* Loop counter */
         uint64_t sum = 0;                              /* Temporary result storage (can get never negative. changed type from q63 to uint64 */
         q31_t in;                                      /* Temporary variable to store input value */
@@ -118,6 +134,7 @@
   /* Compute Rms and store result in destination vector */
   arm_sqrt_q31(clip_q63_to_q31((sum / (q63_t) blockSize) >> 31), pResult);
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of RMS group

CMSIS/DSP/Source/StatisticsFunctions/arm_std_f32.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_std_f32.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_std_f32.c
index e1e6577..ea160d4 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_std_f32.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_std_f32.c
@@ -60,7 +60,7 @@
   @param[out]    pResult    standard deviation value returned here
   @return        none
  */
-#if defined(ARM_MATH_NEON_EXPERIMENTAL)
+#if (defined(ARM_MATH_NEON_EXPERIMENTAL) || defined(ARM_MATH_MVEF)) && !defined(ARM_MATH_AUTOVECTORIZE)
 void arm_std_f32(
   const float32_t * pSrc,
         uint32_t blockSize,
@@ -94,7 +94,7 @@
     return;
   }
 
-#if defined (ARM_MATH_LOOPUNROLL)
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
 
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
@@ -181,7 +181,7 @@
 #endif /* #ifndef ARM_MATH_CM0_FAMILY */
 
 }
-#endif /* #if defined(ARM_MATH_NEON) */
+#endif /* #if defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF)*/
 
 /**
   @} end of STD group

CMSIS/DSP/Source/StatisticsFunctions/arm_std_q15.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_std_q15.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_std_q15.c
index 8e5c042..8003f83 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_std_q15.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_std_q15.c
@@ -54,7 +54,18 @@
                    Finally, the 34.30 result is truncated to 34.15 format by discarding the lower
                    15 bits, and then saturated to yield a result in 1.15 format.
  */
+#if defined(ARM_MATH_MVEI)
+void arm_std_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+    q15_t var=0;
 
+    arm_var_q15(pSrc, blockSize, &var);
+    arm_sqrt_q15(var,pResult);
+}
+#else
 void arm_std_q15(
   const q15_t * pSrc,
         uint32_t blockSize,
@@ -155,6 +166,7 @@
   /* Compute standard deviation and store result in destination */
   arm_sqrt_q15(__SSAT((meanOfSquares - squareOfMean) >> 15U, 16U), pResult);
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of STD group

CMSIS/DSP/Source/StatisticsFunctions/arm_std_q31.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_std_q31.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_std_q31.c
index cfb6cb8..190e595 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_std_q31.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_std_q31.c
@@ -57,7 +57,18 @@
                    After division, internal variables should be Q18.46
                    Finally, the 18.46 accumulator is right shifted by 15 bits to yield a 1.31 format value.
  */
+#if defined(ARM_MATH_MVEI)
+void arm_std_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+    q31_t var=0;
 
+    arm_var_q31(pSrc, blockSize, &var);
+    arm_sqrt_q31(var, pResult);
+}
+#else
 void arm_std_q31(
   const q31_t * pSrc,
         uint32_t blockSize,
@@ -141,6 +152,7 @@
   /* Compute standard deviation and store result in destination */
   arm_sqrt_q31((meanOfSquares - squareOfMean) >> 15U, pResult);
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of STD group

CMSIS/DSP/Source/StatisticsFunctions/arm_var_f32.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_var_f32.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_var_f32.c
index 3c325b1..22cc2ba 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_var_f32.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_var_f32.c
@@ -59,7 +59,65 @@
   @param[out]    pResult    variance value returned here
   @return        none
  */
-#if defined(ARM_MATH_NEON_EXPERIMENTAL)
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_var_f32(
+           const float32_t * pSrc,
+                 uint32_t blockSize,
+                 float32_t * pResult)
+{
+    int32_t         blkCnt;     /* loop counters */
+    f32x4_t         vecSrc;
+    f32x4_t         sumVec = vdupq_n_f32(0.0f);
+    float32_t       fMean;
+    float32_t sum = 0.0f;                          /* accumulator */
+    float32_t in;                                  /* Temporary variable to store input value */
+
+    if (blockSize <= 1U) {
+        *pResult = 0;
+        return;
+    }
+
+    arm_mean_f32(pSrc, blockSize, &fMean);
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+
+        vecSrc = vldrwq_f32(pSrc);
+        /*
+         * sum lanes
+         */
+        vecSrc = vsubq(vecSrc, fMean);
+        sumVec = vfmaq(sumVec, vecSrc, vecSrc);
+
+        blkCnt --;
+        pSrc += 4;
+    }
+
+    sum = vecAddAcrossF32Mve(sumVec);
+
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0x3;
+    while (blkCnt > 0U)
+    {
+       in = *pSrc++ - fMean;
+       sum += in * in;
+
+       /* Decrement loop counter */
+       blkCnt--;
+    }
+   
+    /* Variance */
+    *pResult = sum / (float32_t) (blockSize - 1);
+}
+#else
+#if defined(ARM_MATH_NEON_EXPERIMENTAL) && !defined(ARM_MATH_AUTOVECTORIZE)
 void arm_var_f32(
            const float32_t * pSrc,
                  uint32_t blockSize,
@@ -138,7 +196,7 @@
     return;
   }
 
-#if defined (ARM_MATH_LOOPUNROLL)
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
 
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
@@ -182,7 +240,7 @@
 
   pInput = pSrc;
 
-#if defined (ARM_MATH_LOOPUNROLL)
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
 
   /* Loop unrolling: Compute 4 outputs at a time */
   blkCnt = blockSize >> 2U;
@@ -228,6 +286,7 @@
   *pResult = fSum / (float32_t)(blockSize - 1.0f);
 }
 #endif /* #if defined(ARM_MATH_NEON) */
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of variance group

CMSIS/DSP/Source/StatisticsFunctions/arm_var_q15.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_var_q15.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_var_q15.c
index 259e76b..fcfaf3d 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_var_q15.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_var_q15.c
@@ -54,7 +54,72 @@
                    Finally, the 34.30 result is truncated to 34.15 format by discarding the lower
                    15 bits, and then saturated to yield a result in 1.15 format.
  */
+#if defined(ARM_MATH_MVEI)
+void arm_var_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+    int32_t  blkCnt;     /* loop counters */
+    q15x8_t         vecSrc;
+    q63_t           sumOfSquares = 0LL;
+    q63_t           meanOfSquares, squareOfMean;        /* square of mean and mean of square */
+    q63_t           sum = 0LL;
+    q15_t in; 
 
+    if (blockSize <= 1U) {
+        *pResult = 0;
+        return;
+    }
+
+
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrhq_s16(pSrc);
+        /* C = (A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1]) */
+        /* Compute Sum of squares of the input samples
+         * and then store the result in a temporary variable, sumOfSquares. */
+
+        sumOfSquares = vmlaldavaq(sumOfSquares, vecSrc, vecSrc);
+        sum = vaddvaq(sum, vecSrc);
+
+        blkCnt --;
+        pSrc += 8;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 7;
+    while (blkCnt > 0U)
+    {
+      /* C = A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1] */
+      /* C = A[0] + A[1] + ... + A[blockSize-1] */
+
+      in = *pSrc++;
+      /* Compute sum of squares and store result in a temporary variable, sumOfSquares. */
+#if defined (ARM_MATH_DSP)
+      sumOfSquares = __SMLALD(in, in, sumOfSquares);
+#else
+      sumOfSquares += (in * in);
+#endif /* #if defined (ARM_MATH_DSP) */
+      /* Compute sum and store result in a temporary variable, sum. */
+      sum += in;
+  
+      /* Decrement loop counter */
+      blkCnt--;
+    }
+
+    /* Compute Mean of squares of the input samples
+     * and then store the result in a temporary variable, meanOfSquares. */
+    meanOfSquares = arm_div_q63_to_q31(sumOfSquares, (blockSize - 1U));
+
+    /* Compute square of mean */
+    squareOfMean = arm_div_q63_to_q31((q63_t)sum * sum, (q31_t)(blockSize * (blockSize - 1U)));
+
+    /* mean of the squares minus the square of the mean. */
+    *pResult = (meanOfSquares - squareOfMean) >> 15;
+}
+#else
 void arm_var_q15(
   const q15_t * pSrc,
         uint32_t blockSize,
@@ -158,6 +223,7 @@
   /* mean of squares minus the square of mean. */
   *pResult = (meanOfSquares - squareOfMean) >> 15U;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of variance group

CMSIS/DSP/Source/StatisticsFunctions/arm_var_q31.c

diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_var_q31.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_var_q31.c
index 558332f..1d0f1e9 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_var_q31.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_var_q31.c
@@ -57,7 +57,74 @@
                    After division, internal variables should be Q18.46
                    Finally, the 18.46 accumulator is right shifted by 15 bits to yield a 1.31 format value.
  */
+#if defined(ARM_MATH_MVEI)
+void arm_var_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+    int32_t  blkCnt;     /* loop counters */
+    q31x4_t         vecSrc;
+    q63_t           sumOfSquares = 0LL;
+    q63_t           meanOfSquares, squareOfMean;        /* square of mean and mean of square */
+    q63_t           sum = 0LL;
+    q31_t in; 
 
+    if (blockSize <= 1U) {
+        *pResult = 0;
+        return;
+    }
+
+
+   /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vldrwq_s32(pSrc);
+        /* C = (A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1]) */
+        /* Compute Sum of squares of the input samples
+         * and then store the result in a temporary variable, sumOfSquares. */
+
+        /* downscale */
+        vecSrc = vshrq(vecSrc, 8);
+        sumOfSquares = vmlaldavaq(sumOfSquares, vecSrc, vecSrc);
+        sum = vaddlvaq(sum, vecSrc);
+
+        blkCnt --;
+        pSrc += 4;
+    }
+
+    
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0x3;
+    while (blkCnt > 0U)
+    {
+       /* C = A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1] */
+       /* C = A[0] + A[1] + ... + A[blockSize-1] */
+
+       in = *pSrc++ >> 8U;
+       /* Compute sum of squares and store result in a temporary variable, sumOfSquares. */
+       sumOfSquares += ((q63_t) (in) * (in));
+       /* Compute sum and store result in a temporary variable, sum. */
+       sum += in;
+   
+       /* Decrement loop counter */
+       blkCnt--;
+    }
+
+    /* Compute Mean of squares of the input samples
+     * and then store the result in a temporary variable, meanOfSquares. */
+    meanOfSquares = sumOfSquares / (q63_t) (blockSize - 1U);
+
+    /* Compute square of mean */
+    squareOfMean = sum * sum / (q63_t) (blockSize * (blockSize - 1U));
+
+    /* Compute standard deviation and then store the result to the destination */
+    *pResult = asrl(meanOfSquares - squareOfMean, 15U);
+}
+#else
 void arm_var_q31(
   const q31_t * pSrc,
         uint32_t blockSize,
@@ -141,7 +208,7 @@
   /* Compute variance and store result in destination */
   *pResult = (meanOfSquares - squareOfMean) >> 15U;
 }
-
+#endif
 /**
   @} end of variance group
  */

CMSIS/DSP/Testing/.gitignore

diff --git a/CMSIS/DSP/Testing/.gitignore b/CMSIS/DSP/Testing/.gitignore
index f4d0d77..02b57a4 100644
--- a/CMSIS/DSP/Testing/.gitignore
+++ b/CMSIS/DSP/Testing/.gitignore
@@ -14,3 +14,4 @@
 currentConfig.csv
 test.txt
 __pycache__
+bugcheck.py
\ No newline at end of file

CMSIS/DSP/Testing/CMakeLists.txt

diff --git a/CMSIS/DSP/Testing/CMakeLists.txt b/CMSIS/DSP/Testing/CMakeLists.txt
index 4c331c0..a23617f 100644
--- a/CMSIS/DSP/Testing/CMakeLists.txt
+++ b/CMSIS/DSP/Testing/CMakeLists.txt
@@ -151,6 +151,9 @@
   Source/Tests/TransformQ31.cpp
   Source/Tests/TransformQ15.cpp
   Source/Tests/StatsTestsF32.cpp
+  Source/Tests/StatsTestsQ31.cpp
+  Source/Tests/StatsTestsQ15.cpp
+  Source/Tests/StatsTestsQ7.cpp
   Source/Tests/SupportTestsF32.cpp
   Source/Tests/SupportBarTestsF32.cpp
   Source/Tests/DistanceTestsF32.cpp

CMSIS/DSP/Testing/FrameworkInclude/Error.h

diff --git a/CMSIS/DSP/Testing/FrameworkInclude/Error.h b/CMSIS/DSP/Testing/FrameworkInclude/Error.h
index 676a4ed..e2e8da1 100644
--- a/CMSIS/DSP/Testing/FrameworkInclude/Error.h
+++ b/CMSIS/DSP/Testing/FrameworkInclude/Error.h
@@ -27,7 +27,7 @@
  */
 #ifndef _ASSERT_H_
 #define _ASSERT_H_
-
+#include "arm_math.h"
 #include <exception>
 #include "Test.h"
 #include "Pattern.h"
@@ -81,6 +81,12 @@
 extern void assert_snr_error(unsigned long nb,AnyPattern<q15_t> &pa,AnyPattern<q15_t> &pb, float32_t threshold);
 extern void assert_snr_error(unsigned long nb,AnyPattern<q7_t> &pa,AnyPattern<q7_t> &pb, float32_t threshold);
 
+extern void assert_snr_error(unsigned long nb,float32_t pa,float32_t pb, float32_t threshold);
+extern void assert_snr_error(unsigned long nb,q63_t pa,q63_t pb, float32_t threshold);
+extern void assert_snr_error(unsigned long nb,q31_t pa,q31_t pb, float32_t threshold);
+extern void assert_snr_error(unsigned long nb,q15_t pa,q15_t pb, float32_t threshold);
+extern void assert_snr_error(unsigned long nb,q7_t pa,q7_t pb, float32_t threshold);
+
 extern void assert_true(unsigned long nb,bool cond);
 extern void assert_false(unsigned long nb,bool cond);
 
@@ -145,7 +151,7 @@
 {
     if (abs(pa - pb) > threshold)
     {
-         throw (Error(EQUAL_ERROR,nb));
+         throw (Error(NEAR_EQUAL_ERROR,nb));
     }
 };
 

CMSIS/DSP/Testing/FrameworkSource/Error.cpp

diff --git a/CMSIS/DSP/Testing/FrameworkSource/Error.cpp b/CMSIS/DSP/Testing/FrameworkSource/Error.cpp
index 3bbb88d..e641e91 100644
--- a/CMSIS/DSP/Testing/FrameworkSource/Error.cpp
+++ b/CMSIS/DSP/Testing/FrameworkSource/Error.cpp
@@ -25,6 +25,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "arm_math.h"
 #include "Error.h"
 
 namespace Client {
@@ -384,6 +385,20 @@
    }
 }
 
+void assert_snr_error(unsigned long nb,float32_t a,float32_t b, float32_t threshold)
+{
+   float32_t snr;
+
+   snr = arm_snr_f32(&a, &b, 1);
+
+   //printf("SNR = %f, %f %f\n",snr,a,b);
+   
+   if (snr < threshold)
+   {
+     throw (Error(SNR_ERROR,nb));
+   }
+}
+
 void assert_snr_error(unsigned long nb,AnyPattern<q63_t> &pa,AnyPattern<q63_t> &pb, float32_t threshold)
 {
    float32_t snr;
@@ -411,6 +426,21 @@
 
 }
 
+void assert_snr_error(unsigned long nb,q63_t a,q63_t b, float32_t threshold)
+{
+   float32_t snr;
+
+   snr = arm_snr_q63(&a, &b, 1);
+
+   //printf("SNR = %f\n",snr);
+
+   if (snr < threshold)
+   {
+     throw (Error(SNR_ERROR,nb));
+   }
+
+}
+
 void assert_snr_error(unsigned long nb,AnyPattern<q31_t> &pa,AnyPattern<q31_t> &pb, float32_t threshold)
 {
    float32_t snr;
@@ -437,6 +467,20 @@
 
 }
 
+void assert_snr_error(unsigned long nb,q31_t a,q31_t b, float32_t threshold)
+{
+   float32_t snr;
+
+   snr = arm_snr_q31(&a, &b, 1);
+
+
+   if (snr < threshold)
+   {
+     throw (Error(SNR_ERROR,nb));
+   }
+
+}
+
 void assert_snr_error(unsigned long nb,AnyPattern<q15_t> &pa,AnyPattern<q15_t> &pb, float32_t threshold)
 {
    float32_t snr;
@@ -463,6 +507,21 @@
 
 }
 
+void assert_snr_error(unsigned long nb,q15_t a,q15_t b, float32_t threshold)
+{
+   float32_t snr;
+
+   snr = arm_snr_q15(&a, &b, 1);
+
+   //printf("SNR = %f\n",snr);
+
+   if (snr < threshold)
+   {
+     throw (Error(SNR_ERROR,nb));
+   }
+
+}
+
 void assert_snr_error(unsigned long nb,AnyPattern<q7_t> &pa,AnyPattern<q7_t> &pb, float32_t threshold)
 {
    float32_t snr;
@@ -489,6 +548,21 @@
 
 }
 
+void assert_snr_error(unsigned long nb,q7_t a,q7_t b, float32_t threshold)
+{
+   float32_t snr;
+
+   snr = arm_snr_q7(&a, &b, 1);
+
+   //printf("SNR = %f\n",snr);
+
+   if (snr < threshold)
+   {
+     throw (Error(SNR_ERROR,nb));
+   }
+
+}
+
 void assert_true(unsigned long nb,bool cond)
 {
    if (!cond)

CMSIS/DSP/Testing/Include/Tests/StatsTestsF32.h

diff --git a/CMSIS/DSP/Testing/Include/Tests/StatsTestsF32.h b/CMSIS/DSP/Testing/Include/Tests/StatsTestsF32.h
index c35bb24..712d184 100755
--- a/CMSIS/DSP/Testing/Include/Tests/StatsTestsF32.h
+++ b/CMSIS/DSP/Testing/Include/Tests/StatsTestsF32.h
@@ -14,14 +14,19 @@
             Client::Pattern<int16_t> dims;
 
             Client::LocalPattern<float32_t> output;
+            Client::LocalPattern<int16_t> index;
             Client::LocalPattern<float32_t> tmp;
 
             // Reference patterns are not loaded when we are in dump mode
             Client::RefPattern<float32_t> ref;
+            Client::Pattern<int16_t> maxIndexes;
+            Client::Pattern<int16_t> minIndexes;
 
             int nbPatterns;
             int vecDim;
 
+            int refOffset;
+
            
 
     };

CMSIS/DSP/Testing/Include/Tests/StatsTestsQ15.h

diff --git a/CMSIS/DSP/Testing/Include/Tests/StatsTestsQ15.h b/CMSIS/DSP/Testing/Include/Tests/StatsTestsQ15.h
new file mode 100755
index 0000000..f2e7f32
--- /dev/null
+++ b/CMSIS/DSP/Testing/Include/Tests/StatsTestsQ15.h
@@ -0,0 +1,34 @@
+#include "Test.h"
+#include "Pattern.h"
+class StatsTestsQ15:public Client::Suite
+    {
+        public:
+            StatsTestsQ15(Testing::testID_t id);
+            virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr);
+            virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "StatsTestsQ15_decl.h"
+            
+            Client::Pattern<q15_t> inputA;
+            Client::Pattern<q15_t> inputB;
+            Client::Pattern<int16_t> dims;
+
+            Client::LocalPattern<q15_t> output;
+            Client::LocalPattern<q63_t> outputPower;
+            Client::LocalPattern<int16_t> index;
+            Client::LocalPattern<q15_t> tmp;
+
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<q15_t> ref;
+            Client::RefPattern<q63_t> refPower;
+            Client::Pattern<int16_t> maxIndexes;
+            Client::Pattern<int16_t> minIndexes;
+
+            int nbPatterns;
+            int vecDim;
+
+            int refOffset;
+
+           
+
+    };

CMSIS/DSP/Testing/Include/Tests/StatsTestsQ31.h

diff --git a/CMSIS/DSP/Testing/Include/Tests/StatsTestsQ31.h b/CMSIS/DSP/Testing/Include/Tests/StatsTestsQ31.h
new file mode 100755
index 0000000..04d554e
--- /dev/null
+++ b/CMSIS/DSP/Testing/Include/Tests/StatsTestsQ31.h
@@ -0,0 +1,34 @@
+#include "Test.h"
+#include "Pattern.h"
+class StatsTestsQ31:public Client::Suite
+    {
+        public:
+            StatsTestsQ31(Testing::testID_t id);
+            virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr);
+            virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "StatsTestsQ31_decl.h"
+            
+            Client::Pattern<q31_t> inputA;
+            Client::Pattern<q31_t> inputB;
+            Client::Pattern<int16_t> dims;
+
+            Client::LocalPattern<q31_t> output;
+            Client::LocalPattern<q63_t> outputPower;
+            Client::LocalPattern<int16_t> index;
+            Client::LocalPattern<q31_t> tmp;
+
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<q31_t> ref;
+            Client::RefPattern<q63_t> refPower;
+            Client::Pattern<int16_t> maxIndexes;
+            Client::Pattern<int16_t> minIndexes;
+
+            int nbPatterns;
+            int vecDim;
+
+            int refOffset;
+
+           
+
+    };

CMSIS/DSP/Testing/Include/Tests/StatsTestsQ7.h

diff --git a/CMSIS/DSP/Testing/Include/Tests/StatsTestsQ7.h b/CMSIS/DSP/Testing/Include/Tests/StatsTestsQ7.h
new file mode 100755
index 0000000..74227a6
--- /dev/null
+++ b/CMSIS/DSP/Testing/Include/Tests/StatsTestsQ7.h
@@ -0,0 +1,34 @@
+#include "Test.h"
+#include "Pattern.h"
+class StatsTestsQ7:public Client::Suite
+    {
+        public:
+            StatsTestsQ7(Testing::testID_t id);
+            virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr);
+            virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "StatsTestsQ7_decl.h"
+            
+            Client::Pattern<q7_t> inputA;
+            Client::Pattern<q7_t> inputB;
+            Client::Pattern<int16_t> dims;
+
+            Client::LocalPattern<q7_t> output;
+            Client::LocalPattern<q31_t> outputPower;
+            Client::LocalPattern<int16_t> index;
+            Client::LocalPattern<q7_t> tmp;
+
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<q7_t> ref;
+            Client::RefPattern<q31_t> refPower;
+            Client::Pattern<int16_t> maxIndexes;
+            Client::Pattern<int16_t> minIndexes;
+
+            int nbPatterns;
+            int vecDim;
+
+            int refOffset;
+
+           
+
+    };

CMSIS/DSP/Testing/PatternGeneration/Stats.py

diff --git a/CMSIS/DSP/Testing/PatternGeneration/Stats.py b/CMSIS/DSP/Testing/PatternGeneration/Stats.py
index 13d8413..17f780a 100755
--- a/CMSIS/DSP/Testing/PatternGeneration/Stats.py
+++ b/CMSIS/DSP/Testing/PatternGeneration/Stats.py
@@ -5,6 +5,7 @@
 import numpy as np
 import scipy
 import scipy.stats
+import math
 
 NBTESTS = 10
 VECDIM = [12,14,20]
@@ -101,31 +102,194 @@
     config.writeInputS16(nb, dims,"Dims")
     config.writeReference(nb, outputs,"RefLogSumExpDot")
 
-def writeF32OnlyTests(config):
-    entropyTest(config,1)
-    logsumexpTest(config,2)
-    klTest(config,3)
-    logSumExpDotTest(config,4)
-    return(4)
+def writeF32OnlyTests(config,nb):
+    entropyTest(config,nb)
+    logsumexpTest(config,nb+1)
+    klTest(config,nb+2)
+    logSumExpDotTest(config,nb+3)
+    return(nb+4)
 
 def generateMaxTests(config,nb,format,data):
 
-    nbiters = Tools.loopnb(format,Tools.TAILONLY)
     
+    indexes=[]
+    maxvals=[]
+
+    nbiters = Tools.loopnb(format,Tools.TAILONLY)
     index=np.argmax(data[0:nbiters])
     maxvalue=data[index]
 
+    indexes.append(index)
+    maxvals.append(maxvalue)
+
+    nbiters = Tools.loopnb(format,Tools.BODYONLY)
+    index=np.argmax(data[0:nbiters])
+    maxvalue=data[index]
+
+    indexes.append(index)
+    maxvals.append(maxvalue)
+
+    nbiters = Tools.loopnb(format,Tools.BODYANDTAIL)
+    index=np.argmax(data[0:nbiters])
+    maxvalue=data[index]
+
+    indexes.append(index)
+    maxvals.append(maxvalue)
+
+    if format == 7:
+      # Force max at position 280
+  
+      nbiters = 280
+  
+      data = np.zeros(nbiters)
+  
+      data[nbiters-1] = 0.9 
+      data[nbiters-2] = 0.8 
+  
+      index=np.argmax(data[0:nbiters])
+      maxvalue=data[index]
+  
+      indexes.append(index)
+      maxvals.append(maxvalue)
+
+      config.writeInput(nb, data,"InputMaxIndexMax")
+
+    config.writeReference(nb, maxvals,"MaxVals")
+    config.writeInputS16(nb, indexes,"MaxIndexes")
+    return(nb+1)
+
+def generateMinTests(config,nb,format,data):
+
+    
+    indexes=[]
+    maxvals=[]
+
+    nbiters = Tools.loopnb(format,Tools.TAILONLY)
+    index=np.argmin(data[0:nbiters])
+    maxvalue=data[index]
+
+    indexes.append(index)
+    maxvals.append(maxvalue)
+
+    nbiters = Tools.loopnb(format,Tools.BODYONLY)
+    index=np.argmin(data[0:nbiters])
+    maxvalue=data[index]
+
+    indexes.append(index)
+    maxvals.append(maxvalue)
+
+    nbiters = Tools.loopnb(format,Tools.BODYANDTAIL)
+    index=np.argmin(data[0:nbiters])
+    maxvalue=data[index]
+
+    indexes.append(index)
+    maxvals.append(maxvalue)
+
+    if format == 7:
+       # Force max at position 280
+       nbiters = 280
    
+       data = 0.9*np.ones(nbiters)
+   
+       data[nbiters-1] = 0.0 
+       data[nbiters-2] = 0.1 
+   
+       index=np.argmin(data[0:nbiters])
+       maxvalue=data[index]
+   
+       indexes.append(index)
+       maxvals.append(maxvalue)
+   
+      
+       config.writeInput(nb, data,"InputMinIndexMax")
+    config.writeReference(nb, maxvals,"MinVals")
+    config.writeInputS16(nb, indexes,"MinIndexes")
+    return(nb+1)
+
+def averageTest(format,data):
+   return(np.average(data))
+
+def powerTest(format,data):
+   if format == 31:
+       return(np.dot(data,data) / 2**15) # CMSIS is 2.28 format
+   elif format == 15:
+       return(np.dot(data,data) / 2**33) # CMSIS is 34.30 format
+   elif format == 7:
+       return(np.dot(data,data) / 2**17) # CMSIS is 18.14 format
+   else:
+       return(np.dot(data,data))
+
+def rmsTest(format,data):
+   return(math.sqrt(np.dot(data,data)/data.size))
+
+def stdTest(format,data):
+   return(np.std(data,ddof=1))
+
+def varTest(format,data):
+   return(np.var(data,ddof=1))
+
+def generateFuncTests(config,nb,format,data,func,name):
+
+    funcvals=[]
+
+    nbiters = Tools.loopnb(format,Tools.TAILONLY)
+    funcvalue=func(format,data[0:nbiters])
+    funcvals.append(funcvalue)
+
+    nbiters = Tools.loopnb(format,Tools.BODYONLY)
+    funcvalue=func(format,data[0:nbiters])
+    funcvals.append(funcvalue)
+
+    nbiters = Tools.loopnb(format,Tools.BODYANDTAIL)
+    funcvalue=func(format,data[0:nbiters])
+    funcvals.append(funcvalue)
+
+    config.writeReference(nb, funcvals,name)
+    return(nb+1)
+
+def generatePowerTests(config,nb,format,data):
+
+    funcvals=[]
+
+    nbiters = Tools.loopnb(format,Tools.TAILONLY)
+    funcvalue=powerTest(format,data[0:nbiters])
+    funcvals.append(funcvalue)
+
+    nbiters = Tools.loopnb(format,Tools.BODYONLY)
+    funcvalue=powerTest(format,data[0:nbiters])
+    funcvals.append(funcvalue)
+
+    nbiters = Tools.loopnb(format,Tools.BODYANDTAIL)
+    funcvalue=powerTest(format,data[0:nbiters])
+    funcvals.append(funcvalue)
+
+    if format==31 or format==15:
+      config.writeReferenceQ63(nb, funcvals,"PowerVals")
+    elif format==7:
+      config.writeReferenceQ31(nb, funcvals,"PowerVals")
+    else:
+      config.writeReference(nb, funcvals,"PowerVals")
     return(nb+1)
 
 def writeTests(config,nb,format):
+    NBSAMPLES = 300
     data1=np.random.randn(NBSAMPLES)
     data2=np.random.randn(NBSAMPLES)
     
     data1 = data1/max(data1)
-    data2 = data1/max(data2)
+    data2 = np.abs(data1)
+
+    config.writeInput(1, data1,"Input")
+    config.writeInput(2, data2,"Input")
 
     nb=generateMaxTests(config,nb,format,data1)
+    nb=generateFuncTests(config,nb,format,data2,averageTest,"MeanVals")
+    nb=generateMinTests(config,nb,format,data1)
+    nb=generatePowerTests(config,nb,format,data1)
+    nb=generateFuncTests(config,nb,format,data1,rmsTest,"RmsVals")
+    nb=generateFuncTests(config,nb,format,data1,stdTest,"StdVals")
+    nb=generateFuncTests(config,nb,format,data1,varTest,"VarVals")
+    return(nb)
 
 
 
@@ -137,8 +301,9 @@
 configq15=Tools.Config(PATTERNDIR,PARAMDIR,"q15")
 configq7 =Tools.Config(PATTERNDIR,PARAMDIR,"q7")
 
-nb=writeF32OnlyTests(configf32)
-writeTests(nb+1,configf32,0)
-writeTests(nb+1,configq31,31)
-writeTests(nb+1,configq15,15)
-writeTests(nb+1,configq7,7)
\ No newline at end of file
+nb=writeTests(configf32,1,0)
+nb=writeF32OnlyTests(configf32,22)
+
+writeTests(configq31,1,31)
+writeTests(configq15,1,15)
+writeTests(configq7,1,7)
\ No newline at end of file

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims22_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims1_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims22_s16.txt
old mode 100755
new mode 100644
similarity index 100%
rename from CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims1_s16.txt
rename to CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims22_s16.txt

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims23_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims2_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims23_s16.txt
old mode 100755
new mode 100644
similarity index 100%
rename from CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims2_s16.txt
rename to CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims23_s16.txt

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims24_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims3_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims24_s16.txt
old mode 100755
new mode 100644
similarity index 100%
rename from CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims3_s16.txt
rename to CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims24_s16.txt

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims25_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims1_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims25_s16.txt
old mode 100755
new mode 100644
similarity index 100%
copy from CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims1_s16.txt
copy to CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims25_s16.txt

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims4_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims4_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims4_s16.txt
deleted file mode 100755
index b392894..0000000
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Dims4_s16.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-H
-2
-// 10
-0x000A
-// 14
-0x000E

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input1_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input1_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input1_f32.txt
old mode 100755
new mode 100644
index 92dea2a..da4d3ed
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input1_f32.txt
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input1_f32.txt
@@ -1,282 +1,602 @@
 W
-140
-// 0.096126
-0x3dc4ddd0
-// 0.054879
-0x3d60c8d1
-// 0.035373
-0x3d10e2d3
-// 0.080156
-0x3da428ff
-// 0.015274
-0x3c7a4135
-// 0.123553
-0x3dfd0939
-// 0.020653
-0x3ca9303a
-// 0.101714
-0x3dd04f6e
-// 0.040169
-0x3d24885b
-// 0.138936
-0x3e0e4521
-// 0.129785
-0x3e04e66e
-// 0.015031
-0x3c764619
-// 0.024280
-0x3cc6e608
-// 0.124071
-0x3dfe18f2
-// 0.015211
-0x3c793604
-// 0.077605
-0x3d9eef79
-// 0.093893
-0x3dc04ac8
-// 0.049594
-0x3d4b2324
-// 0.074563
-0x3d98b488
-// 0.069522
-0x3d8e6150
-// 0.108617
-0x3dde72c5
-// 0.119865
-0x3df57ba7
-// 0.051507
-0x3d52f88b
-// 0.008593
-0x3c0cc915
-// 0.122105
-0x3dfa1248
-// 0.085292
-0x3daeadd3
-// 0.107960
-0x3ddd1a01
-// 0.015674
-0x3c806693
-// 0.161033
-0x3e24e5bf
-// 0.002654
-0x3b2df0d7
-// 0.012806
-0x3c51d19c
-// 0.014205
-0x3c68baac
-// 0.164592
-0x3e288ad7
-// 0.068758
-0x3d8cd0d6
-// 0.110863
-0x3de30c30
-// 0.135928
-0x3e0b30c9
-// 0.011206
-0x3c379b4c
-// 0.120655
-0x3df71a21
-// 0.010775
-0x3c3088b6
-// 0.062895
-0x3d80cf41
-// 0.062579
-0x3d802954
-// 0.061050
-0x3d7a0fed
-// 0.031948
-0x3d02db7d
-// 0.024362
-0x3cc79334
-// 0.101570
-0x3dd003c0
-// 0.103529
-0x3dd406de
-// 0.090873
-0x3dba1bde
-// 0.004786
-0x3b9cd3f3
-// 0.046927
-0x3d4036e2
-// 0.004842
-0x3b9eabbb
-// 0.068125
-0x3d8b8542
-// 0.090070
-0x3db876c0
-// 0.126675
-0x3e01b719
-// 0.110761
-0x3de2d6c2
-// 0.103435
-0x3dd3d58c
-// 0.092096
-0x3dbc9d0b
-// 0.145594
-0x3e151688
-// 0.126616
-0x3e01a7b0
-// 0.024383
-0x3cc7be82
-// 0.015570
-0x3c7f194e
-// 0.053057
-0x3d59522e
-// 0.058314
-0x3d6eda75
-// 0.044683
-0x3d3705de
-// 0.150977
-0x3e1a99c4
-// 0.107335
-0x3ddbd265
-// 0.172803
-0x3e30f326
-// 0.003024
-0x3b462896
-// 0.004310
-0x3b8d3e21
-// 0.003969
-0x3b820a96
-// 0.089366
-0x3db7057b
-// 0.102876
-0x3dd2b07e
-// 0.083029
-0x3daa0b3f
-// 0.059170
-0x3d725c12
-// 0.016977
-0x3c8b1456
-// 0.146734
-0x3e164174
-// 0.015161
-0x3c7864b9
-// 0.082400
-0x3da8c178
-// 0.026597
-0x3cd9e1fd
-// 0.036095
-0x3d13d7f2
-// 0.124590
-0x3dff28d1
-// 0.132641
-0x3e07d32c
-// 0.128042
-0x3e031d85
-// 0.020782
-0x3caa3ee9
-// 0.024906
-0x3ccc0724
-// 0.055786
-0x3d64805a
-// 0.039608
-0x3d223be6
-// 0.103623
-0x3dd4382c
-// 0.024213
-0x3cc65ade
-// 0.051646
-0x3d538b20
-// 0.094721
-0x3dc1fd45
-// 0.130185
-0x3e054f49
-// 0.065448
-0x3d860968
-// 0.099440
-0x3dcba70e
-// 0.120493
-0x3df6c54b
-// 0.074504
-0x3d9895c3
-// 0.044909
-0x3d37f2e2
-// 0.072976
-0x3d957479
-// 0.022446
-0x3cb7e0a3
-// 0.087826
-0x3db3de05
-// 0.070806
-0x3d9102ca
-// 0.039142
-0x3d205330
-// 0.068876
-0x3d8d0efc
-// 0.095886
-0x3dc45ff9
-// 0.046935
-0x3d403ecc
-// 0.104755
-0x3dd689c1
-// 0.085944
-0x3db00346
-// 0.025268
-0x3cceffcb
-// 0.051143
-0x3d517b83
-// 0.053822
-0x3d5c74eb
-// 0.108343
-0x3ddde2fa
-// 0.058181
-0x3d6e4f44
-// 0.103072
-0x3dd31772
-// 0.121733
-0x3df94eef
-// 0.097422
-0x3dc784fb
-// 0.048325
-0x3d45f022
-// 0.021655
-0x3cb165fd
-// 0.043063
-0x3d306264
-// 0.074061
-0x3d97ad50
-// 0.117680
-0x3df10229
-// 0.114582
-0x3deaa9d9
-// 0.122754
-0x3dfb6661
-// 0.060175
-0x3d7679b7
-// 0.049308
-0x3d49f78d
-// 0.119300
-0x3df453b6
-// 0.003159
-0x3b4f03c2
-// 0.006785
-0x3bde52a3
-// 0.117153
-0x3defee00
-// 0.019708
-0x3ca171c9
-// 0.082308
-0x3da8914b
-// 0.061496
-0x3d7be378
-// 0.039050
-0x3d1ff2f3
-// 0.036299
-0x3d14ae53
-// 0.104578
-0x3dd62cfa
-// 0.038682
-0x3d1e70e8
-// 0.002466
-0x3b219720
-// 0.146722
-0x3e163e5b
-// 0.076524
-0x3d9cb864
-// 0.060454
-0x3d779e40
-// 0.101473
-0x3dcfd10e
-// 0.113088
-0x3de79a73
+300
+// 0.180773
+0x3e391ca7
+// 0.003317
+0x3b595fd7
+// -0.335957
+0xbeac029b
+// 0.115844
+0x3ded3f99
+// 0.111880
+0x3de52180
+// 0.171240
+0x3e2f59a4
+// 0.153297
+0x3e1cf9d7
+// 0.009362
+0x3c196137
+// -0.049881
+0xbd4c502c
+// 0.000216
+0x3962d43a
+// 0.019048
+0x3c9c09af
+// -0.065724
+0xbd869a5c
+// -0.507955
+0xbf020956
+// -0.043368
+0xbd31a26b
+// 0.183172
+0x3e3b916d
+// -0.004976
+0xbba30af9
+// 0.203713
+0x3e509a27
+// -0.507682
+0xbf01f76c
+// 0.145941
+0x3e157173
+// 0.118502
+0x3df2b115
+// -0.371302
+0xbebe1b3c
+// -0.449494
+0xbee62419
+// 0.192967
+0x3e45992f
+// 0.158456
+0x3e224267
+// -0.014354
+0xbc6b2e0e
+// 0.332674
+0x3eaa5445
+// 0.286223
+0x3e928bc6
+// -0.052531
+0xbd572b13
+// -0.187712
+0xbe403799
+// -0.327488
+0xbea7ac91
+// -0.089872
+0xbdb80ee1
+// 0.453624
+0x3ee8415d
+// 0.121327
+0x3df87a0e
+// 0.210226
+0x3e574578
+// -0.146224
+0xbe15bbcc
+// 0.227184
+0x3e68a2d4
+// 0.241443
+0x3e773cef
+// 0.557693
+0x3f0ec4f2
+// -0.078583
+0xbda0f05b
+// 0.081011
+0x3da5e949
+// 0.068668
+0x3d8ca1b0
+// -0.254428
+0xbe824472
+// -0.369904
+0xbebd641d
+// 0.604297
+0x3f1ab33c
+// -0.201012
+0xbe4dd61f
+// 0.059607
+0x3d742655
+// 0.205533
+0x3e52775a
+// 0.076935
+0x3d9d9044
+// 0.324877
+0x3ea6564e
+// 0.134254
+0x3e0979d4
+// 0.167822
+0x3e2bd987
+// -0.039266
+0xbd20d5df
+// 0.172008
+0x3e3022f3
+// 0.159767
+0x3e2399e0
+// 0.180300
+0x3e38a08e
+// 0.205159
+0x3e52152f
+// 0.056502
+0x3d676ed5
+// -0.278222
+0xbe8e7324
+// 1.000000
+0x3f800000
+// 0.225469
+0x3e66e142
+// -0.101749
+0xbdd061f6
+// 0.077426
+0x3d9e91ae
+// -0.176034
+0xbe344234
+// 0.304814
+0x3e9c1090
+// -0.031973
+0xbd02f670
+// 0.286401
+0x3e92a331
+// 0.116988
+0x3def9754
+// -0.148372
+0xbe17eec3
+// -0.083924
+0xbdabe056
+// 0.279081
+0x3e8ee3a7
+// 0.027854
+0x3ce42d3a
+// -0.076946
+0xbd9d9610
+// -0.268039
+0xbe893c58
+// -0.246966
+0xbe7ce48f
+// 0.124787
+0x3dff906a
+// -0.019722
+0xbca19001
+// 0.021471
+0x3cafe3b7
+// 0.261079
+0x3e85ac2b
+// -0.038057
+0xbd1be154
+// -0.282582
+0xbe90aea5
+// -0.772133
+0xbf45aa88
+// 0.288227
+0x3e93927a
+// 0.306850
+0x3e9d1b7d
+// 0.140975
+0x3e105bac
+// -0.061042
+0xbd7a0751
+// -0.496855
+0xbefe63c4
+// -0.185225
+0xbe3dabb9
+// -0.040895
+0xbd2781c8
+// 0.005741
+0x3bbc1e2a
+// 0.315298
+0x3ea16eb9
+// 0.375930
+0x3ec079f6
+// 0.281762
+0x3e904320
+// -0.374771
+0xbebfe208
+// 0.225793
+0x3e673640
+// -0.029681
+0xbcf325f7
+// -0.217679
+0xbe5ee72b
+// -0.053910
+0xbd5cd139
+// -0.219700
+0xbe60f917
+// -0.358543
+0xbeb792e4
+// 0.612633
+0x3f1cd584
+// -0.052378
+0xbd5689d0
+// -0.593074
+0xbf17d3b2
+// -0.095387
+0xbdc35a7e
+// 0.277320
+0x3e8dfcee
+// -0.254922
+0xbe828528
+// 0.075413
+0x3d9a7208
+// 0.077348
+0x3d9e6888
+// -0.171646
+0xbe2fc3ef
+// -0.353420
+0xbeb4f36c
+// 0.756086
+0x3f418ee2
+// 0.192348
+0x3e44f6e3
+// -0.558221
+0xbf0ee78b
+// -0.349722
+0xbeb30eba
+// -0.117714
+0xbdf113f6
+// -0.176873
+0xbe351e39
+// 0.024051
+0x3cc505ef
+// 0.268485
+0x3e8976d0
+// 0.143505
+0x3e12f2e1
+// 0.147395
+0x3e16eeb4
+// -0.064866
+0xbd84d87b
+// -0.587286
+0xbf16585e
+// 0.347998
+0x3eb22ccd
+// 0.089509
+0x3db75049
+// -0.217681
+0xbe5ee7c0
+// -0.118649
+0xbdf2fe2b
+// -0.152026
+0xbe1baca4
+// -0.131582
+0xbe06bd84
+// -0.266943
+0xbe88acc5
+// 0.318698
+0x3ea32c66
+// 0.082573
+0x3da91c0b
+// -0.150573
+0xbe1a2fd5
+// 0.030381
+0x3cf8e1b9
+// 0.128629
+0x3e03b746
+// 0.043407
+0x3d31cb83
+// -0.490343
+0xbefb0e3d
+// 0.029675
+0x3cf3198f
+// 0.259883
+0x3e850f63
+// 0.201872
+0x3e4eb784
+// -0.004435
+0xbb9154e8
+// 0.406644
+0x3ed033a2
+// 0.023980
+0x3cc471b5
+// 0.703822
+0x3f342db1
+// -0.237431
+0xbe732118
+// -0.195532
+0xbe4839a7
+// 0.420122
+0x3ed71a3a
+// -0.176519
+0xbe34c178
+// -0.389200
+0xbec7452b
+// 0.286695
+0x3e92c9a9
+// -0.113949
+0xbde95dfe
+// 0.063220
+0x3d81794a
+// -0.135655
+0xbe0ae92c
+// -0.234746
+0xbe70614c
+// -0.123373
+0xbdfcaafe
+// 0.236578
+0x3e724185
+// 0.112751
+0x3de6ea3f
+// 0.430976
+0x3edca8f0
+// -0.173051
+0xbe313435
+// -0.539233
+0xbf0a0b2c
+// -0.106952
+0xbddb09b7
+// -0.248923
+0xbe7ee58c
+// 0.160052
+0x3e23e4b0
+// 0.405250
+0x3ecf7ce6
+// 0.038490
+0x3d1da749
+// -0.754819
+0xbf413bd4
+// 0.335065
+0x3eab8d9f
+// -0.010497
+0xbc2bf9c6
+// -0.153476
+0xbe1d28e3
+// -0.301231
+0xbe9a3aee
+// 0.133129
+0x3e085310
+// -0.206379
+0xbe535507
+// 0.291856
+0x3e956e32
+// -0.514779
+0xbf03c888
+// -0.204405
+0xbe514f7d
+// -0.680482
+0xbf2e340f
+// 0.298003
+0x3e9893d5
+// -0.000249
+0xb982bdc1
+// 0.155243
+0x3e1ef81b
+// -0.077929
+0xbd9f9907
+// 0.185250
+0x3e3db22f
+// -0.098374
+0xbdc9788d
+// 0.244998
+0x3e7ae0d9
+// 0.123930
+0x3dfdcee6
+// 0.294405
+0x3e96bc44
+// -0.098375
+0xbdc978fe
+// 0.307972
+0x3e9dae81
+// -0.002831
+0xbb399045
+// -0.096067
+0xbdc4bf04
+// 0.274925
+0x3e8cc301
+// 0.187400
+0x3e3fe5e7
+// -0.080963
+0xbda5cfd2
+// -0.327412
+0xbea7a281
+// 0.013138
+0x3c574235
+// -0.311934
+0xbe9fb5d6
+// -0.256389
+0xbe834566
+// 0.191764
+0x3e445dd7
+// 0.287594
+0x3e933f7e
+// 0.251833
+0x3e80f034
+// -0.391665
+0xbec88856
+// 0.315983
+0x3ea1c891
+// -0.095807
+0xbdc43661
+// -0.211389
+0xbe58763e
+// 0.258683
+0x3e84721c
+// 0.384232
+0x3ec4ba12
+// 0.576996
+0x3f13b602
+// 0.055314
+0x3d629156
+// -0.238307
+0xbe7406bb
+// 0.126599
+0x3e01a34b
+// 0.025223
+0x3ccea0b4
+// 0.124107
+0x3dfe2bbb
+// 0.121501
+0x3df8d591
+// -0.196324
+0xbe49091c
+// 0.422662
+0x3ed8672a
+// 0.089543
+0x3db76277
+// 0.278451
+0x3e8e9127
+// 0.059750
+0x3d74bc8c
+// -0.373473
+0xbebf37cc
+// -0.149498
+0xbe1915fb
+// 0.169801
+0x3e2de053
+// -0.397130
+0xbecb5497
+// -0.265939
+0xbe882919
+// -0.063404
+0xbd81da36
+// -0.219959
+0xbe613ce2
+// 0.038141
+0x3d1c3961
+// 0.169264
+0x3e2d5396
+// 0.167103
+0x3e2b1cf0
+// 0.463228
+0x3eed2c3f
+// -0.303581
+0xbe9b6ef1
+// -0.060459
+0xbd77a3a2
+// 0.273986
+0x3e8c47f3
+// 0.213953
+0x3e5b1680
+// -0.388064
+0xbec6b04d
+// 0.711034
+0x3f360651
+// 0.399716
+0x3ecca7a0
+// 0.191071
+0x3e43a826
+// -0.176286
+0xbe348453
+// -0.000611
+0xba204510
+// 0.205100
+0x3e5205d1
+// 0.247204
+0x3e7d2328
+// 0.020089
+0x3ca49261
+// -0.149378
+0xbe18f686
+// 0.128530
+0x3e039d7c
+// -0.036474
+0xbd156631
+// 0.227535
+0x3e68fee9
+// 0.176040
+0x3e3443d6
+// -0.176439
+0xbe34ac65
+// 0.479290
+0x3ef56580
+// 0.292146
+0x3e95941b
+// -0.004249
+0xbb8b3969
+// 0.912307
+0x3f698cf1
+// -0.591720
+0xbf177aef
+// -0.072924
+0xbd955966
+// 0.113417
+0x3de84736
+// 0.172742
+0x3e30e331
+// -0.050781
+0xbd4fff66
+// 0.084815
+0x3dadb382
+// -0.474700
+0xbef30bef
+// 0.156257
+0x3e2001da
+// 0.419153
+0x3ed69b44
+// 0.461078
+0x3eec1273
+// 0.038056
+0x3d1be037
+// -0.118122
+0xbdf1e9dd
+// 0.148492
+0x3e180e37
+// 0.034291
+0x3d0c746b
+// 0.181770
+0x3e3a21e9
+// -0.308913
+0xbe9e29e2
+// 0.333125
+0x3eaa8f5b
+// -0.174511
+0xbe32b315
+// -0.233817
+0xbe6f6dc3
+// 0.355195
+0x3eb5dc2f
+// -0.380402
+0xbec2c401
+// -0.230453
+0xbe6bfbd8
+// -0.570527
+0xbf120e10
+// 0.280631
+0x3e8faed9
+// 0.173200
+0x3e315b47
+// -0.096317
+0xbdc54199
+// 0.360819
+0x3eb8bd45
+// 0.040504
+0x3d25e7e9
+// 0.732779
+0x3f3b976a
+// 0.109666
+0x3de09865
+// -0.141874
+0xbe11475a
+// 0.012802
+0x3c51be14
+// 0.233586
+0x3e6f313f
+// -0.657900
+0xbf286c23
+// 0.136135
+0x3e0b6715
+// -0.406237
+0xbecffe42
+// -0.687533
+0xbf30022d
+// -0.049256
+0xbd49c0fa
+// -0.171818
+0xbe2ff126
+// 0.155693
+0x3e1f6de9
+// -0.447904
+0xbee553b0
+// -0.728481
+0xbf3a7dbe
+// -0.308104
+0xbe9dbfc1
+// 0.180673
+0x3e39026c
+// -0.131354
+0xbe068192
+// 0.289558
+0x3e9440f0
+// 0.366182
+0x3ebb7c3e
+// 0.041183
+0x3d28aeff
+// 0.263939
+0x3e872310
+// -0.179231
+0xbe37886c
+// -0.009728
+0xbc1f6314

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input22_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input22_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input22_f32.txt
new file mode 100644
index 0000000..79f7358
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input22_f32.txt
@@ -0,0 +1,282 @@
+W
+140
+// 0.084210
+0x3dac7617
+// 0.125953
+0x3e00f9ee
+// 0.051100
+0x3d514e65
+// 0.037159
+0x3d183411
+// 0.031853
+0x3d0277ed
+// 0.094133
+0x3dc0c8ee
+// 0.029542
+0x3cf202fd
+// 0.135122
+0x3e0a5d77
+// 0.010513
+0x3c2c3e7f
+// 0.073928
+0x3d97674e
+// 0.044184
+0x3d34fa6b
+// 0.126504
+0x3e018a61
+// 0.109382
+0x3de003b0
+// 0.046416
+0x3d3e1ef5
+// 0.062587
+0x3d802d88
+// 0.051601
+0x3d535bbd
+// 0.081759
+0x3da77185
+// 0.071160
+0x3d91bc7c
+// 0.115057
+0x3deba2d6
+// 0.053487
+0x3d5b15a2
+// 0.053461
+0x3d5afa3d
+// 0.050963
+0x3d50beb8
+// 0.111128
+0x3de396d3
+// 0.040307
+0x3d2518dc
+// 0.098382
+0x3dc97c55
+// 0.076757
+0x3d9d32b7
+// 0.046272
+0x3d3d87ef
+// 0.087078
+0x3db25633
+// 0.043927
+0x3d33eca2
+// 0.107278
+0x3ddbb457
+// 0.078113
+0x3d9ff9d0
+// 0.126179
+0x3e01352d
+// 0.108718
+0x3ddea774
+// 0.048196
+0x3d4569a4
+// 0.064732
+0x3d84923e
+// 0.016803
+0x3c89a6cf
+// 0.045639
+0x3d3aefd4
+// 0.102951
+0x3dd2d816
+// 0.006592
+0x3bd804b9
+// 0.132187
+0x3e075be7
+// 0.058521
+0x3d6fb377
+// 0.060164
+0x3d766e42
+// 0.048022
+0x3d44b31e
+// 0.065045
+0x3d853689
+// 0.034461
+0x3d0d26d4
+// 0.107508
+0x3ddc2ced
+// 0.105621
+0x3dd84fab
+// 0.044004
+0x3d343d8c
+// 0.102623
+0x3dd22be0
+// 0.067047
+0x3d895029
+// 0.095930
+0x3dc47729
+// 0.033714
+0x3d0a17fb
+// 0.081359
+0x3da69fad
+// 0.096670
+0x3dc5fb2c
+// 0.089166
+0x3db69cc3
+// 0.028828
+0x3cec2958
+// 0.092690
+0x3dbdd419
+// 0.062380
+0x3d7f827d
+// 0.071653
+0x3d92beca
+// 0.015679
+0x3c80712e
+// 0.044216
+0x3d351b5d
+// 0.131537
+0x3e06b184
+// 0.009674
+0x3c1e80a5
+// 0.028927
+0x3cecf88b
+// 0.083796
+0x3dab9d76
+// 0.132753
+0x3e07f05e
+// 0.113043
+0x3de7831e
+// 0.042030
+0x3d2c27c7
+// 0.118002
+0x3df1ab2c
+// 0.053620
+0x3d5ba08d
+// 0.077559
+0x3d9ed708
+// 0.154475
+0x3e1e2ed0
+// 0.146807
+0x3e165472
+// 0.024157
+0x3cc5e4f2
+// 0.078638
+0x3da10cfc
+// 0.144104
+0x3e138ff8
+// 0.002497
+0x3b23a956
+// 0.094160
+0x3dc0d6ca
+// 0.088282
+0x3db4cd5e
+// 0.004572
+0x3b95cdb1
+// 0.021887
+0x3cb34c9e
+// 0.041143
+0x3d28855f
+// 0.010779
+0x3c309b82
+// 0.110940
+0x3de334b8
+// 0.128217
+0x3e034b4b
+// 0.019143
+0x3c9cd190
+// 0.113663
+0x3de8c84c
+// 0.088359
+0x3db4f551
+// 0.007739
+0x3bfd97f1
+// 0.068537
+0x3d8c5d1f
+// 0.136630
+0x3e0be8a6
+// 0.038761
+0x3d1ec3e4
+// 0.047085
+0x3d40dc3d
+// 0.050939
+0x3d50a599
+// 0.031459
+0x3d00dacf
+// 0.088084
+0x3db46535
+// 0.121621
+0x3df91455
+// 0.059764
+0x3d74cb60
+// 0.107812
+0x3ddccc63
+// 0.015991
+0x3c82ffae
+// 0.017137
+0x3c8c635f
+// 0.073726
+0x3d96fd74
+// 0.057426
+0x3d6b3765
+// 0.092462
+0x3dbd5ced
+// 0.103492
+0x3dd3f3d8
+// 0.063862
+0x3d82ca37
+// 0.034311
+0x3d0c89a1
+// 0.074905
+0x3d9967ba
+// 0.053631
+0x3d5bac08
+// 0.075259
+0x3d9a2170
+// 0.109519
+0x3de04ba6
+// 0.120466
+0x3df6b712
+// 0.073334
+0x3d96303d
+// 0.129945
+0x3e05105d
+// 0.091491
+0x3dbb5fdd
+// 0.024290
+0x3cc6fbab
+// 0.061614
+0x3d7c5e92
+// 0.028434
+0x3ce8ee74
+// 0.029791
+0x3cf40b99
+// 0.126480
+0x3e0183e1
+// 0.107971
+0x3ddd1fdc
+// 0.097197
+0x3dc70ef8
+// 0.147431
+0x3e16f838
+// 0.043118
+0x3d309c9b
+// 0.020374
+0x3ca6e801
+// 0.018530
+0x3c97cc85
+// 0.115114
+0x3debc0c4
+// 0.101567
+0x3dd00241
+// 0.018728
+0x3c996bcc
+// 0.112820
+0x3de70e3a
+// 0.020396
+0x3ca71594
+// 0.060116
+0x3d763c5e
+// 0.058842
+0x3d710471
+// 0.113682
+0x3de8d1de
+// 0.088346
+0x3db4ee93
+// 0.014607
+0x3c6f51ea
+// 0.048559
+0x3d46e61b
+// 0.093526
+0x3dbf8a7d
+// 0.110609
+0x3de286dc
+// 0.043089
+0x3d307dd7

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input23_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input23_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input23_f32.txt
new file mode 100644
index 0000000..f26356e
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input23_f32.txt
@@ -0,0 +1,402 @@
+W
+200
+// 0.026005
+0x3cd508fe
+// 0.008493
+0x3c0b257c
+// 0.052784
+0x3d583394
+// 0.085227
+0x3dae8b5d
+// 0.057132
+0x3d6a02f2
+// 0.057391
+0x3d6b12b4
+// 0.063974
+0x3d8304ee
+// 0.089513
+0x3db75297
+// 0.088059
+0x3db45811
+// 0.058463
+0x3d6f773c
+// 0.053651
+0x3d5bc0f0
+// 0.036178
+0x3d142fce
+// 0.035535
+0x3d118d1c
+// 0.032859
+0x3d06970f
+// 0.072873
+0x3d953e60
+// 0.020678
+0x3ca964b2
+// 0.009725
+0x3c1f56d1
+// 0.000585
+0x3a194c5a
+// 0.087957
+0x3db422c5
+// 0.062919
+0x3d80dbaa
+// 0.063007
+0x3d8109fa
+// 0.079792
+0x3da369f1
+// 0.050345
+0x3d4e36e8
+// 0.022070
+0x3cb4cd21
+// 0.059086
+0x3d720417
+// 0.038227
+0x3d1c943c
+// 0.043699
+0x3d32fd3f
+// 0.026778
+0x3cdb5e17
+// 0.036773
+0x3d169f4d
+// 0.023821
+0x3cc32440
+// 0.094876
+0x3dc24e24
+// 0.048604
+0x3d4714c3
+// 0.043590
+0x3d328be0
+// 0.016343
+0x3c85e26a
+// 0.078576
+0x3da0ec7d
+// 0.022692
+0x3cb9e56c
+// 0.080406
+0x3da4abb9
+// 0.020671
+0x3ca9571c
+// 0.084588
+0x3dad3c92
+// 0.066054
+0x3d87475a
+// 0.106781
+0x3ddaafd7
+// 0.001693
+0x3adde47f
+// 0.049610
+0x3d4b33e0
+// 0.028725
+0x3ceb503d
+// 0.070081
+0x3d8f86e1
+// 0.061077
+0x3d7a2b8a
+// 0.078177
+0x3da01b76
+// 0.041875
+0x3d2b859f
+// 0.077297
+0x3d9e4dcf
+// 0.093087
+0x3dbea43c
+// 0.003929
+0x3b80bdbc
+// 0.005097
+0x3ba70300
+// 0.101802
+0x3dd07d8c
+// 0.028720
+0x3ceb4623
+// 0.010461
+0x3c2b62e3
+// 0.026961
+0x3cdcde34
+// 0.059111
+0x3d721ec6
+// 0.013326
+0x3c5a5672
+// 0.072581
+0x3d94a596
+// 0.069608
+0x3d8e8ed0
+// 0.018285
+0x3c95ca45
+// 0.002536
+0x3b262aaa
+// 0.074779
+0x3d9925e4
+// 0.059811
+0x3d74fc28
+// 0.051748
+0x3d53f575
+// 0.054695
+0x3d6007c3
+// 0.042953
+0x3d2fefc6
+// 0.044519
+0x3d365932
+// 0.077961
+0x3d9fa9e0
+// 0.061605
+0x3d7c555b
+// 0.043604
+0x3d3299d0
+// 0.069007
+0x3d8d5378
+// 0.065718
+0x3d869711
+// 0.050583
+0x3d4f2ff3
+// 0.069427
+0x3d8e2f88
+// 0.055812
+0x3d649b16
+// 0.021066
+0x3cac9275
+// 0.047894
+0x3d442c54
+// 0.020137
+0x3ca4f75b
+// 0.067862
+0x3d8afb61
+// 0.037472
+0x3d197bbb
+// 0.057275
+0x3d6a98f4
+// 0.027602
+0x3ce21e27
+// 0.084665
+0x3dad64bf
+// 0.017512
+0x3c8f7522
+// 0.007250
+0x3bed8e73
+// 0.035012
+0x3d0f684a
+// 0.087569
+0x3db35722
+// 0.092624
+0x3dbdb1cd
+// 0.010345
+0x3c297dd5
+// 0.003128
+0x3b4d0659
+// 0.052166
+0x3d55ac56
+// 0.079954
+0x3da3bec6
+// 0.031037
+0x3cfe410c
+// 0.024184
+0x3cc61ddb
+// 0.070852
+0x3d911abe
+// 0.079799
+0x3da36d6d
+// 0.085593
+0x3daf4b94
+// 0.080038
+0x3da3eb05
+// 0.035924
+0x3d132581
+// 0.026941
+0x3cdcb304
+// 0.042201
+0x3d2cdb5b
+// 0.067377
+0x3d89fd1e
+// 0.070427
+0x3d903c3d
+// 0.022993
+0x3cbc5ba6
+// 0.079282
+0x3da25e84
+// 0.074061
+0x3d97ad15
+// 0.055389
+0x3d62dfcb
+// 0.036704
+0x3d165728
+// 0.078917
+0x3da19f17
+// 0.054463
+0x3d5f1511
+// 0.046116
+0x3d3ce476
+// 0.038153
+0x3d1c46a2
+// 0.017950
+0x3c930c0d
+// 0.055459
+0x3d6328bb
+// 0.064202
+0x3d837c64
+// 0.006692
+0x3bdb454e
+// 0.037200
+0x3d185f19
+// 0.048357
+0x3d4611b2
+// 0.077115
+0x3d9dee91
+// 0.030540
+0x3cfa2eaf
+// 0.038796
+0x3d1ee83b
+// 0.020878
+0x3cab08eb
+// 0.070101
+0x3d8f914d
+// 0.025802
+0x3cd35dce
+// 0.083143
+0x3daa46a9
+// 0.090793
+0x3db9f1aa
+// 0.071000
+0x3d9168a5
+// 0.004052
+0x3b84c6f7
+// 0.016665
+0x3c888572
+// 0.053592
+0x3d5b83bd
+// 0.033555
+0x3d097085
+// 0.044426
+0x3d35f7e2
+// 0.103757
+0x3dd47e56
+// 0.030692
+0x3cfb6d88
+// 0.002639
+0x3b2cf7cb
+// 0.094562
+0x3dc1a9c4
+// 0.076354
+0x3d9c5f49
+// 0.092598
+0x3dbda446
+// 0.016055
+0x3c838676
+// 0.035229
+0x3d104c2e
+// 0.057887
+0x3d6d1ad2
+// 0.065474
+0x3d86171e
+// 0.031391
+0x3d009355
+// 0.077979
+0x3d9fb369
+// 0.067197
+0x3d899e58
+// 0.040936
+0x3d27ad02
+// 0.052674
+0x3d57c0dc
+// 0.067770
+0x3d8acacb
+// 0.016553
+0x3c8799cd
+// 0.090299
+0x3db8ee7a
+// 0.038478
+0x3d1d9b5f
+// 0.040254
+0x3d24e1af
+// 0.039006
+0x3d1fc51d
+// 0.033211
+0x3d0808b3
+// 0.084359
+0x3dacc437
+// 0.059098
+0x3d7210f3
+// 0.008187
+0x3c0623da
+// 0.022101
+0x3cb50e10
+// 0.071917
+0x3d93492f
+// 0.002010
+0x3b03ba53
+// 0.102633
+0x3dd2316f
+// 0.033350
+0x3d0899a2
+// 0.015731
+0x3c80ddb0
+// 0.025850
+0x3cd3c44d
+// 0.059916
+0x3d756aa8
+// 0.012761
+0x3c5114d1
+// 0.034479
+0x3d0d39d8
+// 0.079822
+0x3da379ae
+// 0.067313
+0x3d89db58
+// 0.021457
+0x3cafc769
+// 0.098106
+0x3dc8ebab
+// 0.015895
+0x3c823600
+// 0.067425
+0x3d8a15ef
+// 0.035891
+0x3d130225
+// 0.099393
+0x3dcb8e5b
+// 0.018513
+0x3c97a825
+// 0.077645
+0x3d9f0422
+// 0.070742
+0x3d90e0f9
+// 0.061070
+0x3d7a240f
+// 0.048583
+0x3d46ff0e
+// 0.081195
+0x3da649cc
+// 0.010150
+0x3c264ae0
+// 0.070596
+0x3d9094a2
+// 0.058345
+0x3d6efb88
+// 0.032147
+0x3d03ac95
+// 0.071847
+0x3d93244e
+// 0.018212
+0x3c953121
+// 0.088104
+0x3db46fbf
+// 0.036104
+0x3d13e169
+// 0.020604
+0x3ca8c8fb
+// 0.007394
+0x3bf246b0
+// 0.087792
+0x3db3cc67
+// 0.062764
+0x3d808a4d
+// 0.022160
+0x3cb58968
+// 0.072603
+0x3d94b119
+// 0.076714
+0x3d9d1c0e
+// 0.046214
+0x3d3d4a70
+// 0.074313
+0x3d983187
+// 0.014160
+0x3c67ffd3

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input2_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input2_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input2_f32.txt
old mode 100755
new mode 100644
index 0ccba92..6b5354a
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input2_f32.txt
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/Input2_f32.txt
@@ -1,402 +1,602 @@
 W
-200
-// 0.056235
-0x3d66572c
-// 0.077805
-0x3d9f5833
-// 0.043943
-0x3d33fd8f
-// 0.063779
-0x3d829e5c
-// 0.064986
-0x3d851773
-// 0.054177
-0x3d5de8d5
-// 0.037718
-0x3d1a7ea1
-// 0.060158
-0x3d7667c4
-// 0.086482
-0x3db11d8a
-// 0.082833
-0x3da9a440
-// 0.050966
-0x3d50c1f6
-// 0.005996
-0x3bc47d21
-// 0.087289
-0x3db2c47c
-// 0.016967
-0x3c8aff60
-// 0.014258
-0x3c699986
-// 0.026259
-0x3cd71c4d
-// 0.077756
-0x3d9f3eb9
-// 0.018830
-0x3c9a4143
-// 0.008146
-0x3c05756c
-// 0.065417
-0x3d85f91d
-// 0.017280
-0x3c8d8f86
-// 0.006173
-0x3bca442f
-// 0.031528
-0x3d0123fb
-// 0.045332
-0x3d39ada6
-// 0.060593
-0x3d782fef
-// 0.012308
-0x3c49a7dc
-// 0.059121
-0x3d72295e
-// 0.070851
-0x3d911a18
-// 0.084293
-0x3daca201
-// 0.101793
-0x3dd078a1
-// 0.038845
-0x3d1f1be0
-// 0.063282
-0x3d819a1c
-// 0.013683
-0x3c603040
-// 0.061395
-0x3d7b7990
-// 0.049085
-0x3d490ce0
-// 0.074528
-0x3d98a234
-// 0.053696
-0x3d5bf0af
-// 0.083965
-0x3dabf60c
-// 0.014367
-0x3c6b6278
-// 0.057881
-0x3d6d14f9
-// 0.075077
-0x3d99c22b
-// 0.063741
-0x3d828ac9
-// 0.006331
-0x3bcf70fc
-// 0.062521
-0x3d800ad1
-// 0.014482
-0x3c6d47e5
-// 0.000047
-0x38464452
-// 0.081241
-0x3da66174
-// 0.021053
-0x3cac77f4
-// 0.026764
-0x3cdb4023
-// 0.116510
-0x3dee9c96
-// 0.013493
-0x3c5d10e5
-// 0.089995
-0x3db84f41
-// 0.000171
-0x3932fbe2
-// 0.086223
-0x3db09572
-// 0.106877
-0x3ddae292
-// 0.004089
-0x3b85fa3a
-// 0.057155
-0x3d6a1b1c
-// 0.111539
-0x3de46eaf
-// 0.060647
-0x3d7868ea
-// 0.002045
-0x3b060414
-// 0.060276
-0x3d76e424
-// 0.003055
-0x3b483ae7
-// 0.040906
-0x3d278d5c
-// 0.061561
-0x3d7c27de
-// 0.035198
-0x3d102bbc
-// 0.069424
-0x3d8e2e1f
-// 0.055495
-0x3d634e71
-// 0.060152
-0x3d7661c2
-// 0.059809
-0x3d74f9f8
-// 0.056055
-0x3d659a1e
-// 0.056583
-0x3d67c319
-// 0.038416
-0x3d1d5a6d
-// 0.038873
-0x3d1f39bc
-// 0.051058
-0x3d5121fb
-// 0.064343
-0x3d83c630
-// 0.045519
-0x3d3a71f1
-// 0.044943
-0x3d3815ad
-// 0.061532
-0x3d7c088b
-// 0.020923
-0x3cab678f
-// 0.075879
-0x3d9b6692
-// 0.011548
-0x3c3d3392
-// 0.070785
-0x3d90f7d7
-// 0.054558
-0x3d5f77d9
-// 0.013389
-0x3c5b5bbc
-// 0.014933
-0x3c74ab8e
-// 0.015557
-0x3c7ee3ca
-// 0.085977
-0x3db014d6
-// 0.051554
-0x3d5329da
-// 0.090497
-0x3db9567a
-// 0.034857
-0x3d0ec5e8
-// 0.067221
-0x3d89ab4d
-// 0.094795
-0x3dc223f3
-// 0.050355
-0x3d4e409a
-// 0.047586
-0x3d42e96c
-// 0.048152
-0x3d453b73
-// 0.035092
-0x3d0fbc77
-// 0.032954
-0x3d06fadd
-// 0.061213
-0x3d7aba1d
-// 0.084998
-0x3dae134c
-// 0.033980
-0x3d0b2e6a
-// 0.038308
-0x3d1ce87d
-// 0.037561
-0x3d19d98c
-// 0.018229
-0x3c955521
-// 0.050508
-0x3d4ee1e7
-// 0.080445
-0x3da4c042
-// 0.081487
-0x3da6e2ad
-// 0.006107
-0x3bc81974
-// 0.051214
-0x3d51c5ff
-// 0.098546
-0x3dc9d293
-// 0.095200
-0x3dc2f864
-// 0.081929
-0x3da7ca61
-// 0.028955
-0x3ced33e2
-// 0.045321
-0x3d39a24d
-// 0.034107
-0x3d0bb37d
-// 0.035228
-0x3d104b96
-// 0.013547
-0x3c5df3d7
-// 0.030927
-0x3cfd5af4
-// 0.078610
-0x3da0fe78
-// 0.073860
-0x3d9743a9
-// 0.019911
-0x3ca31b7c
-// 0.042311
-0x3d2d4e09
-// 0.019992
-0x3ca3c590
-// 0.061218
-0x3d7ac03d
-// 0.067824
-0x3d8ae749
-// 0.056913
-0x3d691d90
-// 0.033024
-0x3d0744b1
-// 0.013628
-0x3c5f48e1
-// 0.011932
-0x3c437fc1
-// 0.020891
-0x3cab22c3
-// 0.081911
-0x3da7c0fe
-// 0.081018
-0x3da5ec91
-// 0.036514
-0x3d159006
-// 0.067579
-0x3d8a66dc
-// 0.025495
-0x3cd0db37
-// 0.081557
-0x3da70744
-// 0.050548
-0x3d4f0bad
-// 0.054135
-0x3d5dbd04
-// 0.064251
-0x3d83962e
-// 0.049079
-0x3d490732
-// 0.080179
-0x3da434aa
-// 0.017069
-0x3c8bd443
-// 0.032430
-0x3d04d4ee
-// 0.040662
-0x3d268cd9
-// 0.003388
-0x3b5e07db
-// 0.047310
-0x3d41c7dd
-// 0.027722
-0x3ce31980
-// 0.074089
-0x3d97bc1f
-// 0.054994
-0x3d614168
-// 0.096348
-0x3dc55252
-// 0.064836
-0x3d84c8fd
-// 0.015399
-0x3c7c4d7b
-// 0.072098
-0x3d93a81f
-// 0.058293
-0x3d6ec516
-// 0.037538
-0x3d19c0fb
-// 0.059715
-0x3d749806
-// 0.063750
-0x3d828f81
-// 0.018897
-0x3c9ace2b
-// 0.067245
-0x3d89b7d6
-// 0.052338
-0x3d566066
-// 0.095878
-0x3dc45b6d
-// 0.055513
-0x3d63620e
-// 0.063981
-0x3d8308b2
-// 0.045226
-0x3d393ea6
-// 0.073588
-0x3d96b511
-// 0.037877
-0x3d1b2473
-// 0.082377
-0x3da8b57c
-// 0.087027
-0x3db23b4a
-// 0.008888
-0x3c119e14
-// 0.086347
-0x3db0d6c6
-// 0.064021
-0x3d831d65
-// 0.067012
-0x3d893d95
-// 0.019129
-0x3c9cb3f2
-// 0.033592
-0x3d0997b0
-// 0.018059
-0x3c93ef83
-// 0.028626
-0x3cea8107
-// 0.075945
-0x3d9b8944
-// 0.076121
-0x3d9be56e
-// 0.000857
-0x3a60a1c1
-// 0.069906
-0x3d8f2aad
-// 0.005909
-0x3bc19c70
-// 0.092776
-0x3dbe016e
-// 0.040213
-0x3d24b6c8
-// 0.021631
-0x3cb13284
-// 0.093571
-0x3dbfa23a
-// 0.023001
-0x3cbc6d0b
-// 0.074200
-0x3d97f63e
-// 0.061399
-0x3d7b7df3
-// 0.055935
-0x3d651c2f
-// 0.044264
-0x3d354ddd
-// 0.030839
-0x3cfca237
-// 0.010192
-0x3c26fd09
-// 0.094557
-0x3dc1a758
-// 0.054240
-0x3d5e2b02
-// 0.035270
-0x3d1077af
-// 0.080850
-0x3da594ad
-// 0.044644
-0x3d36dc90
-// 0.027236
-0x3cdf1cff
-// 0.044468
-0x3d3623b0
-// 0.001583
-0x3acf71c8
-// 0.069130
-0x3d8d9421
+300
+// 0.180773
+0x3e391ca7
+// 0.003317
+0x3b595fd7
+// 0.335957
+0x3eac029b
+// 0.115844
+0x3ded3f99
+// 0.111880
+0x3de52180
+// 0.171240
+0x3e2f59a4
+// 0.153297
+0x3e1cf9d7
+// 0.009362
+0x3c196137
+// 0.049881
+0x3d4c502c
+// 0.000216
+0x3962d43a
+// 0.019048
+0x3c9c09af
+// 0.065724
+0x3d869a5c
+// 0.507955
+0x3f020956
+// 0.043368
+0x3d31a26b
+// 0.183172
+0x3e3b916d
+// 0.004976
+0x3ba30af9
+// 0.203713
+0x3e509a27
+// 0.507682
+0x3f01f76c
+// 0.145941
+0x3e157173
+// 0.118502
+0x3df2b115
+// 0.371302
+0x3ebe1b3c
+// 0.449494
+0x3ee62419
+// 0.192967
+0x3e45992f
+// 0.158456
+0x3e224267
+// 0.014354
+0x3c6b2e0e
+// 0.332674
+0x3eaa5445
+// 0.286223
+0x3e928bc6
+// 0.052531
+0x3d572b13
+// 0.187712
+0x3e403799
+// 0.327488
+0x3ea7ac91
+// 0.089872
+0x3db80ee1
+// 0.453624
+0x3ee8415d
+// 0.121327
+0x3df87a0e
+// 0.210226
+0x3e574578
+// 0.146224
+0x3e15bbcc
+// 0.227184
+0x3e68a2d4
+// 0.241443
+0x3e773cef
+// 0.557693
+0x3f0ec4f2
+// 0.078583
+0x3da0f05b
+// 0.081011
+0x3da5e949
+// 0.068668
+0x3d8ca1b0
+// 0.254428
+0x3e824472
+// 0.369904
+0x3ebd641d
+// 0.604297
+0x3f1ab33c
+// 0.201012
+0x3e4dd61f
+// 0.059607
+0x3d742655
+// 0.205533
+0x3e52775a
+// 0.076935
+0x3d9d9044
+// 0.324877
+0x3ea6564e
+// 0.134254
+0x3e0979d4
+// 0.167822
+0x3e2bd987
+// 0.039266
+0x3d20d5df
+// 0.172008
+0x3e3022f3
+// 0.159767
+0x3e2399e0
+// 0.180300
+0x3e38a08e
+// 0.205159
+0x3e52152f
+// 0.056502
+0x3d676ed5
+// 0.278222
+0x3e8e7324
+// 1.000000
+0x3f800000
+// 0.225469
+0x3e66e142
+// 0.101749
+0x3dd061f6
+// 0.077426
+0x3d9e91ae
+// 0.176034
+0x3e344234
+// 0.304814
+0x3e9c1090
+// 0.031973
+0x3d02f670
+// 0.286401
+0x3e92a331
+// 0.116988
+0x3def9754
+// 0.148372
+0x3e17eec3
+// 0.083924
+0x3dabe056
+// 0.279081
+0x3e8ee3a7
+// 0.027854
+0x3ce42d3a
+// 0.076946
+0x3d9d9610
+// 0.268039
+0x3e893c58
+// 0.246966
+0x3e7ce48f
+// 0.124787
+0x3dff906a
+// 0.019722
+0x3ca19001
+// 0.021471
+0x3cafe3b7
+// 0.261079
+0x3e85ac2b
+// 0.038057
+0x3d1be154
+// 0.282582
+0x3e90aea5
+// 0.772133
+0x3f45aa88
+// 0.288227
+0x3e93927a
+// 0.306850
+0x3e9d1b7d
+// 0.140975
+0x3e105bac
+// 0.061042
+0x3d7a0751
+// 0.496855
+0x3efe63c4
+// 0.185225
+0x3e3dabb9
+// 0.040895
+0x3d2781c8
+// 0.005741
+0x3bbc1e2a
+// 0.315298
+0x3ea16eb9
+// 0.375930
+0x3ec079f6
+// 0.281762
+0x3e904320
+// 0.374771
+0x3ebfe208
+// 0.225793
+0x3e673640
+// 0.029681
+0x3cf325f7
+// 0.217679
+0x3e5ee72b
+// 0.053910
+0x3d5cd139
+// 0.219700
+0x3e60f917
+// 0.358543
+0x3eb792e4
+// 0.612633
+0x3f1cd584
+// 0.052378
+0x3d5689d0
+// 0.593074
+0x3f17d3b2
+// 0.095387
+0x3dc35a7e
+// 0.277320
+0x3e8dfcee
+// 0.254922
+0x3e828528
+// 0.075413
+0x3d9a7208
+// 0.077348
+0x3d9e6888
+// 0.171646
+0x3e2fc3ef
+// 0.353420
+0x3eb4f36c
+// 0.756086
+0x3f418ee2
+// 0.192348
+0x3e44f6e3
+// 0.558221
+0x3f0ee78b
+// 0.349722
+0x3eb30eba
+// 0.117714
+0x3df113f6
+// 0.176873
+0x3e351e39
+// 0.024051
+0x3cc505ef
+// 0.268485
+0x3e8976d0
+// 0.143505
+0x3e12f2e1
+// 0.147395
+0x3e16eeb4
+// 0.064866
+0x3d84d87b
+// 0.587286
+0x3f16585e
+// 0.347998
+0x3eb22ccd
+// 0.089509
+0x3db75049
+// 0.217681
+0x3e5ee7c0
+// 0.118649
+0x3df2fe2b
+// 0.152026
+0x3e1baca4
+// 0.131582
+0x3e06bd84
+// 0.266943
+0x3e88acc5
+// 0.318698
+0x3ea32c66
+// 0.082573
+0x3da91c0b
+// 0.150573
+0x3e1a2fd5
+// 0.030381
+0x3cf8e1b9
+// 0.128629
+0x3e03b746
+// 0.043407
+0x3d31cb83
+// 0.490343
+0x3efb0e3d
+// 0.029675
+0x3cf3198f
+// 0.259883
+0x3e850f63
+// 0.201872
+0x3e4eb784
+// 0.004435
+0x3b9154e8
+// 0.406644
+0x3ed033a2
+// 0.023980
+0x3cc471b5
+// 0.703822
+0x3f342db1
+// 0.237431
+0x3e732118
+// 0.195532
+0x3e4839a7
+// 0.420122
+0x3ed71a3a
+// 0.176519
+0x3e34c178
+// 0.389200
+0x3ec7452b
+// 0.286695
+0x3e92c9a9
+// 0.113949
+0x3de95dfe
+// 0.063220
+0x3d81794a
+// 0.135655
+0x3e0ae92c
+// 0.234746
+0x3e70614c
+// 0.123373
+0x3dfcaafe
+// 0.236578
+0x3e724185
+// 0.112751
+0x3de6ea3f
+// 0.430976
+0x3edca8f0
+// 0.173051
+0x3e313435
+// 0.539233
+0x3f0a0b2c
+// 0.106952
+0x3ddb09b7
+// 0.248923
+0x3e7ee58c
+// 0.160052
+0x3e23e4b0
+// 0.405250
+0x3ecf7ce6
+// 0.038490
+0x3d1da749
+// 0.754819
+0x3f413bd4
+// 0.335065
+0x3eab8d9f
+// 0.010497
+0x3c2bf9c6
+// 0.153476
+0x3e1d28e3
+// 0.301231
+0x3e9a3aee
+// 0.133129
+0x3e085310
+// 0.206379
+0x3e535507
+// 0.291856
+0x3e956e32
+// 0.514779
+0x3f03c888
+// 0.204405
+0x3e514f7d
+// 0.680482
+0x3f2e340f
+// 0.298003
+0x3e9893d5
+// 0.000249
+0x3982bdc1
+// 0.155243
+0x3e1ef81b
+// 0.077929
+0x3d9f9907
+// 0.185250
+0x3e3db22f
+// 0.098374
+0x3dc9788d
+// 0.244998
+0x3e7ae0d9
+// 0.123930
+0x3dfdcee6
+// 0.294405
+0x3e96bc44
+// 0.098375
+0x3dc978fe
+// 0.307972
+0x3e9dae81
+// 0.002831
+0x3b399045
+// 0.096067
+0x3dc4bf04
+// 0.274925
+0x3e8cc301
+// 0.187400
+0x3e3fe5e7
+// 0.080963
+0x3da5cfd2
+// 0.327412
+0x3ea7a281
+// 0.013138
+0x3c574235
+// 0.311934
+0x3e9fb5d6
+// 0.256389
+0x3e834566
+// 0.191764
+0x3e445dd7
+// 0.287594
+0x3e933f7e
+// 0.251833
+0x3e80f034
+// 0.391665
+0x3ec88856
+// 0.315983
+0x3ea1c891
+// 0.095807
+0x3dc43661
+// 0.211389
+0x3e58763e
+// 0.258683
+0x3e84721c
+// 0.384232
+0x3ec4ba12
+// 0.576996
+0x3f13b602
+// 0.055314
+0x3d629156
+// 0.238307
+0x3e7406bb
+// 0.126599
+0x3e01a34b
+// 0.025223
+0x3ccea0b4
+// 0.124107
+0x3dfe2bbb
+// 0.121501
+0x3df8d591
+// 0.196324
+0x3e49091c
+// 0.422662
+0x3ed8672a
+// 0.089543
+0x3db76277
+// 0.278451
+0x3e8e9127
+// 0.059750
+0x3d74bc8c
+// 0.373473
+0x3ebf37cc
+// 0.149498
+0x3e1915fb
+// 0.169801
+0x3e2de053
+// 0.397130
+0x3ecb5497
+// 0.265939
+0x3e882919
+// 0.063404
+0x3d81da36
+// 0.219959
+0x3e613ce2
+// 0.038141
+0x3d1c3961
+// 0.169264
+0x3e2d5396
+// 0.167103
+0x3e2b1cf0
+// 0.463228
+0x3eed2c3f
+// 0.303581
+0x3e9b6ef1
+// 0.060459
+0x3d77a3a2
+// 0.273986
+0x3e8c47f3
+// 0.213953
+0x3e5b1680
+// 0.388064
+0x3ec6b04d
+// 0.711034
+0x3f360651
+// 0.399716
+0x3ecca7a0
+// 0.191071
+0x3e43a826
+// 0.176286
+0x3e348453
+// 0.000611
+0x3a204510
+// 0.205100
+0x3e5205d1
+// 0.247204
+0x3e7d2328
+// 0.020089
+0x3ca49261
+// 0.149378
+0x3e18f686
+// 0.128530
+0x3e039d7c
+// 0.036474
+0x3d156631
+// 0.227535
+0x3e68fee9
+// 0.176040
+0x3e3443d6
+// 0.176439
+0x3e34ac65
+// 0.479290
+0x3ef56580
+// 0.292146
+0x3e95941b
+// 0.004249
+0x3b8b3969
+// 0.912307
+0x3f698cf1
+// 0.591720
+0x3f177aef
+// 0.072924
+0x3d955966
+// 0.113417
+0x3de84736
+// 0.172742
+0x3e30e331
+// 0.050781
+0x3d4fff66
+// 0.084815
+0x3dadb382
+// 0.474700
+0x3ef30bef
+// 0.156257
+0x3e2001da
+// 0.419153
+0x3ed69b44
+// 0.461078
+0x3eec1273
+// 0.038056
+0x3d1be037
+// 0.118122
+0x3df1e9dd
+// 0.148492
+0x3e180e37
+// 0.034291
+0x3d0c746b
+// 0.181770
+0x3e3a21e9
+// 0.308913
+0x3e9e29e2
+// 0.333125
+0x3eaa8f5b
+// 0.174511
+0x3e32b315
+// 0.233817
+0x3e6f6dc3
+// 0.355195
+0x3eb5dc2f
+// 0.380402
+0x3ec2c401
+// 0.230453
+0x3e6bfbd8
+// 0.570527
+0x3f120e10
+// 0.280631
+0x3e8faed9
+// 0.173200
+0x3e315b47
+// 0.096317
+0x3dc54199
+// 0.360819
+0x3eb8bd45
+// 0.040504
+0x3d25e7e9
+// 0.732779
+0x3f3b976a
+// 0.109666
+0x3de09865
+// 0.141874
+0x3e11475a
+// 0.012802
+0x3c51be14
+// 0.233586
+0x3e6f313f
+// 0.657900
+0x3f286c23
+// 0.136135
+0x3e0b6715
+// 0.406237
+0x3ecffe42
+// 0.687533
+0x3f30022d
+// 0.049256
+0x3d49c0fa
+// 0.171818
+0x3e2ff126
+// 0.155693
+0x3e1f6de9
+// 0.447904
+0x3ee553b0
+// 0.728481
+0x3f3a7dbe
+// 0.308104
+0x3e9dbfc1
+// 0.180673
+0x3e39026c
+// 0.131354
+0x3e068192
+// 0.289558
+0x3e9440f0
+// 0.366182
+0x3ebb7c3e
+// 0.041183
+0x3d28aeff
+// 0.263939
+0x3e872310
+// 0.179231
+0x3e37886c
+// 0.009728
+0x3c1f6314

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA24_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA24_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA24_f32.txt
new file mode 100644
index 0000000..76b4bbb
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA24_f32.txt
@@ -0,0 +1,242 @@
+W
+120
+// 0.067755
+0x3d8ac308
+// 0.135949
+0x3e0b361d
+// 0.113401
+0x3de83ea9
+// 0.018184
+0x3c94f669
+// 0.089178
+0x3db6a2e0
+// 0.086584
+0x3db152fd
+// 0.087844
+0x3db3e77b
+// 0.127061
+0x3e021c40
+// 0.011418
+0x3c3b1326
+// 0.079023
+0x3da1d69f
+// 0.123590
+0x3dfd1cf0
+// 0.060014
+0x3d75d15e
+// 0.045491
+0x3d3a5482
+// 0.001012
+0x3a84a992
+// 0.024548
+0x3cc918da
+// 0.161555
+0x3e256ecb
+// 0.017660
+0x3c90aadf
+// 0.039315
+0x3d21092e
+// 0.169257
+0x3e2d51d0
+// 0.087235
+0x3db2a87f
+// 0.100356
+0x3dcd8784
+// 0.151056
+0x3e1aae74
+// 0.044336
+0x3d359a01
+// 0.158177
+0x3e21f939
+// 0.125859
+0x3e00e13e
+// 0.121134
+0x3df81525
+// 0.025459
+0x3cd08e79
+// 0.114077
+0x3de9a123
+// 0.160441
+0x3e244a86
+// 0.188714
+0x3e413e3a
+// 0.038816
+0x3d1efd01
+// 0.050261
+0x3d4dde69
+// 0.148611
+0x3e182d95
+// 0.001119
+0x3a92a2d7
+// 0.019105
+0x3c9c824b
+// 0.006405
+0x3bd1e21a
+// 0.030792
+0x3cfc3ec4
+// 0.138094
+0x3e0d6871
+// 0.124281
+0x3dfe86ee
+// 0.106018
+0x3dd9200e
+// 0.159866
+0x3e23b3ca
+// 0.064351
+0x3d83ca8c
+// 0.152618
+0x3e1c47e6
+// 0.006819
+0x3bdf74f3
+// 0.006134
+0x3bc8fc01
+// 0.031476
+0x3d00ec7f
+// 0.036964
+0x3d176727
+// 0.142589
+0x3e1202d2
+// 0.086170
+0x3db079ab
+// 0.122263
+0x3dfa6512
+// 0.156807
+0x3e209215
+// 0.070790
+0x3d90fa6d
+// 0.150255
+0x3e19dc67
+// 0.049428
+0x3d4a757b
+// 0.140168
+0x3e0f8850
+// 0.002022
+0x3b0485b6
+// 0.085075
+0x3dae3bbf
+// 0.003711
+0x3b733b2e
+// 0.092910
+0x3dbe47d6
+// 0.040399
+0x3d2579c8
+// 0.062985
+0x3d80fe7a
+// 0.125790
+0x3e00cf0f
+// 0.035854
+0x3d12db48
+// 0.009574
+0x3c1cdbb6
+// 0.062762
+0x3d808969
+// 0.149699
+0x3e194acd
+// 0.130544
+0x3e05ad49
+// 0.137335
+0x3e0ca18c
+// 0.006436
+0x3bd2e83b
+// 0.149096
+0x3e18ac9b
+// 0.021975
+0x3cb404d1
+// 0.107950
+0x3ddd14b1
+// 0.040865
+0x3d276228
+// 0.091019
+0x3dba6803
+// 0.125070
+0x3e001248
+// 0.155726
+0x3e1f768a
+// 0.134478
+0x3e09b4b5
+// 0.036464
+0x3d155b4e
+// 0.114637
+0x3deac6dc
+// 0.100370
+0x3dcd8ed8
+// 0.043597
+0x3d329330
+// 0.037144
+0x3d182485
+// 0.013902
+0x3c63c5e1
+// 0.106727
+0x3dda93e7
+// 0.122110
+0x3dfa14e2
+// 0.117174
+0x3deff91d
+// 0.099236
+0x3dcb3c49
+// 0.133601
+0x3e08cea5
+// 0.007709
+0x3bfc9c8f
+// 0.107071
+0x3ddb482a
+// 0.138326
+0x3e0da54f
+// 0.110482
+0x3de24446
+// 0.007385
+0x3bf2006c
+// 0.120611
+0x3df702fd
+// 0.020854
+0x3caad6b5
+// 0.015440
+0x3c7cf728
+// 0.122600
+0x3dfb159e
+// 0.061793
+0x3d7d1a64
+// 0.103456
+0x3dd3e0d0
+// 0.115847
+0x3ded4161
+// 0.101047
+0x3dcef1cf
+// 0.119657
+0x3df50ef4
+// 0.077257
+0x3d9e38d7
+// 0.082706
+0x3da961bd
+// 0.016095
+0x3c83d9d1
+// 0.019613
+0x3ca0ac60
+// 0.107918
+0x3ddd03e9
+// 0.072010
+0x3d937a32
+// 0.009560
+0x3c1ca182
+// 0.107563
+0x3ddc4a07
+// 0.013405
+0x3c5ba24d
+// 0.012736
+0x3c50a9d6
+// 0.137713
+0x3e0d0485
+// 0.059520
+0x3d73cb08
+// 0.146214
+0x3e15b91a
+// 0.120207
+0x3df62f23
+// 0.039413
+0x3d216ff4
+// 0.089910
+0x3db822b4
+// 0.153754
+0x3e1d71b9
+// 0.110005
+0x3de14a40

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA25_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA25_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA25_f32.txt
new file mode 100644
index 0000000..4295664
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA25_f32.txt
@@ -0,0 +1,282 @@
+W
+140
+// -2.238115
+0xc00f3d47
+// -2.229094
+0xc00ea97b
+// -2.547336
+0xc023078d
+// -5.132111
+0xc0a43a40
+// -2.674479
+0xc02b2aac
+// -2.203295
+0xc00d02ca
+// -3.448261
+0xc05cb051
+// -2.244292
+0xc00fa27d
+// -6.228171
+0xc0c74d2d
+// -2.119763
+0xc007aa32
+// -3.621111
+0xc067c04a
+// -2.246031
+0xc00fbefa
+// -3.113077
+0xc0473ca9
+// -2.320060
+0xc0147bdd
+// -3.149003
+0xc0498945
+// -3.636399
+0xc068bac4
+// -1.803440
+0xbfe6d71d
+// -4.125488
+0xc0840400
+// -3.382160
+0xc0587550
+// -3.898703
+0xc079845b
+// -1.856912
+0xbfedaf4b
+// -2.946107
+0xc03c8d03
+// -2.253739
+0xc0103d44
+// -2.491516
+0xc01f74fe
+// -2.490087
+0xc01f5d96
+// -1.941402
+0xbff87fda
+// -3.180954
+0xc04b94be
+// -3.119270
+0xc047a21f
+// -2.278553
+0xc011d3cf
+// -2.078686
+0xc0050932
+// -2.906661
+0xc03a06bc
+// -2.625431
+0xc0280712
+// -3.695847
+0xc06c88c3
+// -2.075740
+0xc004d8ec
+// -2.214836
+0xc00dbfde
+// -4.221673
+0xc08717f1
+// -5.010718
+0xc0a057cd
+// -2.100006
+0xc0066681
+// -2.607248
+0xc026dd28
+// -3.580075
+0xc0651ff1
+// -3.003638
+0xc0403b9b
+// -2.264014
+0xc010e59c
+// -2.544991
+0xc022e124
+// -2.093239
+0xc005f7a0
+// -2.944219
+0xc03c6e16
+// -2.668316
+0xc02ac5b2
+// -2.756677
+0xc0306d66
+// -3.166746
+0xc04aabf9
+// -3.330903
+0xc0552d86
+// -2.906611
+0xc03a05e9
+// -2.940764
+0xc03c357a
+// -2.783593
+0xc0322663
+// -2.427363
+0xc01b59e9
+// -2.854278
+0xc036ac7d
+// -2.086780
+0xc0058dcc
+// -2.220374
+0xc00e1a9c
+// -2.211720
+0xc00d8cd1
+// -2.210696
+0xc00d7c0a
+// -2.646913
+0xc0296704
+// -2.507603
+0xc0207c91
+// -2.195600
+0xc00c84b4
+// -3.603104
+0xc0669942
+// -2.601074
+0xc02677fe
+// -3.534837
+0xc0623ac4
+// -2.565296
+0xc0242dce
+// -2.326374
+0xc014e34e
+// -2.613352
+0xc027412b
+// -2.761525
+0xc030bcd2
+// -2.503728
+0xc0203d14
+// -4.985947
+0xc09f8ce0
+// -2.371070
+0xc017bf9d
+// -4.064290
+0xc0820eaa
+// -3.324535
+0xc054c530
+// -3.019901
+0xc041460d
+// -2.068763
+0xc004669e
+// -2.660753
+0xc02a49c6
+// -2.025671
+0xc001a496
+// -2.573481
+0xc024b3e9
+// -2.668187
+0xc02ac393
+// -3.196208
+0xc04c8eae
+// -2.128358
+0xc0083703
+// -2.685143
+0xc02bd961
+// -2.500640
+0xc0200a7b
+// -3.391305
+0xc0590b22
+// -2.579235
+0xc0251231
+// -2.724034
+0xc02e5695
+// -3.450499
+0xc05cd4fc
+// -5.279590
+0xc0a8f267
+// -2.559292
+0xc023cb72
+// -1.774237
+0xbfe31a32
+// -4.244747
+0xc087d4f7
+// -3.082385
+0xc04545cc
+// -4.080938
+0xc082970c
+// -2.260665
+0xc010aebb
+// -2.008981
+0xc0009324
+// -2.227754
+0xc00e9386
+// -2.272121
+0xc0116a6e
+// -2.790163
+0xc0329206
+// -2.293675
+0xc012cb93
+// -1.870775
+0xbfef7592
+// -3.944046
+0xc07c6b3f
+// -2.891772
+0xc03912ca
+// -2.432966
+0xc01bb5b6
+// -3.118619
+0xc0479776
+// -2.537258
+0xc0226271
+// -4.489384
+0xc08fa909
+// -2.714375
+0xc02db853
+// -1.932073
+0xbff74e2d
+// -4.653504
+0xc094e980
+// -5.468243
+0xc0aefbd9
+// -1.894479
+0xbff27e4c
+// -2.456772
+0xc01d3bbf
+// -3.487214
+0xc05f2e85
+// -2.413477
+0xc01a7668
+// -2.410242
+0xc01a4166
+// -2.254236
+0xc0104568
+// -2.383320
+0xc0188851
+// -2.903471
+0xc039d279
+// -3.101790
+0xc04683bb
+// -2.125726
+0xc0080be4
+// -2.532385
+0xc0221298
+// -3.809582
+0xc073d030
+// -2.187687
+0xc00c0310
+// -4.354469
+0xc08b57ce
+// -2.541144
+0xc022a21b
+// -2.509071
+0xc020949e
+// -2.032456
+0xc00213c4
+// -2.803229
+0xc0336819
+// -3.297247
+0xc0530619
+// -2.250895
+0xc0100ea9
+// -1.951796
+0xbff9d472
+// -3.373325
+0xc057e48d
+// -2.815610
+0xc03432f3
+// -2.137461
+0xc008cc29
+// -3.240385
+0xc04f6277
+// -2.866285
+0xc0377137
+// -2.752172
+0xc0302397
+// -2.847317
+0xc0363a71
+// -2.296292
+0xc012f673
+// -5.037886
+0xc0a1365d

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA3_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA3_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA3_f32.txt
deleted file mode 100755
index ede00b8..0000000
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA3_f32.txt
+++ /dev/null
@@ -1,242 +0,0 @@
-W
-120
-// 0.006047
-0x3bc628bc
-// 0.126348
-0x3e01615a
-// 0.132721
-0x3e07e81b
-// 0.079188
-0x3da22d7c
-// 0.052569
-0x3d575298
-// 0.053801
-0x3d5c5df9
-// 0.111303
-0x3de3f2bd
-// 0.036834
-0x3d16df24
-// 0.145668
-0x3e152a00
-// 0.031233
-0x3cffdce9
-// 0.131107
-0x3e0640c9
-// 0.093181
-0x3dbed5ab
-// 0.091800
-0x3dbc019a
-// 0.167721
-0x3e2bbf04
-// 0.085843
-0x3dafce3b
-// 0.058460
-0x3d6f73af
-// 0.144506
-0x3e13f96c
-// 0.029775
-0x3cf3eaaf
-// 0.020261
-0x3ca5f9d1
-// 0.001844
-0x3af1a775
-// 0.073163
-0x3d95d66e
-// 0.179610
-0x3e37eba3
-// 0.007988
-0x3c02dfb6
-// 0.139031
-0x3e0e5e06
-// 0.106405
-0x3dd9eaa2
-// 0.000267
-0x398bd62b
-// 0.098791
-0x3dca52bc
-// 0.118489
-0x3df2aa84
-// 0.022028
-0x3cb473f4
-// 0.060337
-0x3d77241c
-// 0.056541
-0x3d6797b3
-// 0.036456
-0x3d1552fb
-// 0.147647
-0x3e1730cc
-// 0.156344
-0x3e2018b2
-// 0.123088
-0x3dfc155e
-// 0.073608
-0x3d96bf8c
-// 0.012738
-0x3c50b3c7
-// 0.127402
-0x3e0275c6
-// 0.019504
-0x3c9fc654
-// 0.202326
-0x3e4f2e8f
-// 0.024988
-0x3cccb3af
-// 0.183719
-0x3e3c20b9
-// 0.179076
-0x3e375f97
-// 0.138144
-0x3e0d75a8
-// 0.010974
-0x3c33caea
-// 0.084679
-0x3dad6bf1
-// 0.007287
-0x3beec8c1
-// 0.009164
-0x3c162495
-// 0.019588
-0x3ca076e6
-// 0.071888
-0x3d9339f6
-// 0.103017
-0x3dd2fa67
-// 0.052992
-0x3d590e5d
-// 0.062562
-0x3d8020be
-// 0.032107
-0x3d0382bb
-// 0.122831
-0x3dfb8eb7
-// 0.123690
-0x3dfd511f
-// 0.146890
-0x3e166a73
-// 0.003692
-0x3b71f9b4
-// 0.034373
-0x3d0ccae1
-// 0.226369
-0x3e67cd53
-// 0.055306
-0x3d62882b
-// 0.111249
-0x3de3d67e
-// 0.114484
-0x3dea7688
-// 0.043314
-0x3d3169ad
-// 0.081992
-0x3da7eb7f
-// 0.028787
-0x3cebd2b2
-// 0.137284
-0x3e0c941c
-// 0.101281
-0x3dcf6c63
-// 0.153498
-0x3e1d2e77
-// 0.006570
-0x3bd74669
-// 0.063099
-0x3d8139dc
-// 0.103138
-0x3dd33a17
-// 0.070770
-0x3d90f00b
-// 0.138918
-0x3e0e4075
-// 0.026604
-0x3cd9efa8
-// 0.073999
-0x3d978ce7
-// 0.044662
-0x3d36ef23
-// 0.010329
-0x3c293b9d
-// 0.154825
-0x3e1e8a61
-// 0.108104
-0x3ddd65be
-// 0.172945
-0x3e31189b
-// 0.131701
-0x3e06dc8f
-// 0.018779
-0x3c99d6c5
-// 0.048364
-0x3d461960
-// 0.004625
-0x3b9790d5
-// 0.017069
-0x3c8bd34c
-// 0.052701
-0x3d57dd21
-// 0.174354
-0x3e3289cd
-// 0.012914
-0x3c539477
-// 0.067136
-0x3d897ec8
-// 0.106958
-0x3ddb0cf0
-// 0.111712
-0x3de4c94f
-// 0.107299
-0x3ddbbf6a
-// 0.108561
-0x3dde5535
-// 0.125588
-0x3e009a1d
-// 0.111083
-0x3de37f86
-// 0.119331
-0x3df46406
-// 0.032154
-0x3d03b40b
-// 0.122062
-0x3df9fbcb
-// 0.136589
-0x3e0bddeb
-// 0.034387
-0x3d0cd9a8
-// 0.021967
-0x3cb3f40a
-// 0.131967
-0x3e07227a
-// 0.082378
-0x3da8b5ab
-// 0.125468
-0x3e007a9e
-// 0.013779
-0x3c61c0f3
-// 0.086054
-0x3db03d01
-// 0.093864
-0x3dc03b84
-// 0.155477
-0x3e1f355a
-// 0.131485
-0x3e06a3e2
-// 0.102287
-0x3dd17ba6
-// 0.061280
-0x3d7b0122
-// 0.104429
-0x3dd5dea7
-// 0.014807
-0x3c729aae
-// 0.022420
-0x3cb7aacd
-// 0.093206
-0x3dbee2b8
-// 0.037411
-0x3d193bf3
-// 0.138661
-0x3e0dfd3a
-// 0.109075
-0x3ddf6291
-// 0.029463
-0x3cf15baf

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA4_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA4_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA4_f32.txt
deleted file mode 100755
index 418ddd5..0000000
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputA4_f32.txt
+++ /dev/null
@@ -1,282 +0,0 @@
-W
-140
-// -2.937437
-0xc03bfef9
-// -2.319812
-0xc01477cb
-// -2.122321
-0xc007d41b
-// -2.132953
-0xc008824d
-// -3.902897
-0xc079c912
-// -2.485666
-0xc01f1525
-// -4.837458
-0xc09acc75
-// -2.200258
-0xc00cd109
-// -2.456678
-0xc01d3a37
-// -3.386361
-0xc058ba22
-// -2.968888
-0xc03e0244
-// -4.159550
-0xc0851b08
-// -2.225123
-0xc00e686c
-// -2.237442
-0xc00f323e
-// -3.657517
-0xc06a14c3
-// -2.159819
-0xc00a3a79
-// -2.212901
-0xc00da02b
-// -4.361059
-0xc08b8dcb
-// -2.275099
-0xc0119b3b
-// -2.597107
-0xc02636ff
-// -2.722921
-0xc02e4457
-// -2.461961
-0xc01d90c4
-// -3.440021
-0xc05c294c
-// -2.342257
-0xc015e78a
-// -3.155328
-0xc049f0e6
-// -2.345418
-0xc0161b54
-// -2.688389
-0xc02c0e8f
-// -2.443140
-0xc01c5c67
-// -2.237181
-0xc00f2df7
-// -3.140883
-0xc049043a
-// -2.614217
-0xc0274f56
-// -2.262157
-0xc010c72d
-// -2.193239
-0xc00c5e06
-// -2.168818
-0xc00acdea
-// -2.639748
-0xc028f1a2
-// -2.848019
-0xc03645f0
-// -2.765049
-0xc030f68f
-// -2.451468
-0xc01ce4d8
-// -2.340835
-0xc015d03d
-// -4.669080
-0xc095691a
-// -2.642343
-0xc0291c25
-// -5.408748
-0xc0ad1477
-// -2.177459
-0xc00b5b7d
-// -4.037190
-0xc08130a9
-// -2.304983
-0xc01384d8
-// -2.407948
-0xc01a1bd2
-// -2.709700
-0xc02d6bb8
-// -2.814918
-0xc03427a0
-// -2.310880
-0xc013e577
-// -3.337622
-0xc0559b99
-// -2.731337
-0xc02ece38
-// -3.139665
-0xc048f046
-// -3.555456
-0xc0638c96
-// -2.414098
-0xc01a8094
-// -2.219262
-0xc00e0863
-// -2.343753
-0xc016000b
-// -3.213300
-0xc04da6b4
-// -1.912427
-0xbff4ca68
-// -3.482994
-0xc05ee960
-// -2.939992
-0xc03c28d3
-// -1.809478
-0xbfe79cfb
-// -3.655081
-0xc069ecda
-// -4.050159
-0xc0819ae7
-// -1.694885
-0xbfd8f1fe
-// -3.928383
-0xc07b6aa0
-// -2.764698
-0xc030f0d0
-// -1.816547
-0xbfe8849b
-// -3.480855
-0xc05ec655
-// -2.743057
-0xc02f8e3e
-// -4.563702
-0xc09209d9
-// -2.808479
-0xc033be20
-// -2.783835
-0xc0322a5a
-// -2.732837
-0xc02ee6cc
-// -2.400041
-0xc0199a44
-// -4.563638
-0xc0920953
-// -1.775404
-0xbfe34074
-// -2.062098
-0xc003f96b
-// -2.370733
-0xc017ba17
-// -3.405902
-0xc059fa4d
-// -2.032680
-0xc002176d
-// -3.162956
-0xc04a6de0
-// -3.425999
-0xc05b4393
-// -2.642872
-0xc02924cf
-// -3.705794
-0xc06d2bbb
-// -5.242547
-0xc0a7c2f3
-// -2.154788
-0xc009e80c
-// -2.468035
-0xc01df44a
-// -2.349867
-0xc0166437
-// -2.247067
-0xc00fcff1
-// -2.493350
-0xc01f930b
-// -2.635539
-0xc028acac
-// -3.137631
-0xc048cef1
-// -3.559765
-0xc063d32f
-// -2.133347
-0xc00888c2
-// -2.899370
-0xc0398f45
-// -2.939320
-0xc03c1dd4
-// -2.655540
-0xc029f45d
-// -2.487244
-0xc01f2f00
-// -2.315065
-0xc0142a08
-// -2.705430
-0xc02d25c5
-// -2.427825
-0xc01b617d
-// -2.094550
-0xc0060d1b
-// -2.815774
-0xc03435a5
-// -2.682923
-0xc02bb501
-// -2.298131
-0xc0131492
-// -4.220838
-0xc087111a
-// -3.138187
-0xc048d80e
-// -3.368468
-0xc05794fa
-// -3.296028
-0xc052f21f
-// -2.145281
-0xc0094c48
-// -1.969823
-0xbffc2328
-// -3.847174
-0xc0763818
-// -2.517131
-0xc02118ab
-// -2.840606
-0xc035cc7f
-// -3.264118
-0xc050e750
-// -4.499197
-0xc08ff96b
-// -2.433933
-0xc01bc58e
-// -2.641747
-0xc0291264
-// -2.178451
-0xc00b6bbd
-// -4.503685
-0xc0901e30
-// -2.408603
-0xc01a268f
-// -2.355837
-0xc016c607
-// -4.063132
-0xc082052c
-// -2.087104
-0xc005931f
-// -1.950742
-0xbff9b1e8
-// -2.614655
-0xc0275681
-// -2.652767
-0xc029c6ed
-// -2.603648
-0xc026a22c
-// -6.083038
-0xc0c2a83f
-// -3.105599
-0xc046c223
-// -4.137948
-0xc0846a12
-// -2.020449
-0xc0014f07
-// -1.941666
-0xbff88882
-// -2.259635
-0xc0109ddd
-// -3.241031
-0xc04f6d0d
-// -2.669383
-0xc02ad72b
-// -2.728630
-0xc02ea1e0
-// -2.028120
-0xc001ccba
-// -3.992279
-0xc07f817e
-// -2.289771
-0xc0128b9b

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB24_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB24_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB24_f32.txt
new file mode 100644
index 0000000..a0f0f8b
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB24_f32.txt
@@ -0,0 +1,242 @@
+W
+120
+// 0.142657
+0x3e121491
+// 0.065002
+0x3d851fde
+// 0.079635
+0x3da317a7
+// 0.139283
+0x3e0ea03a
+// 0.139540
+0x3e0ee379
+// 0.094070
+0x3dc0a7e0
+// 0.131890
+0x3e070e19
+// 0.053913
+0x3d5cd387
+// 0.011221
+0x3c37d6ab
+// 0.056839
+0x3d68cfa0
+// 0.021506
+0x3cb02c5d
+// 0.064446
+0x3d83fc61
+// 0.019049
+0x3c9c0d21
+// 0.064719
+0x3d848b72
+// 0.128471
+0x3e038dd3
+// 0.070866
+0x3d91226d
+// 0.079089
+0x3da1f981
+// 0.150118
+0x3e19b86c
+// 0.018956
+0x3c9b4a02
+// 0.105247
+0x3dd78be1
+// 0.093707
+0x3dbfe96c
+// 0.047421
+0x3d423caf
+// 0.109434
+0x3de01f30
+// 0.112922
+0x3de74385
+// 0.045232
+0x3d394515
+// 0.151836
+0x3e1b7ada
+// 0.032553
+0x3d0555f5
+// 0.025821
+0x3cd38744
+// 0.150200
+0x3e19cdf9
+// 0.043515
+0x3d323cef
+// 0.119677
+0x3df51953
+// 0.021998
+0x3cb4344e
+// 0.110405
+0x3de21bd8
+// 0.053011
+0x3d5921ef
+// 0.120099
+0x3df5f64a
+// 0.125654
+0x3e00ab86
+// 0.108089
+0x3ddd5dd4
+// 0.199174
+0x3e4bf465
+// 0.067256
+0x3d89bd95
+// 0.008986
+0x3c133a0b
+// 0.062864
+0x3d80bf01
+// 0.147247
+0x3e16c7f8
+// 0.006986
+0x3be4ea7e
+// 0.142485
+0x3e11e787
+// 0.008445
+0x3c0a5c5c
+// 0.068986
+0x3d8d489a
+// 0.126725
+0x3e01c449
+// 0.052756
+0x3d581658
+// 0.066964
+0x3d89248e
+// 0.094683
+0x3dc1e8f2
+// 0.033275
+0x3d084bc3
+// 0.147293
+0x3e16d415
+// 0.031545
+0x3d0135a8
+// 0.052281
+0x3d5624ee
+// 0.036122
+0x3d13f45c
+// 0.141726
+0x3e1120bb
+// 0.076713
+0x3d9d1ba9
+// 0.124198
+0x3dfe5b96
+// 0.068462
+0x3d8c35ff
+// 0.126736
+0x3e01c723
+// 0.034574
+0x3d0d9d1f
+// 0.041682
+0x3d2aba8a
+// 0.146611
+0x3e162112
+// 0.030856
+0x3cfcc50d
+// 0.071788
+0x3d930578
+// 0.078660
+0x3da1184c
+// 0.008077
+0x3c045516
+// 0.113382
+0x3de8349e
+// 0.136563
+0x3e0bd72e
+// 0.114405
+0x3dea4cfa
+// 0.132127
+0x3e074c63
+// 0.091277
+0x3dbaefa3
+// 0.000414
+0x39d92eb8
+// 0.000493
+0x3a0142cb
+// 0.041023
+0x3d2807e5
+// 0.129370
+0x3e047997
+// 0.157250
+0x3e210625
+// 0.075020
+0x3d99a3e6
+// 0.001518
+0x3ac6fa0f
+// 0.188537
+0x3e410fda
+// 0.223246
+0x3e649ab9
+// 0.008648
+0x3c0dae61
+// 0.125781
+0x3e00cca1
+// 0.048700
+0x3d4779bf
+// 0.127871
+0x3e02f0b9
+// 0.103338
+0x3dd3a2b8
+// 0.004049
+0x3b84b0f6
+// 0.165520
+0x3e297e34
+// 0.025228
+0x3cceaa5e
+// 0.091946
+0x3dbc4e1b
+// 0.152150
+0x3e1bcd40
+// 0.123316
+0x3dfc8d30
+// 0.052675
+0x3d57c1cc
+// 0.036182
+0x3d1433dc
+// 0.084339
+0x3dacb9f6
+// 0.033385
+0x3d08be68
+// 0.040715
+0x3d26c4de
+// 0.096404
+0x3dc56f65
+// 0.122097
+0x3dfa0dea
+// 0.029656
+0x3cf2f026
+// 0.013371
+0x3c5b13cd
+// 0.183772
+0x3e3c2ebe
+// 0.016150
+0x3c844dd3
+// 0.176335
+0x3e349148
+// 0.041512
+0x3d2a08c2
+// 0.107859
+0x3ddce52b
+// 0.151439
+0x3e1b12cc
+// 0.020689
+0x3ca97c66
+// 0.060296
+0x3d76f93a
+// 0.091635
+0x3dbbab46
+// 0.033402
+0x3d08d07f
+// 0.128494
+0x3e039410
+// 0.109460
+0x3de02c63
+// 0.023973
+0x3cc46360
+// 0.017721
+0x3c912b93
+// 0.229670
+0x3e6b2e8f
+// 0.045958
+0x3d3c3e54
+// 0.111088
+0x3de38200
+// 0.140697
+0x3e1012c9
+// 0.007606
+0x3bf93c55

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB25_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB25_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB25_f32.txt
new file mode 100644
index 0000000..8d0388c
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB25_f32.txt
@@ -0,0 +1,282 @@
+W
+140
+// -2.589182
+0xc025b52a
+// -2.381646
+0xc0186ce1
+// -2.496305
+0xc01fc378
+// -3.441956
+0xc05c4901
+// -2.161347
+0xc00a5384
+// -2.764519
+0xc030eddf
+// -3.053492
+0xc0436c6b
+// -2.363325
+0xc01740b8
+// -2.118983
+0xc0079d6c
+// -5.378495
+0xc0ac1ca1
+// -2.096745
+0xc0063110
+// -2.450700
+0xc01cd845
+// -5.231028
+0xc0a76495
+// -2.624899
+0xc027fe59
+// -3.865819
+0xc0776994
+// -2.232948
+0xc00ee89d
+// -2.317428
+0xc01450bc
+// -2.321629
+0xc0149591
+// -2.757902
+0xc0308176
+// -2.731499
+0xc02ed0e3
+// -2.708887
+0xc02d5e68
+// -2.208960
+0xc00d5f98
+// -2.815270
+0xc0342d64
+// -2.405863
+0xc019f9ab
+// -2.243387
+0xc00f93a9
+// -5.921443
+0xc0bd7c75
+// -4.041116
+0xc08150d2
+// -2.236834
+0xc00f2849
+// -2.522717
+0xc0217432
+// -2.333636
+0xc0155a49
+// -5.222840
+0xc0a72181
+// -3.265198
+0xc050f8ff
+// -2.513492
+0xc020dd0f
+// -2.517033
+0xc0211711
+// -2.265870
+0xc0110405
+// -2.632946
+0xc0288231
+// -2.489416
+0xc01f5299
+// -2.215480
+0xc00dca6d
+// -3.941548
+0xc07c4254
+// -2.442724
+0xc01c5597
+// -2.308849
+0xc013c42d
+// -2.861762
+0xc037271c
+// -2.433652
+0xc01bc0f6
+// -2.077572
+0xc004f6f0
+// -3.432322
+0xc05bab29
+// -3.887496
+0xc078ccbe
+// -2.330283
+0xc015235c
+// -4.281625
+0xc0890313
+// -2.792802
+0xc032bd47
+// -3.537002
+0xc0625e3c
+// -2.596332
+0xc0262a4c
+// -2.325534
+0xc014d58c
+// -4.894490
+0xc09c9faa
+// -2.087094
+0xc00592f2
+// -2.084767
+0xc0056cd1
+// -2.140000
+0xc008f5c3
+// -2.594693
+0xc0260f73
+// -2.153972
+0xc009daae
+// -2.255843
+0xc0105fba
+// -2.343498
+0xc015fbe1
+// -2.801124
+0xc033459e
+// -3.336209
+0xc0558474
+// -1.987465
+0xbffe653f
+// -2.414814
+0xc01a8c50
+// -6.880915
+0xc0dc3075
+// -2.485003
+0xc01f0a49
+// -4.514564
+0xc0907750
+// -1.906942
+0xbff416aa
+// -4.519725
+0xc090a197
+// -3.122070
+0xc047d000
+// -2.038553
+0xc00277a7
+// -2.179355
+0xc00b7a8c
+// -3.639486
+0xc068ed58
+// -5.771378
+0xc0b8af20
+// -5.837187
+0xc0baca3c
+// -3.616186
+0xc0676f96
+// -4.969469
+0xc09f05e3
+// -2.321794
+0xc0149846
+// -2.530933
+0xc021facd
+// -3.084159
+0xc04562dd
+// -1.983283
+0xbffddc36
+// -3.134855
+0xc048a175
+// -1.947384
+0xbff943e4
+// -1.855862
+0xbfed8ce4
+// -2.377312
+0xc01825e0
+// -3.357540
+0xc056e1ef
+// -2.654137
+0xc029dd60
+// -3.180546
+0xc04b8e10
+// -2.387543
+0xc018cd80
+// -3.209159
+0xc04d62de
+// -2.023680
+0xc00183f8
+// -2.192628
+0xc00c5405
+// -4.629758
+0xc09426fa
+// -2.004601
+0xc0004b62
+// -5.716032
+0xc0b6e9bc
+// -2.286533
+0xc012568c
+// -2.632237
+0xc0287691
+// -2.575437
+0xc024d3f7
+// -2.482530
+0xc01ee1c5
+// -2.304803
+0xc01381e5
+// -3.295181
+0xc052e43d
+// -3.903040
+0xc079cb69
+// -3.581063
+0xc0653023
+// -2.061085
+0xc003e8d0
+// -2.999021
+0xc03feff6
+// -2.071894
+0xc00499e7
+// -1.955618
+0xbffa51b5
+// -3.044899
+0xc042df9f
+// -2.343644
+0xc015fe42
+// -2.916562
+0xc03aa8f4
+// -2.705771
+0xc02d2b59
+// -3.337948
+0xc055a0f2
+// -1.957135
+0xbffa836a
+// -2.599720
+0xc02661d1
+// -1.785619
+0xbfe48f2c
+// -2.366344
+0xc017722d
+// -4.590683
+0xc092e6df
+// -2.654294
+0xc029dff4
+// -2.288701
+0xc0127a13
+// -4.258182
+0xc0884307
+// -3.278001
+0xc051cac3
+// -2.762944
+0xc030d413
+// -2.213926
+0xc00db0f8
+// -5.468220
+0xc0aefba8
+// -2.752874
+0xc0302f17
+// -2.783155
+0xc0321f35
+// -2.128426
+0xc0083820
+// -5.436661
+0xc0adf920
+// -2.515801
+0xc02102e1
+// -2.196171
+0xc00c8e10
+// -2.005714
+0xc0005d9d
+// -3.085679
+0xc0457bc3
+// -4.045663
+0xc0817612
+// -2.702803
+0xc02cfabb
+// -2.482926
+0xc01ee844
+// -3.335565
+0xc05579e6
+// -2.596393
+0xc0262b4d
+// -2.819914
+0xc0347979
+// -2.015959
+0xc001057a
+// -3.070936
+0xc0448a37

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB3_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB3_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB3_f32.txt
deleted file mode 100755
index fe5fdf1..0000000
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB3_f32.txt
+++ /dev/null
@@ -1,242 +0,0 @@
-W
-120
-// 0.044983
-0x3d384090
-// 0.063204
-0x3d817126
-// 0.014184
-0x3c68646a
-// 0.119876
-0x3df5815b
-// 0.202342
-0x3e4f32d3
-// 0.145255
-0x3e14bdbf
-// 0.029081
-0x3cee3abb
-// 0.175435
-0x3e33a51e
-// 0.073557
-0x3d96a4fa
-// 0.102909
-0x3dd2c21a
-// 0.003713
-0x3b7359dd
-// 0.025461
-0x3cd092d9
-// 0.027952
-0x3ce4fc04
-// 0.121727
-0x3df94bf7
-// 0.150883
-0x3e1a810a
-// 0.137462
-0x3e0cc2e5
-// 0.177950
-0x3e363893
-// 0.025627
-0x3cd1eec3
-// 0.057045
-0x3d69a84b
-// 0.028221
-0x3ce72fc6
-// 0.050590
-0x3d4f37a3
-// 0.035918
-0x3d131ea9
-// 0.118421
-0x3df286f7
-// 0.068203
-0x3d8bae1d
-// 0.031919
-0x3d02bd42
-// 0.051377
-0x3d5270f2
-// 0.095771
-0x3dc4235d
-// 0.112689
-0x3de6c972
-// 0.124770
-0x3dff876b
-// 0.129501
-0x3e049bfb
-// 0.061095
-0x3d7a3f14
-// 0.109398
-0x3de00c11
-// 0.060844
-0x3d793729
-// 0.109745
-0x3de0c21d
-// 0.102047
-0x3dd0fdf0
-// 0.010844
-0x3c31abc7
-// 0.025053
-0x3ccd3c7a
-// 0.104917
-0x3dd6de92
-// 0.101331
-0x3dcf86bb
-// 0.066291
-0x3d87c37f
-// 0.109169
-0x3ddf9419
-// 0.107543
-0x3ddc3fc2
-// 0.027078
-0x3cddd245
-// 0.030607
-0x3cfabc0a
-// 0.074828
-0x3d993f39
-// 0.206119
-0x3e5310d4
-// 0.037497
-0x3d1996b2
-// 0.109567
-0x3de0646f
-// 0.179149
-0x3e3772d6
-// 0.102167
-0x3dd13ce3
-// 0.081166
-0x3da63a5e
-// 0.015204
-0x3c791a5c
-// 0.180793
-0x3e3921db
-// 0.042993
-0x3d3019e2
-// 0.032140
-0x3d03a551
-// 0.042215
-0x3d2ce9b6
-// 0.066584
-0x3d885d27
-// 0.079089
-0x3da1f99d
-// 0.019153
-0x3c9ce730
-// 0.159346
-0x3e232b87
-// 0.096565
-0x3dc5c41d
-// 0.081082
-0x3da60e67
-// 0.147438
-0x3e16f9f4
-// 0.078555
-0x3da0e1a0
-// 0.077076
-0x3d9dd9fc
-// 0.015722
-0x3c80cafb
-// 0.165153
-0x3e291dcd
-// 0.093546
-0x3dbf94cd
-// 0.034683
-0x3d0e0f9e
-// 0.055575
-0x3d63a319
-// 0.023973
-0x3cc463b2
-// 0.130632
-0x3e05c445
-// 0.020764
-0x3caa1a04
-// 0.103480
-0x3dd3ed5b
-// 0.138688
-0x3e0e0446
-// 0.098501
-0x3dc9bae5
-// 0.024754
-0x3ccac9eb
-// 0.090573
-0x3db97e34
-// 0.153524
-0x3e1d3568
-// 0.099521
-0x3dcbd17a
-// 0.012342
-0x3c4a3526
-// 0.061270
-0x3d7af6a9
-// 0.042894
-0x3d2fb16c
-// 0.153689
-0x3e1d6085
-// 0.022284
-0x3cb68ce3
-// 0.003680
-0x3b71257c
-// 0.004948
-0x3ba22640
-// 0.082520
-0x3da90018
-// 0.060753
-0x3d78d882
-// 0.146602
-0x3e161ec3
-// 0.161830
-0x3e25b6dc
-// 0.001966
-0x3b00d470
-// 0.130081
-0x3e0533f4
-// 0.194115
-0x3e46c607
-// 0.146537
-0x3e160dab
-// 0.044685
-0x3d370763
-// 0.126425
-0x3e017593
-// 0.001232
-0x3aa180bf
-// 0.069823
-0x3d8eff7e
-// 0.078981
-0x3da1c0e7
-// 0.139521
-0x3e0ede8e
-// 0.128575
-0x3e03a929
-// 0.119353
-0x3df46f48
-// 0.086768
-0x3db1b384
-// 0.070929
-0x3d91436c
-// 0.003132
-0x3b4d3c69
-// 0.035408
-0x3d110872
-// 0.139852
-0x3e0f3558
-// 0.058214
-0x3d6e715e
-// 0.113633
-0x3de8b830
-// 0.128412
-0x3e037e4e
-// 0.088403
-0x3db50cb1
-// 0.035593
-0x3d11c99e
-// 0.108979
-0x3ddf3058
-// 0.079775
-0x3da360de
-// 0.064459
-0x3d840350
-// 0.052166
-0x3d55ac70
-// 0.087890
-0x3db3ffa7
-// 0.107610
-0x3ddc62b1
-// 0.074867
-0x3d9953ed

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB4_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB4_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB4_f32.txt
deleted file mode 100755
index 7ed2e75..0000000
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/InputB4_f32.txt
+++ /dev/null
@@ -1,282 +0,0 @@
-W
-140
-// -4.880571
-0xc09c2da4
-// -2.310025
-0xc013d775
-// -4.722834
-0xc0972175
-// -2.375864
-0xc0180e29
-// -2.499043
-0xc01ff051
-// -2.617184
-0xc0277ff3
-// -2.500725
-0xc0200bdf
-// -3.125170
-0xc04802ca
-// -2.044707
-0xc002dc79
-// -2.245046
-0xc00faed7
-// -3.789078
-0xc0728042
-// -2.422561
-0xc01b0b3f
-// -2.542340
-0xc022b5b4
-// -2.324173
-0xc014bf3f
-// -4.319170
-0xc08a36a5
-// -2.162495
-0xc00a6653
-// -2.362773
-0xc01737ae
-// -2.666671
-0xc02aaabd
-// -4.811499
-0xc099f7cd
-// -2.457236
-0xc01d435c
-// -2.344153
-0xc016069c
-// -4.008705
-0xc0804750
-// -2.106636
-0xc006d322
-// -2.220302
-0xc00e196f
-// -4.220413
-0xc0870d9f
-// -4.033934
-0xc08115fc
-// -2.067383
-0xc0045003
-// -2.087627
-0xc0059baf
-// -2.514702
-0xc020f0df
-// -2.498742
-0xc01feb64
-// -3.535087
-0xc0623edc
-// -2.905015
-0xc039ebc2
-// -2.178259
-0xc00b689b
-// -2.434247
-0xc01bcab4
-// -3.826071
-0xc074de5b
-// -2.162461
-0xc00a65c1
-// -2.644227
-0xc0293b02
-// -2.566446
-0xc02440a5
-// -6.060368
-0xc0c1ee89
-// -1.916264
-0xbff54823
-// -2.803304
-0xc0336954
-// -2.654779
-0xc029e7e7
-// -2.335184
-0xc01573a9
-// -2.341243
-0xc015d6eb
-// -3.759905
-0xc070a249
-// -2.242762
-0xc00f8968
-// -2.621021
-0xc027becd
-// -2.491564
-0xc01f75c9
-// -2.746422
-0xc02fc562
-// -4.311164
-0xc089f50e
-// -2.260324
-0xc010a927
-// -2.347152
-0xc01637be
-// -2.541638
-0xc022aa32
-// -3.833711
-0xc0755b85
-// -2.269105
-0xc0113903
-// -2.923681
-0xc03b1d98
-// -2.488858
-0xc01f4971
-// -3.593271
-0xc065f828
-// -3.544676
-0xc062dbf7
-// -5.131858
-0xc0a4382e
-// -3.911178
-0xc07a50bd
-// -2.151457
-0xc009b17b
-// -2.580359
-0xc025249a
-// -2.104187
-0xc006aaff
-// -2.370529
-0xc017b6be
-// -2.044771
-0xc002dd86
-// -2.300521
-0xc0133bbe
-// -2.801055
-0xc033447e
-// -3.684200
-0xc06bc9ee
-// -2.081287
-0xc00533ce
-// -3.916425
-0xc07aa6b5
-// -2.163027
-0xc00a6f09
-// -3.035936
-0xc0424cc6
-// -3.616765
-0xc0677914
-// -3.256338
-0xc05067d7
-// -2.049571
-0xc0032c2a
-// -2.793543
-0xc032c967
-// -2.093242
-0xc005f7af
-// -2.377697
-0xc0182c2e
-// -2.534072
-0xc0222e3d
-// -3.141081
-0xc0490779
-// -3.026531
-0xc041b2ae
-// -2.539031
-0xc0227f7d
-// -2.219713
-0xc00e0fc9
-// -2.519878
-0xc02145ae
-// -2.222879
-0xc00e43a5
-// -3.318352
-0xc0545fe0
-// -6.141658
-0xc0c48877
-// -2.532739
-0xc0221866
-// -2.849836
-0xc03663b7
-// -2.203600
-0xc00d07c7
-// -2.386310
-0xc018b94d
-// -2.907326
-0xc03a11a2
-// -2.721533
-0xc02e2d97
-// -2.622819
-0xc027dc42
-// -2.159328
-0xc00a326f
-// -2.286669
-0xc01258c8
-// -3.318666
-0xc0546508
-// -3.334933
-0xc0556f8a
-// -3.479360
-0xc05eadd6
-// -2.436450
-0xc01beecc
-// -2.304555
-0xc0137dd5
-// -3.350386
-0xc0566cba
-// -3.987784
-0xc07f37dc
-// -2.255624
-0xc0105c25
-// -2.225388
-0xc00e6cc3
-// -2.499332
-0xc01ff50f
-// -2.662503
-0xc02a6674
-// -2.355506
-0xc016c09e
-// -2.669696
-0xc02adc4c
-// -2.785439
-0xc03244a1
-// -2.161930
-0xc00a5d0e
-// -2.800365
-0xc033392f
-// -2.776937
-0xc031b954
-// -1.891957
-0xbff22ba3
-// -5.177098
-0xc0a5aaca
-// -2.583016
-0xc0255023
-// -2.938910
-0xc03c171a
-// -2.537616
-0xc022684b
-// -5.884942
-0xc0bc5171
-// -2.104592
-0xc006b1a3
-// -3.753596
-0xc0703aea
-// -2.346414
-0xc0162ba6
-// -2.309552
-0xc013cfb2
-// -2.469240
-0xc01e0807
-// -2.320116
-0xc0147cc8
-// -3.702086
-0xc06ceefa
-// -2.564086
-0xc02419fe
-// -2.339059
-0xc015b325
-// -2.062204
-0xc003fb27
-// -3.666694
-0xc06aab1e
-// -2.273782
-0xc01185a4
-// -5.516875
-0xc0b08a3d
-// -4.206650
-0xc0869ce0
-// -2.816358
-0xc0343f36
-// -2.399771
-0xc01995d9
-// -2.635137
-0xc028a616
-// -2.263880
-0xc010e367
-// -2.297445
-0xc0130959
-// -2.174929
-0xc00b3209

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MaxIndexes1_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MaxIndexes1_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MaxIndexes1_s16.txt
new file mode 100644
index 0000000..bf129e7
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MaxIndexes1_s16.txt
@@ -0,0 +1,8 @@
+H
+3
+// 0
+0x0000
+// 0
+0x0000
+// 0
+0x0000

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MaxVals1_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MaxVals1_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MaxVals1_f32.txt
new file mode 100644
index 0000000..58ca9e1
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MaxVals1_f32.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.180773
+0x3e391ca7
+// 0.180773
+0x3e391ca7
+// 0.180773
+0x3e391ca7

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MeanVals2_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MeanVals2_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MeanVals2_f32.txt
new file mode 100644
index 0000000..5c9052c
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MeanVals2_f32.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.173349
+0x3e318274
+// 0.135209
+0x3e0a742f
+// 0.125728
+0x3e00bed6

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MinIndexes3_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MinIndexes3_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MinIndexes3_s16.txt
new file mode 100644
index 0000000..df7bb13
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MinIndexes3_s16.txt
@@ -0,0 +1,8 @@
+H
+3
+// 2
+0x0002
+// 2
+0x0002
+// 2
+0x0002

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MinVals3_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MinVals3_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MinVals3_f32.txt
new file mode 100644
index 0000000..ab2e159
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/MinVals3_f32.txt
@@ -0,0 +1,8 @@
+W
+3
+// -0.335957
+0xbeac029b
+// -0.335957
+0xbeac029b
+// -0.335957
+0xbeac029b

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/PowerVals4_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/PowerVals4_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/PowerVals4_f32.txt
new file mode 100644
index 0000000..2a6c750
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/PowerVals4_f32.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.145557
+0x3e150cfe
+// 0.224405
+0x3e65ca7c
+// 0.226893
+0x3e6856bb

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefEntropy1_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefEntropy1_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefEntropy1_f32.txt
deleted file mode 100755
index 4288b22..0000000
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefEntropy1_f32.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-W
-10
-// 2.420426
-0x401ae842
-// 2.473287
-0x401e4a55
-// 2.294621
-0x4012db14
-// 2.440063
-0x401c29fe
-// 2.265126
-0x4010f7d3
-// 2.407317
-0x401a117d
-// 2.527646
-0x4021c4f2
-// 2.570614
-0x402484f0
-// 2.421607
-0x401afb9b
-// 2.455924
-0x401d2ddb

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefEntropy22_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefEntropy22_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefEntropy22_f32.txt
new file mode 100644
index 0000000..4229855
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefEntropy22_f32.txt
@@ -0,0 +1,22 @@
+W
+10
+// 2.474748
+0x401e6244
+// 2.586410
+0x402587bc
+// 2.481122
+0x401ecab5
+// 2.555989
+0x40239552
+// 2.464160
+0x401db4cb
+// 2.321593
+0x401494fb
+// 2.462875
+0x401d9fbf
+// 2.521439
+0x40215f40
+// 2.442936
+0x401c590f
+// 2.487722
+0x401f36d6

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefKL24_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefKL24_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefKL24_f32.txt
new file mode 100644
index 0000000..3247148
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefKL24_f32.txt
@@ -0,0 +1,22 @@
+W
+10
+// 0.317130
+0x3ea25ed2
+// 0.598060
+0x3f191a7b
+// 0.535593
+0x3f091ca7
+// 0.864186
+0x3f5d3b50
+// 0.635382
+0x3f22a865
+// 0.591023
+0x3f174d41
+// 1.252037
+0x3fa042bd
+// 0.369431
+0x3ebd260a
+// 0.464273
+0x3eedb533
+// 0.556895
+0x3f0e90a5

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefKL3_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefKL3_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefKL3_f32.txt
deleted file mode 100755
index 20e8384..0000000
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefKL3_f32.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-W
-10
-// 0.957399
-0x3f751812
-// 0.406465
-0x3ed01c21
-// 0.357268
-0x3eb6ebe3
-// 0.686696
-0x3f2fcb50
-// 0.448469
-0x3ee59dc7
-// 0.205755
-0x3e52b16b
-// 0.562704
-0x3f100d63
-// 0.606644
-0x3f1b4d00
-// 0.293960
-0x3e9681e7
-// 0.239745
-0x3e757fd5

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp1_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp1_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp1_f32.txt
deleted file mode 100755
index a240bec..0000000
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp1_f32.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-W
-10
-// 2.711102
-0x402d82b0
-// 2.711427
-0x402d8804
-// 2.711261
-0x402d854c
-// 2.711538
-0x402d89d8
-// 2.711763
-0x402d8d88
-// 2.711499
-0x402d8935
-// 2.710971
-0x402d808c
-// 2.711208
-0x402d8470
-// 2.711304
-0x402d8602
-// 2.711338
-0x402d8691

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp23_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp23_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp23_f32.txt
new file mode 100644
index 0000000..f567392
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp23_f32.txt
@@ -0,0 +1,22 @@
+W
+10
+// 3.046099
+0x4042f349
+// 3.046020
+0x4042f1fe
+// 3.046275
+0x4042f62a
+// 3.045934
+0x4042f094
+// 3.046173
+0x4042f480
+// 3.045950
+0x4042f0d9
+// 3.046239
+0x4042f595
+// 3.045982
+0x4042f15f
+// 3.046222
+0x4042f54f
+// 3.046098
+0x4042f347

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp2_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp2_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp2_f32.txt
deleted file mode 100755
index 1b54d8b..0000000
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp2_f32.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-W
-10
-// 3.046080
-0x4042f2f9
-// 3.046085
-0x4042f30e
-// 3.046527
-0x4042fa4e
-// 3.045871
-0x4042ef8e
-// 3.046065
-0x4042f2ba
-// 3.046120
-0x4042f3a3
-// 3.045996
-0x4042f199
-// 3.046050
-0x4042f27b
-// 3.046123
-0x4042f3ae
-// 3.046097
-0x4042f33f

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExpDot25_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExpDot25_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExpDot25_f32.txt
new file mode 100644
index 0000000..3dac61a
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExpDot25_f32.txt
@@ -0,0 +1,22 @@
+W
+10
+// -2.637687
+0xc028cfde
+// -2.665422
+0xc02a9645
+// -2.569673
+0xc0247586
+// -2.501364
+0xc0201659
+// -2.573845
+0xc024b9de
+// -2.665674
+0xc02a9a69
+// -2.653128
+0xc029ccd8
+// -2.665512
+0xc02a97c0
+// -2.608091
+0xc026eaf8
+// -2.437264
+0xc01bfc24

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExpDot4_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExpDot4_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExpDot4_f32.txt
deleted file mode 100755
index 220bee1..0000000
--- a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExpDot4_f32.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-W
-10
-// -2.635825
-0xc028b15a
-// -2.578362
-0xc02503e3
-// -2.684868
-0xc02bd4e2
-// -2.621420
-0xc027c558
-// -2.664016
-0xc02a7f3f
-// -2.518862
-0xc0213507
-// -2.646046
-0xc02958d1
-// -2.663388
-0xc02a74f1
-// -2.524261
-0xc0218d7f
-// -2.660810
-0xc02a4ab5

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RmsVals5_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RmsVals5_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RmsVals5_f32.txt
new file mode 100644
index 0000000..71f8038
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/RmsVals5_f32.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.220271
+0x3e618e9c
+// 0.167483
+0x3e2b80bd
+// 0.158778
+0x3e2296a2

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/StdVals6_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/StdVals6_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/StdVals6_f32.txt
new file mode 100644
index 0000000..a59d8fa
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/StdVals6_f32.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.262554
+0x3e866d84
+// 0.170469
+0x3e2e8f6c
+// 0.162981
+0x3e26e496

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/VarVals7_f32.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/VarVals7_f32.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/VarVals7_f32.txt
new file mode 100644
index 0000000..a6d9bfa
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF32/VarVals7_f32.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.068935
+0x3d8d2daa
+// 0.029060
+0x3cee0e90
+// 0.026563
+0x3cd99a7c

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/Input1_q15.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/Input1_q15.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/Input1_q15.txt
new file mode 100644
index 0000000..4765dfe
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/Input1_q15.txt
@@ -0,0 +1,602 @@
+H
+300
+// -0.129424
+0xEF6F
+// 0.300659
+0x267C
+// 0.952315
+0x79E5
+// 0.127592
+0x1055
+// -0.145106
+0xED6D
+// -0.264355
+0xDE2A
+// 0.064840
+0x084D
+// -0.207798
+0xE567
+// -0.015726
+0xFDFD
+// 0.378317
+0x306D
+// -0.027830
+0xFC70
+// 0.554807
+0x4704
+// -0.399803
+0xCCD3
+// -0.076024
+0xF645
+// 0.902645
+0x738A
+// 0.430024
+0x370B
+// -0.121616
+0xF06F
+// -0.004903
+0xFF5F
+// 0.124252
+0x0FE7
+// 0.426960
+0x36A7
+// -0.208824
+0xE545
+// 0.294137
+0x25A6
+// -0.008791
+0xFEE0
+// -0.018669
+0xFD9C
+// 0.140396
+0x11F8
+// -0.099961
+0xF334
+// -0.676805
+0xA95E
+// 0.391980
+0x322C
+// 0.246912
+0x1F9B
+// 0.211322
+0x1B0D
+// -0.269914
+0xDD73
+// -0.053112
+0xF934
+// 0.313060
+0x2812
+// 0.188772
+0x182A
+// -0.197396
+0xE6BC
+// 0.555692
+0x4721
+// -0.787394
+0x9B37
+// 0.395110
+0x3293
+// 0.090162
+0x0B8A
+// 0.264893
+0x21E8
+// -0.152509
+0xEC7B
+// 0.179959
+0x1709
+// 0.610978
+0x4E35
+// -0.129914
+0xEF5F
+// -0.342287
+0xD430
+// -1.015459
+0x8000
+// 0.253526
+0x2074
+// 0.113958
+0x0E96
+// -0.009141
+0xFED4
+// -0.363836
+0xD16E
+// -0.218311
+0xE40E
+// 0.084999
+0x0AE1
+// 0.112939
+0x0E75
+// 0.349567
+0x2CBF
+// 0.249411
+0x1FED
+// 0.085612
+0x0AF5
+// 0.347319
+0x2C75
+// 0.281351
+0x2403
+// -0.328026
+0xD603
+// -0.302669
+0xD942
+// 0.250757
+0x2019
+// 0.140259
+0x11F4
+// -0.364104
+0xD165
+// 0.057587
+0x075F
+// -0.079101
+0xF5E0
+// -0.650527
+0xACBC
+// 0.082911
+0x0A9D
+// 0.064487
+0x0841
+// -0.000970
+0xFFE0
+// -0.254963
+0xDF5D
+// -0.228137
+0xE2CC
+// -0.014375
+0xFE29
+// 0.367610
+0x2F0E
+// -0.016753
+0xFDDB
+// -0.508248
+0xBEF2
+// 0.452682
+0x39F1
+// 0.712255
+0x5B2B
+// -0.556560
+0xB8C3
+// 0.880904
+0x70C1
+// -0.605523
+0xB27E
+// 0.225032
+0x1CCE
+// -0.044564
+0xFA4C
+// 0.163399
+0x14EA
+// -0.188500
+0xE7DF
+// 0.470300
+0x3C33
+// -0.627604
+0xAFAB
+// 0.868095
+0x6F1E
+// 0.250116
+0x2004
+// 0.468909
+0x3C05
+// 0.299856
+0x2662
+// -0.143236
+0xEDAA
+// -0.314611
+0xD7BB
+// 0.241615
+0x1EED
+// -0.282959
+0xDBC8
+// 0.166968
+0x155F
+// 0.101992
+0x0D0E
+// 0.814363
+0x683D
+// -0.114577
+0xF156
+// -0.804388
+0x990A
+// -0.525777
+0xBCB3
+// -0.347144
+0xD391
+// -0.090323
+0xF470
+// 0.632555
+0x50F8
+// -0.004340
+0xFF72
+// 0.160799
+0x1495
+// 1.000000
+0x7FFF
+// -0.101838
+0xF2F7
+// 0.136319
+0x1173
+// -0.822422
+0x96BB
+// 0.208644
+0x1AB5
+// -0.101037
+0xF311
+// -0.581907
+0xB584
+// 0.302440
+0x26B6
+// 0.175385
+0x1673
+// 0.182595
+0x175F
+// -0.317191
+0xD766
+// 0.035901
+0x0498
+// -0.224800
+0xE33A
+// 0.281458
+0x2407
+// -0.561082
+0xB82E
+// 0.227113
+0x1D12
+// -0.030103
+0xFC26
+// -0.097333
+0xF38B
+// 0.081006
+0x0A5E
+// -0.073598
+0xF694
+// 0.011075
+0x016B
+// 0.226532
+0x1CFF
+// -0.155943
+0xEC0A
+// 0.088428
+0x0B52
+// 0.181517
+0x173C
+// -0.155758
+0xEC10
+// -0.115848
+0xF12C
+// -0.044230
+0xFA57
+// -0.437941
+0xC7F2
+// -0.124809
+0xF006
+// -0.092449
+0xF42B
+// -0.201462
+0xE636
+// -0.508946
+0xBEDB
+// 0.268065
+0x2250
+// 0.366393
+0x2EE6
+// 0.241221
+0x1EE0
+// 0.135078
+0x114A
+// -0.085470
+0xF50F
+// 0.045236
+0x05CA
+// -0.008379
+0xFEED
+// 0.045823
+0x05DE
+// 0.030623
+0x03EB
+// -0.232325
+0xE243
+// -0.310345
+0xD847
+// 0.147249
+0x12D9
+// 0.298541
+0x2637
+// -0.253999
+0xDF7D
+// 0.126492
+0x1031
+// -0.062867
+0xF7F4
+// -0.820720
+0x96F3
+// 0.082578
+0x0A92
+// -0.199109
+0xE684
+// -0.395456
+0xCD62
+// -0.337020
+0xD4DD
+// 0.427367
+0x36B4
+// 0.430180
+0x3710
+// 0.200947
+0x19B9
+// 0.164241
+0x1506
+// 0.447653
+0x394D
+// 0.146104
+0x12B4
+// 0.223170
+0x1C91
+// 0.448886
+0x3975
+// -0.609285
+0xB203
+// -0.290520
+0xDAD0
+// -0.050561
+0xF987
+// -0.165093
+0xEADE
+// 0.393838
+0x3269
+// 0.369355
+0x2F47
+// -0.147432
+0xED21
+// -0.033987
+0xFBA6
+// -0.263119
+0xDE52
+// 0.102610
+0x0D22
+// 0.058432
+0x077B
+// -0.306605
+0xD8C1
+// -0.410825
+0xCB6A
+// -0.034994
+0xFB85
+// -0.743634
+0xA0D1
+// -0.316313
+0xD783
+// 0.416921
+0x355E
+// 0.128592
+0x1076
+// -0.193789
+0xE732
+// 0.099331
+0x0CB7
+// -0.376321
+0xCFD5
+// -0.203096
+0xE601
+// 0.352315
+0x2D19
+// 0.738274
+0x5E80
+// -0.534742
+0xBB8E
+// 0.386115
+0x316C
+// 0.156725
+0x1410
+// -0.015653
+0xFDFF
+// -0.190905
+0xE790
+// -0.322522
+0xD6B8
+// -0.448099
+0xC6A5
+// 0.390328
+0x31F6
+// 0.273528
+0x2303
+// 0.152436
+0x1383
+// 0.082029
+0x0A80
+// 0.023099
+0x02F5
+// -0.163495
+0xEB13
+// 0.554668
+0x46FF
+// -0.327866
+0xD609
+// 0.216476
+0x1BB5
+// 0.003064
+0x0064
+// 0.193613
+0x18C8
+// -0.233694
+0xE216
+// 0.034442
+0x0469
+// 0.181225
+0x1732
+// -0.322650
+0xD6B3
+// 0.255309
+0x20AE
+// -0.156738
+0xEBF0
+// -0.410962
+0xCB66
+// 0.064397
+0x083E
+// -0.288634
+0xDB0E
+// 0.064697
+0x0848
+// -0.420666
+0xCA28
+// 0.085141
+0x0AE6
+// 0.400667
+0x3349
+// 0.291649
+0x2555
+// -0.595296
+0xB3CD
+// -0.411619
+0xCB50
+// 0.239398
+0x1EA5
+// -0.306005
+0xD8D5
+// 0.193002
+0x18B4
+// -0.143834
+0xED97
+// 0.015754
+0x0204
+// 0.115249
+0x0EC0
+// 0.338290
+0x2B4D
+// -0.370386
+0xD097
+// -0.107008
+0xF24E
+// -0.034862
+0xFB8A
+// -0.076444
+0xF637
+// 0.288600
+0x24F1
+// -0.049407
+0xF9AD
+// -0.060101
+0xF84F
+// -0.499142
+0xC01C
+// 0.021883
+0x02CD
+// -0.584850
+0xB524
+// -0.021138
+0xFD4B
+// 0.005308
+0x00AE
+// 0.375920
+0x301E
+// 0.105839
+0x0D8C
+// -0.409281
+0xCB9D
+// 0.207603
+0x1A93
+// 0.053045
+0x06CA
+// 0.215809
+0x1BA0
+// -0.022287
+0xFD26
+// 0.245996
+0x1F7D
+// -0.190015
+0xE7AE
+// -0.669287
+0xAA55
+// -0.098765
+0xF35C
+// 0.242378
+0x1F06
+// -0.080987
+0xF5A2
+// -0.644445
+0xAD83
+// -0.445174
+0xC705
+// -0.116275
+0xF11E
+// -0.239216
+0xE161
+// 0.183359
+0x1778
+// -0.122291
+0xF059
+// -0.328909
+0xD5E6
+// 0.465730
+0x3B9D
+// -0.319624
+0xD717
+// 0.301668
+0x269D
+// 0.375351
+0x300B
+// -0.359200
+0xD206
+// 0.217429
+0x1BD5
+// 0.101542
+0x0CFF
+// -0.322950
+0xD6AA
+// -0.606805
+0xB254
+// -0.144087
+0xED8F
+// 0.237254
+0x1E5E
+// 0.527582
+0x4388
+// -0.250380
+0xDFF4
+// -0.124179
+0xF01B
+// -0.150488
+0xECBD
+// 0.138308
+0x11B4
+// 0.346468
+0x2C59
+// -0.107860
+0xF232
+// 0.678168
+0x56CE
+// 0.173477
+0x1634
+// 0.496094
+0x3F80
+// 0.050544
+0x0678
+// -0.069782
+0xF711
+// 0.496197
+0x3F83
+// -0.038752
+0xFB0A
+// -0.450471
+0xC657
+// 0.390899
+0x3209
+// 0.068641
+0x08C9
+// 0.046916
+0x0601
+// -0.467572
+0xC427
+// -0.180980
+0xE8D6
+// 0.041288
+0x0549
+// -0.322907
+0xD6AB
+// -0.072556
+0xF6B6
+// -0.058526
+0xF882
+// -0.665655
+0xAACC

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/Input2_q15.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/Input2_q15.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/Input2_q15.txt
new file mode 100644
index 0000000..ecd4956
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/Input2_q15.txt
@@ -0,0 +1,602 @@
+H
+300
+// 0.129424
+0x1091
+// 0.300659
+0x267C
+// 0.952315
+0x79E5
+// 0.127592
+0x1055
+// 0.145106
+0x1293
+// 0.264355
+0x21D6
+// 0.064840
+0x084D
+// 0.207798
+0x1A99
+// 0.015726
+0x0203
+// 0.378317
+0x306D
+// 0.027830
+0x0390
+// 0.554807
+0x4704
+// 0.399803
+0x332D
+// 0.076024
+0x09BB
+// 0.902645
+0x738A
+// 0.430024
+0x370B
+// 0.121616
+0x0F91
+// 0.004903
+0x00A1
+// 0.124252
+0x0FE7
+// 0.426960
+0x36A7
+// 0.208824
+0x1ABB
+// 0.294137
+0x25A6
+// 0.008791
+0x0120
+// 0.018669
+0x0264
+// 0.140396
+0x11F8
+// 0.099961
+0x0CCC
+// 0.676805
+0x56A2
+// 0.391980
+0x322C
+// 0.246912
+0x1F9B
+// 0.211322
+0x1B0D
+// 0.269914
+0x228D
+// 0.053112
+0x06CC
+// 0.313060
+0x2812
+// 0.188772
+0x182A
+// 0.197396
+0x1944
+// 0.555692
+0x4721
+// 0.787394
+0x64C9
+// 0.395110
+0x3293
+// 0.090162
+0x0B8A
+// 0.264893
+0x21E8
+// 0.152509
+0x1385
+// 0.179959
+0x1709
+// 0.610978
+0x4E35
+// 0.129914
+0x10A1
+// 0.342287
+0x2BD0
+// 1.015459
+0x7FFF
+// 0.253526
+0x2074
+// 0.113958
+0x0E96
+// 0.009141
+0x012C
+// 0.363836
+0x2E92
+// 0.218311
+0x1BF2
+// 0.084999
+0x0AE1
+// 0.112939
+0x0E75
+// 0.349567
+0x2CBF
+// 0.249411
+0x1FED
+// 0.085612
+0x0AF5
+// 0.347319
+0x2C75
+// 0.281351
+0x2403
+// 0.328026
+0x29FD
+// 0.302669
+0x26BE
+// 0.250757
+0x2019
+// 0.140259
+0x11F4
+// 0.364104
+0x2E9B
+// 0.057587
+0x075F
+// 0.079101
+0x0A20
+// 0.650527
+0x5344
+// 0.082911
+0x0A9D
+// 0.064487
+0x0841
+// 0.000970
+0x0020
+// 0.254963
+0x20A3
+// 0.228137
+0x1D34
+// 0.014375
+0x01D7
+// 0.367610
+0x2F0E
+// 0.016753
+0x0225
+// 0.508248
+0x410E
+// 0.452682
+0x39F1
+// 0.712255
+0x5B2B
+// 0.556560
+0x473D
+// 0.880904
+0x70C1
+// 0.605523
+0x4D82
+// 0.225032
+0x1CCE
+// 0.044564
+0x05B4
+// 0.163399
+0x14EA
+// 0.188500
+0x1821
+// 0.470300
+0x3C33
+// 0.627604
+0x5055
+// 0.868095
+0x6F1E
+// 0.250116
+0x2004
+// 0.468909
+0x3C05
+// 0.299856
+0x2662
+// 0.143236
+0x1256
+// 0.314611
+0x2845
+// 0.241615
+0x1EED
+// 0.282959
+0x2438
+// 0.166968
+0x155F
+// 0.101992
+0x0D0E
+// 0.814363
+0x683D
+// 0.114577
+0x0EAA
+// 0.804388
+0x66F6
+// 0.525777
+0x434D
+// 0.347144
+0x2C6F
+// 0.090323
+0x0B90
+// 0.632555
+0x50F8
+// 0.004340
+0x008E
+// 0.160799
+0x1495
+// 1.000000
+0x7FFF
+// 0.101838
+0x0D09
+// 0.136319
+0x1173
+// 0.822422
+0x6945
+// 0.208644
+0x1AB5
+// 0.101037
+0x0CEF
+// 0.581907
+0x4A7C
+// 0.302440
+0x26B6
+// 0.175385
+0x1673
+// 0.182595
+0x175F
+// 0.317191
+0x289A
+// 0.035901
+0x0498
+// 0.224800
+0x1CC6
+// 0.281458
+0x2407
+// 0.561082
+0x47D2
+// 0.227113
+0x1D12
+// 0.030103
+0x03DA
+// 0.097333
+0x0C75
+// 0.081006
+0x0A5E
+// 0.073598
+0x096C
+// 0.011075
+0x016B
+// 0.226532
+0x1CFF
+// 0.155943
+0x13F6
+// 0.088428
+0x0B52
+// 0.181517
+0x173C
+// 0.155758
+0x13F0
+// 0.115848
+0x0ED4
+// 0.044230
+0x05A9
+// 0.437941
+0x380E
+// 0.124809
+0x0FFA
+// 0.092449
+0x0BD5
+// 0.201462
+0x19CA
+// 0.508946
+0x4125
+// 0.268065
+0x2250
+// 0.366393
+0x2EE6
+// 0.241221
+0x1EE0
+// 0.135078
+0x114A
+// 0.085470
+0x0AF1
+// 0.045236
+0x05CA
+// 0.008379
+0x0113
+// 0.045823
+0x05DE
+// 0.030623
+0x03EB
+// 0.232325
+0x1DBD
+// 0.310345
+0x27B9
+// 0.147249
+0x12D9
+// 0.298541
+0x2637
+// 0.253999
+0x2083
+// 0.126492
+0x1031
+// 0.062867
+0x080C
+// 0.820720
+0x690D
+// 0.082578
+0x0A92
+// 0.199109
+0x197C
+// 0.395456
+0x329E
+// 0.337020
+0x2B23
+// 0.427367
+0x36B4
+// 0.430180
+0x3710
+// 0.200947
+0x19B9
+// 0.164241
+0x1506
+// 0.447653
+0x394D
+// 0.146104
+0x12B4
+// 0.223170
+0x1C91
+// 0.448886
+0x3975
+// 0.609285
+0x4DFD
+// 0.290520
+0x2530
+// 0.050561
+0x0679
+// 0.165093
+0x1522
+// 0.393838
+0x3269
+// 0.369355
+0x2F47
+// 0.147432
+0x12DF
+// 0.033987
+0x045A
+// 0.263119
+0x21AE
+// 0.102610
+0x0D22
+// 0.058432
+0x077B
+// 0.306605
+0x273F
+// 0.410825
+0x3496
+// 0.034994
+0x047B
+// 0.743634
+0x5F2F
+// 0.316313
+0x287D
+// 0.416921
+0x355E
+// 0.128592
+0x1076
+// 0.193789
+0x18CE
+// 0.099331
+0x0CB7
+// 0.376321
+0x302B
+// 0.203096
+0x19FF
+// 0.352315
+0x2D19
+// 0.738274
+0x5E80
+// 0.534742
+0x4472
+// 0.386115
+0x316C
+// 0.156725
+0x1410
+// 0.015653
+0x0201
+// 0.190905
+0x1870
+// 0.322522
+0x2948
+// 0.448099
+0x395B
+// 0.390328
+0x31F6
+// 0.273528
+0x2303
+// 0.152436
+0x1383
+// 0.082029
+0x0A80
+// 0.023099
+0x02F5
+// 0.163495
+0x14ED
+// 0.554668
+0x46FF
+// 0.327866
+0x29F7
+// 0.216476
+0x1BB5
+// 0.003064
+0x0064
+// 0.193613
+0x18C8
+// 0.233694
+0x1DEA
+// 0.034442
+0x0469
+// 0.181225
+0x1732
+// 0.322650
+0x294D
+// 0.255309
+0x20AE
+// 0.156738
+0x1410
+// 0.410962
+0x349A
+// 0.064397
+0x083E
+// 0.288634
+0x24F2
+// 0.064697
+0x0848
+// 0.420666
+0x35D8
+// 0.085141
+0x0AE6
+// 0.400667
+0x3349
+// 0.291649
+0x2555
+// 0.595296
+0x4C33
+// 0.411619
+0x34B0
+// 0.239398
+0x1EA5
+// 0.306005
+0x272B
+// 0.193002
+0x18B4
+// 0.143834
+0x1269
+// 0.015754
+0x0204
+// 0.115249
+0x0EC0
+// 0.338290
+0x2B4D
+// 0.370386
+0x2F69
+// 0.107008
+0x0DB2
+// 0.034862
+0x0476
+// 0.076444
+0x09C9
+// 0.288600
+0x24F1
+// 0.049407
+0x0653
+// 0.060101
+0x07B1
+// 0.499142
+0x3FE4
+// 0.021883
+0x02CD
+// 0.584850
+0x4ADC
+// 0.021138
+0x02B5
+// 0.005308
+0x00AE
+// 0.375920
+0x301E
+// 0.105839
+0x0D8C
+// 0.409281
+0x3463
+// 0.207603
+0x1A93
+// 0.053045
+0x06CA
+// 0.215809
+0x1BA0
+// 0.022287
+0x02DA
+// 0.245996
+0x1F7D
+// 0.190015
+0x1852
+// 0.669287
+0x55AB
+// 0.098765
+0x0CA4
+// 0.242378
+0x1F06
+// 0.080987
+0x0A5E
+// 0.644445
+0x527D
+// 0.445174
+0x38FB
+// 0.116275
+0x0EE2
+// 0.239216
+0x1E9F
+// 0.183359
+0x1778
+// 0.122291
+0x0FA7
+// 0.328909
+0x2A1A
+// 0.465730
+0x3B9D
+// 0.319624
+0x28E9
+// 0.301668
+0x269D
+// 0.375351
+0x300B
+// 0.359200
+0x2DFA
+// 0.217429
+0x1BD5
+// 0.101542
+0x0CFF
+// 0.322950
+0x2956
+// 0.606805
+0x4DAC
+// 0.144087
+0x1271
+// 0.237254
+0x1E5E
+// 0.527582
+0x4388
+// 0.250380
+0x200C
+// 0.124179
+0x0FE5
+// 0.150488
+0x1343
+// 0.138308
+0x11B4
+// 0.346468
+0x2C59
+// 0.107860
+0x0DCE
+// 0.678168
+0x56CE
+// 0.173477
+0x1634
+// 0.496094
+0x3F80
+// 0.050544
+0x0678
+// 0.069782
+0x08EF
+// 0.496197
+0x3F83
+// 0.038752
+0x04F6
+// 0.450471
+0x39A9
+// 0.390899
+0x3209
+// 0.068641
+0x08C9
+// 0.046916
+0x0601
+// 0.467572
+0x3BD9
+// 0.180980
+0x172A
+// 0.041288
+0x0549
+// 0.322907
+0x2955
+// 0.072556
+0x094A
+// 0.058526
+0x077E
+// 0.665655
+0x5534

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MaxIndexes1_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MaxIndexes1_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MaxIndexes1_s16.txt
new file mode 100644
index 0000000..df7bb13
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MaxIndexes1_s16.txt
@@ -0,0 +1,8 @@
+H
+3
+// 2
+0x0002
+// 2
+0x0002
+// 2
+0x0002

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MaxVals1_q15.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MaxVals1_q15.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MaxVals1_q15.txt
new file mode 100644
index 0000000..13d2854
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MaxVals1_q15.txt
@@ -0,0 +1,8 @@
+H
+3
+// 0.952315
+0x79E5
+// 0.952315
+0x79E5
+// 0.952315
+0x79E5

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MeanVals2_q15.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MeanVals2_q15.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MeanVals2_q15.txt
new file mode 100644
index 0000000..6ad6a9b
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MeanVals2_q15.txt
@@ -0,0 +1,8 @@
+H
+3
+// 0.283470
+0x2449
+// 0.311079
+0x27D1
+// 0.299934
+0x2664

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MinIndexes3_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MinIndexes3_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MinIndexes3_s16.txt
new file mode 100644
index 0000000..985da2f
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MinIndexes3_s16.txt
@@ -0,0 +1,8 @@
+H
+3
+// 5
+0x0005
+// 12
+0x000C
+// 12
+0x000C

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MinVals3_q15.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MinVals3_q15.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MinVals3_q15.txt
new file mode 100644
index 0000000..5fa95ce
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/MinVals3_q15.txt
@@ -0,0 +1,8 @@
+H
+3
+// -0.264355
+0xDE2A
+// -0.399803
+0xCCD3
+// -0.399803
+0xCCD3

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/PowerVals4_q63.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/PowerVals4_q63.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/PowerVals4_q63.txt
new file mode 100644
index 0000000..a1a4691
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/PowerVals4_q63.txt
@@ -0,0 +1,8 @@
+D
+3
+// 0.000000
+0x000000004807C4D5
+// 0.000000
+0x00000000B24C839D
+// 0.000000
+0x00000000B33ED705

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/RmsVals5_q15.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/RmsVals5_q15.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/RmsVals5_q15.txt
new file mode 100644
index 0000000..62ccc9c
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/RmsVals5_q15.txt
@@ -0,0 +1,8 @@
+H
+3
+// 0.400976
+0x3353
+// 0.417277
+0x3569
+// 0.405891
+0x33F4

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/StdVals6_q15.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/StdVals6_q15.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/StdVals6_q15.txt
new file mode 100644
index 0000000..63e8e15
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/StdVals6_q15.txt
@@ -0,0 +1,8 @@
+H
+3
+// 0.409894
+0x3477
+// 0.401020
+0x3355
+// 0.393949
+0x326D

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/VarVals7_q15.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/VarVals7_q15.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/VarVals7_q15.txt
new file mode 100644
index 0000000..f9759ef
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ15/VarVals7_q15.txt
@@ -0,0 +1,8 @@
+H
+3
+// 0.168013
+0x1581
+// 0.160817
+0x1496
+// 0.155196
+0x13DD

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/Input1_q31.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/Input1_q31.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/Input1_q31.txt
new file mode 100644
index 0000000..a063dda
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/Input1_q31.txt
@@ -0,0 +1,602 @@
+W
+300
+// 0.133707
+0x111D4BCA
+// -0.012960
+0xFE57579D
+// 0.425272
+0x366F4EA1
+// -0.117470
+0xF0F6BE31
+// 0.377878
+0x305E4EE6
+// -0.358723
+0xD2155C9C
+// -0.001974
+0xFFBF4D46
+// 0.299351
+0x265122D5
+// 0.680439
+0x57189E77
+// 0.771196
+0x62B68AF8
+// 0.244944
+0x1F5A5398
+// -0.445427
+0xC6FC4131
+// -0.583545
+0xB54E6545
+// 0.562137
+0x47F41C98
+// 0.071596
+0x092A0BA9
+// 0.080170
+0x0A42FFBB
+// -0.007107
+0xFF171F67
+// -0.019054
+0xFD8FA6DF
+// -0.003400
+0xFF9098ED
+// 0.569465
+0x48E43AD9
+// 0.326771
+0x29D3A1BE
+// -0.044893
+0xFA40F5DB
+// 0.132821
+0x1100438E
+// 0.020239
+0x02972E7B
+// -0.013752
+0xFE3D6286
+// 0.199107
+0x197C5AAB
+// -0.252421
+0xDFB0AF23
+// 0.271559
+0x22C27473
+// -0.280644
+0xDC13D91F
+// -0.101220
+0xF30B3D2D
+// -0.304165
+0xD911217A
+// 0.201929
+0x19D8CB1D
+// -0.215848
+0xE45F186C
+// -0.215221
+0xE473A1FA
+// -0.212671
+0xE4C73048
+// -0.248855
+0xE0258339
+// 0.483492
+0x3DE314DE
+// -0.376536
+0xCFCDA9CB
+// 0.582748
+0x4A977E49
+// -0.389886
+0xCE183449
+// 0.336759
+0x2B1AEDEA
+// -0.023154
+0xFD094CA2
+// 0.209803
+0x1ADAD6A4
+// 0.227764
+0x1D2760D4
+// -0.200260
+0xE65DE398
+// 0.028752
+0x03AE28CD
+// 0.389939
+0x31E985E1
+// 0.369922
+0x2F599C35
+// 0.058957
+0x078BE582
+// 0.626009
+0x50211208
+// -0.179207
+0xE90FC182
+// 0.276137
+0x23587780
+// 0.126228
+0x10284139
+// -0.026574
+0xFC993BC9
+// -0.259433
+0xDECAE7A5
+// 0.463124
+0x3B47A389
+// 0.400664
+0x3348F84F
+// 0.245048
+0x1F5DB88E
+// -0.421906
+0xC9FEFED1
+// 0.271300
+0x22B9F62F
+// -0.392839
+0xCDB771D5
+// 0.431768
+0x37442C7E
+// 0.439444
+0x383FB3D1
+// 0.490046
+0x3EB9D1E9
+// 0.186543
+0x17E0A261
+// 0.129296
+0x108CC746
+// -0.512460
+0xBE67B504
+// 0.105798
+0x0D8AC83B
+// -0.482361
+0xC241FFA5
+// 0.374144
+0x2FE3F053
+// 0.260922
+0x2165E6C2
+// -0.469427
+0xC3E9D245
+// 0.406665
+0x340D9703
+// 0.402744
+0x338D2040
+// -0.076639
+0xF630AE7C
+// -0.319045
+0xD7298B9C
+// 0.003982
+0x00827F8C
+// 0.125242
+0x1007EA4A
+// -0.093592
+0xF4052E51
+// -0.226697
+0xE2FB97B2
+// -0.096836
+0xF39ADD7F
+// 0.187813
+0x180A4095
+// 0.293981
+0x25A12F2A
+// -0.344888
+0xD3DAB3D3
+// 0.339078
+0x2B66EA22
+// -0.019017
+0xFD90D716
+// -0.207858
+0xE564E753
+// 0.508916
+0x41242B54
+// 0.454897
+0x3A3A1468
+// 0.366884
+0x2EF60B2E
+// -0.624739
+0xB0088B5E
+// 0.582097
+0x4A8225DB
+// 0.491654
+0x3EEE81F8
+// 0.446182
+0x391C7CF4
+// 0.483548
+0x3DE4EA6F
+// 0.439328
+0x383BE970
+// -0.121541
+0xF07157F8
+// 0.366670
+0x2EEF0EE7
+// -0.096916
+0xF3983DA3
+// 0.457964
+0x3A9E8C64
+// 0.767914
+0x624B0420
+// 0.325708
+0x29B0CD77
+// -0.009809
+0xFEBE95A7
+// -0.660499
+0xAB74C2C4
+// 0.175222
+0x166DB073
+// -0.184339
+0xE8679847
+// -0.134476
+0xEEC98000
+// 0.169996
+0x15C27068
+// 1.000000
+0x7FFFFFFF
+// -0.062784
+0xF7F6AE60
+// 0.043149
+0x0585E44F
+// -0.267240
+0xDDCB1550
+// -0.483179
+0xC227347A
+// 0.114580
+0x0EAA8F11
+// -0.201280
+0xE63C72A7
+// 0.231434
+0x1D9FA1AA
+// -0.084918
+0xF5216693
+// 0.256387
+0x20D1482D
+// 0.136994
+0x118902B4
+// -0.553340
+0xB92C28C8
+// 0.084429
+0x0ACE9101
+// -0.567616
+0xB7585D27
+// 0.014567
+0x01DD5267
+// 0.134477
+0x11368729
+// 0.147947
+0x12EFF06E
+// -0.202231
+0xE61D4D72
+// -0.067696
+0xF755BA45
+// -0.347254
+0xD38D2C46
+// -0.062872
+0xF7F3D0AF
+// -0.370798
+0xD089AF36
+// -0.301777
+0xD95F5E98
+// -0.465668
+0xC4650147
+// -0.213807
+0xE4A1F57F
+// -0.394411
+0xCD83F376
+// 0.165901
+0x153C3EFB
+// 0.032147
+0x041D66A6
+// 0.149990
+0x1332DEB7
+// -0.166428
+0xEAB27F49
+// 0.310341
+0x27B94054
+// 0.209825
+0x1ADB8B3B
+// -0.354971
+0xD2905307
+// -0.274670
+0xDCD79D5B
+// -0.166133
+0xEABC2620
+// -0.340461
+0xD46BC716
+// -0.491813
+0xC10C4167
+// 0.034670
+0x04700D2A
+// -0.318471
+0xD73C5AEF
+// -0.179105
+0xE91312F3
+// -0.149563
+0xECDB1BE4
+// 0.206144
+0x1A62EC1D
+// 0.000726
+0x0017CCF3
+// -0.099990
+0xF33387A1
+// -0.242725
+0xE0EE64B2
+// -0.051678
+0xF9629B0B
+// 0.580703
+0x4A547845
+// 0.596671
+0x4C5FB978
+// 0.236500
+0x1E45A0ED
+// 0.514924
+0x41E90535
+// 0.006100
+0x00C7E054
+// -0.559561
+0xB8604F07
+// 0.181766
+0x17441F4B
+// -0.251482
+0xDFCF71AB
+// -0.569042
+0xB729A204
+// -0.049916
+0xF99C5639
+// -0.213747
+0xE4A3ED9B
+// 0.380503
+0x30B45457
+// -0.323724
+0xD690334F
+// -0.356887
+0xD2518A11
+// 0.150006
+0x13336219
+// -0.096157
+0xF3B11D14
+// 0.530617
+0x43EB40DE
+// 0.694865
+0x58F15800
+// 0.136154
+0x116D7EE6
+// -0.223343
+0xE3697C57
+// 0.063014
+0x0810D8BB
+// -0.013625
+0xFE41888A
+// -0.130900
+0xEF3EAB8F
+// 0.343172
+0x2BED0BE3
+// -0.002483
+0xFFAEA71F
+// -0.330680
+0xD5AC496E
+// -0.301763
+0xD95FD8AB
+// -0.147323
+0xED248687
+// -0.265874
+0xDDF7D48B
+// -0.069565
+0xF7187D5E
+// 0.149783
+0x132C1A26
+// 0.130641
+0x10B8D8E5
+// -0.090081
+0xF47838C5
+// -0.621401
+0xB075F0A2
+// -0.075357
+0xF65AB04C
+// 0.231423
+0x1D9F42DA
+// 0.477995
+0x3D2EF3F3
+// -0.223126
+0xE3709EA8
+// 0.280653
+0x23EC7361
+// 0.008641
+0x011B2641
+// -0.197468
+0xE6B95CA6
+// 0.400394
+0x33401948
+// 0.262543
+0x219B0007
+// 0.439370
+0x383D4742
+// 0.039081
+0x05009CD2
+// 0.035016
+0x047B6AC8
+// -0.286617
+0xDB5024F1
+// -0.298417
+0xD9CD7786
+// -0.531623
+0xBBF3C920
+// 0.057286
+0x075527B8
+// 0.103893
+0x0D4C59F6
+// -0.367908
+0xD0E862CF
+// -0.272686
+0xDD18A402
+// 0.562562
+0x48020546
+// -0.114713
+0xF151195F
+// 0.207753
+0x1A97A650
+// 0.049649
+0x065AE900
+// 0.509847
+0x4142A833
+// -0.511966
+0xBE77E5DB
+// -0.065004
+0xF7ADF601
+// -0.430019
+0xC8F51FEE
+// 0.115019
+0x0EB8F35B
+// 0.143063
+0x124FE32A
+// 0.166280
+0x1548A81E
+// 0.382154
+0x30EA695C
+// 0.006188
+0x00CAC82F
+// -0.196839
+0xE6CDF979
+// 0.049517
+0x065696E0
+// 0.003055
+0x00641DBC
+// 0.249166
+0x1FE4AC21
+// 0.041704
+0x05569175
+// -0.424978
+0xC99A5126
+// 0.181267
+0x1733C0B5
+// -0.031113
+0xFC048031
+// 0.203681
+0x1A12349E
+// -0.380801
+0xCF41EC4B
+// -0.137345
+0xEE6B7D19
+// -0.360820
+0xD1D0A6F5
+// 0.205086
+0x1A404368
+// -0.020116
+0xFD6CD8EA
+// 0.103156
+0x0D343B28
+// 0.007530
+0x00F6BBC9
+// -0.193251
+0xE7438FEC
+// -0.122080
+0xF05FAC6F
+// 0.235558
+0x1E26C345
+// -0.250966
+0xDFE05A2E
+// -0.511177
+0xBE91BC74
+// -0.064338
+0xF7C3C194
+// -0.000543
+0xFFEE3225
+// 0.195673
+0x190BD083
+// -0.113341
+0xF17E08E3
+// 0.269201
+0x22752FDC
+// -0.137848
+0xEE5AFF75
+// -0.120188
+0xF09DACEC
+// -0.100120
+0xF32F44D0
+// -0.484846
+0xC1F08E73
+// 0.033251
+0x044193E5
+// 0.224306
+0x1CB60F46
+// -0.292350
+0xDA9444B6
+// 0.035979
+0x049AF56D
+// 0.310583
+0x27C12D2D
+// 0.119179
+0x0F4141F7
+// 0.213090
+0x1B468536
+// -0.271806
+0xDD3578EB
+// -0.339015
+0xD49B2989
+// 0.082683
+0x0A955DCC
+// -0.357286
+0xD24471CE
+// 0.485101
+0x3E17C707
+// 0.379606
+0x3096F127
+// 0.060238
+0x07B5E34D
+// -0.346114
+0xD3B2888C
+// -0.053183
+0xF9314FE6
+// 0.020756
+0x02A8231D
+// 0.442522
+0x38A48D42
+// 0.748197
+0x5FC4EC13
+// 0.480626
+0x3D8528B3
+// 0.489485
+0x3EA774F1
+// -0.129548
+0xEF6AF4F8
+// 0.130972
+0x10C3AE5B
+// 0.117114
+0x0EFD94A6
+// 0.132326
+0x10F00AF7
+// 0.450586
+0x39ACCF58
+// -0.434542
+0xC860E9B7
+// 0.305681
+0x27208D84
+// 0.208810
+0x1ABA47D2
+// -0.084890
+0xF522506B
+// -0.088799
+0xF4A23E56
+// 0.664052
+0x54FFAB73
+// -0.135906
+0xEE9A9EAE
+// 0.863198
+0x6E7D498D
+// 0.097644
+0x0C7F9947
+// -0.235170
+0xE1E5EF9C
+// -0.131533
+0xEF29EE95
+// -0.396498
+0xCD3F8E93
+// 0.231378
+0x1D9DCA12
+// 0.504877
+0x409FD27F
+// -0.161844
+0xEB48B39C
+// -0.230924
+0xE27112A2
+// 0.700053
+0x599B542A
+// 0.148105
+0x12F51C39
+// 0.118860
+0x0F36CAF8
+// -0.485953
+0xC1CC4952
+// -0.497511
+0xC051927F
+// -0.606962
+0xB24F12F5
+// -0.312049
+0xD80EC5A9
+// -0.778831
+0x9C4F4016

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/Input2_q31.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/Input2_q31.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/Input2_q31.txt
new file mode 100644
index 0000000..4f9a45a
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/Input2_q31.txt
@@ -0,0 +1,602 @@
+W
+300
+// 0.133707
+0x111D4BCA
+// 0.012960
+0x01A8A863
+// 0.425272
+0x366F4EA1
+// 0.117470
+0x0F0941CF
+// 0.377878
+0x305E4EE6
+// 0.358723
+0x2DEAA364
+// 0.001974
+0x0040B2BA
+// 0.299351
+0x265122D5
+// 0.680439
+0x57189E77
+// 0.771196
+0x62B68AF8
+// 0.244944
+0x1F5A5398
+// 0.445427
+0x3903BECF
+// 0.583545
+0x4AB19ABB
+// 0.562137
+0x47F41C98
+// 0.071596
+0x092A0BA9
+// 0.080170
+0x0A42FFBB
+// 0.007107
+0x00E8E099
+// 0.019054
+0x02705921
+// 0.003400
+0x006F6713
+// 0.569465
+0x48E43AD9
+// 0.326771
+0x29D3A1BE
+// 0.044893
+0x05BF0A25
+// 0.132821
+0x1100438E
+// 0.020239
+0x02972E7B
+// 0.013752
+0x01C29D7A
+// 0.199107
+0x197C5AAB
+// 0.252421
+0x204F50DD
+// 0.271559
+0x22C27473
+// 0.280644
+0x23EC26E1
+// 0.101220
+0x0CF4C2D3
+// 0.304165
+0x26EEDE86
+// 0.201929
+0x19D8CB1D
+// 0.215848
+0x1BA0E794
+// 0.215221
+0x1B8C5E06
+// 0.212671
+0x1B38CFB8
+// 0.248855
+0x1FDA7CC7
+// 0.483492
+0x3DE314DE
+// 0.376536
+0x30325635
+// 0.582748
+0x4A977E49
+// 0.389886
+0x31E7CBB7
+// 0.336759
+0x2B1AEDEA
+// 0.023154
+0x02F6B35E
+// 0.209803
+0x1ADAD6A4
+// 0.227764
+0x1D2760D4
+// 0.200260
+0x19A21C68
+// 0.028752
+0x03AE28CD
+// 0.389939
+0x31E985E1
+// 0.369922
+0x2F599C35
+// 0.058957
+0x078BE582
+// 0.626009
+0x50211208
+// 0.179207
+0x16F03E7E
+// 0.276137
+0x23587780
+// 0.126228
+0x10284139
+// 0.026574
+0x0366C437
+// 0.259433
+0x2135185B
+// 0.463124
+0x3B47A389
+// 0.400664
+0x3348F84F
+// 0.245048
+0x1F5DB88E
+// 0.421906
+0x3601012F
+// 0.271300
+0x22B9F62F
+// 0.392839
+0x32488E2B
+// 0.431768
+0x37442C7E
+// 0.439444
+0x383FB3D1
+// 0.490046
+0x3EB9D1E9
+// 0.186543
+0x17E0A261
+// 0.129296
+0x108CC746
+// 0.512460
+0x41984AFC
+// 0.105798
+0x0D8AC83B
+// 0.482361
+0x3DBE005B
+// 0.374144
+0x2FE3F053
+// 0.260922
+0x2165E6C2
+// 0.469427
+0x3C162DBB
+// 0.406665
+0x340D9703
+// 0.402744
+0x338D2040
+// 0.076639
+0x09CF5184
+// 0.319045
+0x28D67464
+// 0.003982
+0x00827F8C
+// 0.125242
+0x1007EA4A
+// 0.093592
+0x0BFAD1AF
+// 0.226697
+0x1D04684E
+// 0.096836
+0x0C652281
+// 0.187813
+0x180A4095
+// 0.293981
+0x25A12F2A
+// 0.344888
+0x2C254C2D
+// 0.339078
+0x2B66EA22
+// 0.019017
+0x026F28EA
+// 0.207858
+0x1A9B18AD
+// 0.508916
+0x41242B54
+// 0.454897
+0x3A3A1468
+// 0.366884
+0x2EF60B2E
+// 0.624739
+0x4FF774A2
+// 0.582097
+0x4A8225DB
+// 0.491654
+0x3EEE81F8
+// 0.446182
+0x391C7CF4
+// 0.483548
+0x3DE4EA6F
+// 0.439328
+0x383BE970
+// 0.121541
+0x0F8EA808
+// 0.366670
+0x2EEF0EE7
+// 0.096916
+0x0C67C25D
+// 0.457964
+0x3A9E8C64
+// 0.767914
+0x624B0420
+// 0.325708
+0x29B0CD77
+// 0.009809
+0x01416A59
+// 0.660499
+0x548B3D3C
+// 0.175222
+0x166DB073
+// 0.184339
+0x179867B9
+// 0.134476
+0x11368000
+// 0.169996
+0x15C27068
+// 1.000000
+0x7FFFFFFF
+// 0.062784
+0x080951A0
+// 0.043149
+0x0585E44F
+// 0.267240
+0x2234EAB0
+// 0.483179
+0x3DD8CB86
+// 0.114580
+0x0EAA8F11
+// 0.201280
+0x19C38D59
+// 0.231434
+0x1D9FA1AA
+// 0.084918
+0x0ADE996D
+// 0.256387
+0x20D1482D
+// 0.136994
+0x118902B4
+// 0.553340
+0x46D3D738
+// 0.084429
+0x0ACE9101
+// 0.567616
+0x48A7A2D9
+// 0.014567
+0x01DD5267
+// 0.134477
+0x11368729
+// 0.147947
+0x12EFF06E
+// 0.202231
+0x19E2B28E
+// 0.067696
+0x08AA45BB
+// 0.347254
+0x2C72D3BA
+// 0.062872
+0x080C2F51
+// 0.370798
+0x2F7650CA
+// 0.301777
+0x26A0A168
+// 0.465668
+0x3B9AFEB9
+// 0.213807
+0x1B5E0A81
+// 0.394411
+0x327C0C8A
+// 0.165901
+0x153C3EFB
+// 0.032147
+0x041D66A6
+// 0.149990
+0x1332DEB7
+// 0.166428
+0x154D80B7
+// 0.310341
+0x27B94054
+// 0.209825
+0x1ADB8B3B
+// 0.354971
+0x2D6FACF9
+// 0.274670
+0x232862A5
+// 0.166133
+0x1543D9E0
+// 0.340461
+0x2B9438EA
+// 0.491813
+0x3EF3BE99
+// 0.034670
+0x04700D2A
+// 0.318471
+0x28C3A511
+// 0.179105
+0x16ECED0D
+// 0.149563
+0x1324E41C
+// 0.206144
+0x1A62EC1D
+// 0.000726
+0x0017CCF3
+// 0.099990
+0x0CCC785F
+// 0.242725
+0x1F119B4E
+// 0.051678
+0x069D64F5
+// 0.580703
+0x4A547845
+// 0.596671
+0x4C5FB978
+// 0.236500
+0x1E45A0ED
+// 0.514924
+0x41E90535
+// 0.006100
+0x00C7E054
+// 0.559561
+0x479FB0F9
+// 0.181766
+0x17441F4B
+// 0.251482
+0x20308E55
+// 0.569042
+0x48D65DFC
+// 0.049916
+0x0663A9C7
+// 0.213747
+0x1B5C1265
+// 0.380503
+0x30B45457
+// 0.323724
+0x296FCCB1
+// 0.356887
+0x2DAE75EF
+// 0.150006
+0x13336219
+// 0.096157
+0x0C4EE2EC
+// 0.530617
+0x43EB40DE
+// 0.694865
+0x58F15800
+// 0.136154
+0x116D7EE6
+// 0.223343
+0x1C9683A9
+// 0.063014
+0x0810D8BB
+// 0.013625
+0x01BE7776
+// 0.130900
+0x10C15471
+// 0.343172
+0x2BED0BE3
+// 0.002483
+0x005158E1
+// 0.330680
+0x2A53B692
+// 0.301763
+0x26A02755
+// 0.147323
+0x12DB7979
+// 0.265874
+0x22082B75
+// 0.069565
+0x08E782A2
+// 0.149783
+0x132C1A26
+// 0.130641
+0x10B8D8E5
+// 0.090081
+0x0B87C73B
+// 0.621401
+0x4F8A0F5E
+// 0.075357
+0x09A54FB4
+// 0.231423
+0x1D9F42DA
+// 0.477995
+0x3D2EF3F3
+// 0.223126
+0x1C8F6158
+// 0.280653
+0x23EC7361
+// 0.008641
+0x011B2641
+// 0.197468
+0x1946A35A
+// 0.400394
+0x33401948
+// 0.262543
+0x219B0007
+// 0.439370
+0x383D4742
+// 0.039081
+0x05009CD2
+// 0.035016
+0x047B6AC8
+// 0.286617
+0x24AFDB0F
+// 0.298417
+0x2632887A
+// 0.531623
+0x440C36E0
+// 0.057286
+0x075527B8
+// 0.103893
+0x0D4C59F6
+// 0.367908
+0x2F179D31
+// 0.272686
+0x22E75BFE
+// 0.562562
+0x48020546
+// 0.114713
+0x0EAEE6A1
+// 0.207753
+0x1A97A650
+// 0.049649
+0x065AE900
+// 0.509847
+0x4142A833
+// 0.511966
+0x41881A25
+// 0.065004
+0x085209FF
+// 0.430019
+0x370AE012
+// 0.115019
+0x0EB8F35B
+// 0.143063
+0x124FE32A
+// 0.166280
+0x1548A81E
+// 0.382154
+0x30EA695C
+// 0.006188
+0x00CAC82F
+// 0.196839
+0x19320687
+// 0.049517
+0x065696E0
+// 0.003055
+0x00641DBC
+// 0.249166
+0x1FE4AC21
+// 0.041704
+0x05569175
+// 0.424978
+0x3665AEDA
+// 0.181267
+0x1733C0B5
+// 0.031113
+0x03FB7FCF
+// 0.203681
+0x1A12349E
+// 0.380801
+0x30BE13B5
+// 0.137345
+0x119482E7
+// 0.360820
+0x2E2F590B
+// 0.205086
+0x1A404368
+// 0.020116
+0x02932716
+// 0.103156
+0x0D343B28
+// 0.007530
+0x00F6BBC9
+// 0.193251
+0x18BC7014
+// 0.122080
+0x0FA05391
+// 0.235558
+0x1E26C345
+// 0.250966
+0x201FA5D2
+// 0.511177
+0x416E438C
+// 0.064338
+0x083C3E6C
+// 0.000543
+0x0011CDDB
+// 0.195673
+0x190BD083
+// 0.113341
+0x0E81F71D
+// 0.269201
+0x22752FDC
+// 0.137848
+0x11A5008B
+// 0.120188
+0x0F625314
+// 0.100120
+0x0CD0BB30
+// 0.484846
+0x3E0F718D
+// 0.033251
+0x044193E5
+// 0.224306
+0x1CB60F46
+// 0.292350
+0x256BBB4A
+// 0.035979
+0x049AF56D
+// 0.310583
+0x27C12D2D
+// 0.119179
+0x0F4141F7
+// 0.213090
+0x1B468536
+// 0.271806
+0x22CA8715
+// 0.339015
+0x2B64D677
+// 0.082683
+0x0A955DCC
+// 0.357286
+0x2DBB8E32
+// 0.485101
+0x3E17C707
+// 0.379606
+0x3096F127
+// 0.060238
+0x07B5E34D
+// 0.346114
+0x2C4D7774
+// 0.053183
+0x06CEB01A
+// 0.020756
+0x02A8231D
+// 0.442522
+0x38A48D42
+// 0.748197
+0x5FC4EC13
+// 0.480626
+0x3D8528B3
+// 0.489485
+0x3EA774F1
+// 0.129548
+0x10950B08
+// 0.130972
+0x10C3AE5B
+// 0.117114
+0x0EFD94A6
+// 0.132326
+0x10F00AF7
+// 0.450586
+0x39ACCF58
+// 0.434542
+0x379F1649
+// 0.305681
+0x27208D84
+// 0.208810
+0x1ABA47D2
+// 0.084890
+0x0ADDAF95
+// 0.088799
+0x0B5DC1AA
+// 0.664052
+0x54FFAB73
+// 0.135906
+0x11656152
+// 0.863198
+0x6E7D498D
+// 0.097644
+0x0C7F9947
+// 0.235170
+0x1E1A1064
+// 0.131533
+0x10D6116B
+// 0.396498
+0x32C0716D
+// 0.231378
+0x1D9DCA12
+// 0.504877
+0x409FD27F
+// 0.161844
+0x14B74C64
+// 0.230924
+0x1D8EED5E
+// 0.700053
+0x599B542A
+// 0.148105
+0x12F51C39
+// 0.118860
+0x0F36CAF8
+// 0.485953
+0x3E33B6AE
+// 0.497511
+0x3FAE6D81
+// 0.606962
+0x4DB0ED0B
+// 0.312049
+0x27F13A57
+// 0.778831
+0x63B0BFEA

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MaxIndexes1_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MaxIndexes1_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MaxIndexes1_s16.txt
new file mode 100644
index 0000000..7519b49
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MaxIndexes1_s16.txt
@@ -0,0 +1,8 @@
+H
+3
+// 2
+0x0002
+// 2
+0x0002
+// 8
+0x0008

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MaxVals1_q31.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MaxVals1_q31.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MaxVals1_q31.txt
new file mode 100644
index 0000000..93d3865
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MaxVals1_q31.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.425272
+0x366F4EA1
+// 0.425272
+0x366F4EA1
+// 0.680439
+0x57189E77

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MeanVals2_q31.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MeanVals2_q31.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MeanVals2_q31.txt
new file mode 100644
index 0000000..7ea6672
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MeanVals2_q31.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.190646
+0x18671645
+// 0.215917
+0x1BA3298F
+// 0.267530
+0x223E6F70

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MinIndexes3_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MinIndexes3_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MinIndexes3_s16.txt
new file mode 100644
index 0000000..0ad295f
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MinIndexes3_s16.txt
@@ -0,0 +1,8 @@
+H
+3
+// 1
+0x0001
+// 5
+0x0005
+// 5
+0x0005

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MinVals3_q31.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MinVals3_q31.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MinVals3_q31.txt
new file mode 100644
index 0000000..7e74ffc
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/MinVals3_q31.txt
@@ -0,0 +1,8 @@
+W
+3
+// -0.012960
+0xFE57579D
+// -0.358723
+0xD2155C9C
+// -0.358723
+0xD2155C9C

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/PowerVals4_q63.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/PowerVals4_q63.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/PowerVals4_q63.txt
new file mode 100644
index 0000000..efe467f
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/PowerVals4_q63.txt
@@ -0,0 +1,8 @@
+D
+3
+// 0.000006
+0x000032EB35AAC1E6
+// 0.000018
+0x000092E3E2CC13E8
+// 0.000032
+0x0001096ADB187C51

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/RmsVals5_q31.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/RmsVals5_q31.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/RmsVals5_q31.txt
new file mode 100644
index 0000000..9a6cf51
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/RmsVals5_q31.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.257489
+0x20F564FA
+// 0.267813
+0x2247B0FB
+// 0.339409
+0x2B71C1C3

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/StdVals6_q31.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/StdVals6_q31.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/StdVals6_q31.txt
new file mode 100644
index 0000000..8930a68
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/StdVals6_q31.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.223072
+0x1C8DA386
+// 0.268434
+0x225C094B
+// 0.318394
+0x28C12168

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/VarVals7_q31.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/VarVals7_q31.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/VarVals7_q31.txt
new file mode 100644
index 0000000..5070d7f
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ31/VarVals7_q31.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.049761
+0x065E9446
+// 0.072057
+0x0939271D
+// 0.101375
+0x0CF9D848

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/Input1_q7.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/Input1_q7.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/Input1_q7.txt
new file mode 100644
index 0000000..5d2916b
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/Input1_q7.txt
@@ -0,0 +1,602 @@
+B
+300
+// 0.336472
+0x2B
+// -0.037057
+0xFB
+// 0.550861
+0x47
+// 0.584122
+0x4B
+// 0.025721
+0x03
+// -0.202634
+0xE6
+// -0.324190
+0xD7
+// -0.133293
+0xEF
+// -0.483606
+0xC2
+// -0.220489
+0xE4
+// -0.176548
+0xE9
+// -0.326102
+0xD6
+// -0.325763
+0xD6
+// -0.552751
+0xB9
+// -0.664052
+0xAB
+// 0.114834
+0x0F
+// -0.271745
+0xDD
+// 0.091618
+0x0C
+// -0.297587
+0xDA
+// 0.424934
+0x36
+// -0.702548
+0xA6
+// 0.007353
+0x01
+// -0.809123
+0x98
+// -0.066633
+0xF7
+// 0.309378
+0x28
+// 0.516153
+0x42
+// -0.075236
+0xF6
+// 0.469042
+0x3C
+// -0.073283
+0xF7
+// 0.608858
+0x4E
+// 0.444352
+0x39
+// 0.328469
+0x2A
+// -0.395310
+0xCD
+// -0.219891
+0xE4
+// 0.798952
+0x66
+// 0.028930
+0x04
+// -0.285188
+0xDB
+// 0.422101
+0x36
+// 0.079473
+0x0A
+// 0.010508
+0x01
+// 0.353825
+0x2D
+// 0.144078
+0x12
+// -0.031591
+0xFC
+// -0.121744
+0xF0
+// 0.001137
+0x00
+// 0.127015
+0x10
+// -0.177443
+0xE9
+// 0.999251
+0x7F
+// -0.084107
+0xF5
+// 0.104454
+0x0D
+// 0.095199
+0x0C
+// -0.758359
+0x9F
+// -0.315312
+0xD8
+// -0.473112
+0xC3
+// -0.511980
+0xBE
+// -0.216556
+0xE4
+// -0.081755
+0xF6
+// 0.286713
+0x25
+// 0.391452
+0x32
+// -0.327931
+0xD6
+// -0.130929
+0xEF
+// 0.355871
+0x2E
+// 0.622184
+0x50
+// -0.106957
+0xF2
+// -0.018423
+0xFE
+// 0.230594
+0x1E
+// 0.118188
+0x0F
+// -0.066469
+0xF7
+// -0.420372
+0xCA
+// -0.284430
+0xDC
+// 0.120798
+0x0F
+// -0.060584
+0xF8
+// 0.079495
+0x0A
+// 0.121367
+0x10
+// 0.472706
+0x3D
+// 0.242415
+0x1F
+// 0.035127
+0x04
+// 0.208263
+0x1B
+// 0.214276
+0x1B
+// 0.035605
+0x05
+// -0.130301
+0xEF
+// 0.060339
+0x08
+// -0.658375
+0xAC
+// 0.010486
+0x01
+// -0.021068
+0xFD
+// -0.406017
+0xCC
+// 0.187026
+0x18
+// 0.230990
+0x1E
+// -0.022368
+0xFD
+// -0.545160
+0xBA
+// -0.921352
+0x8A
+// 0.600801
+0x4D
+// -0.204663
+0xE6
+// 0.626339
+0x50
+// -0.923039
+0x8A
+// -0.318908
+0xD7
+// -0.190401
+0xE8
+// 0.517927
+0x42
+// -0.056022
+0xF9
+// 0.318837
+0x29
+// -0.294974
+0xDA
+// -0.163401
+0xEB
+// 0.653063
+0x54
+// -0.212631
+0xE5
+// -0.293357
+0xDA
+// -0.230299
+0xE3
+// -0.606099
+0xB2
+// 0.127240
+0x10
+// 0.320227
+0x29
+// -0.317252
+0xD7
+// 0.363632
+0x2F
+// 0.002922
+0x00
+// -0.219795
+0xE4
+// -0.504394
+0xBF
+// 0.387324
+0x32
+// 0.864405
+0x6F
+// 0.455149
+0x3A
+// -0.275463
+0xDD
+// -0.847907
+0x93
+// 0.283441
+0x24
+// 0.003484
+0x00
+// -0.227787
+0xE3
+// -0.575060
+0xB6
+// 0.402490
+0x34
+// 0.023542
+0x03
+// 0.407167
+0x34
+// 0.336904
+0x2B
+// -0.557382
+0xB9
+// -0.084205
+0xF5
+// -0.228951
+0xE3
+// -0.025058
+0xFD
+// 0.179602
+0x17
+// -0.300949
+0xD9
+// 0.284894
+0x24
+// 1.000000
+0x7F
+// -0.017732
+0xFE
+// -0.409844
+0xCC
+// 0.070211
+0x09
+// -0.250999
+0xE0
+// -0.667980
+0xAA
+// 0.266442
+0x22
+// -0.430611
+0xC9
+// 0.773349
+0x63
+// -0.907582
+0x8C
+// -0.492479
+0xC1
+// 0.007743
+0x01
+// 0.149391
+0x13
+// 0.136825
+0x12
+// 0.445364
+0x39
+// -0.044592
+0xFA
+// 0.049261
+0x06
+// -0.398502
+0xCD
+// -0.144035
+0xEE
+// -0.001349
+0x00
+// -0.319786
+0xD7
+// -0.021230
+0xFD
+// 0.121220
+0x10
+// -0.147020
+0xED
+// 0.113334
+0x0F
+// 0.405765
+0x34
+// 0.103759
+0x0D
+// -0.105568
+0xF2
+// 0.227935
+0x1D
+// -1.066898
+0x80
+// -0.336402
+0xD5
+// -0.113244
+0xF2
+// 0.029219
+0x04
+// 0.509314
+0x41
+// -0.348557
+0xD3
+// -0.347828
+0xD3
+// 0.115661
+0x0F
+// 0.773868
+0x63
+// -0.027216
+0xFD
+// -0.457371
+0xC5
+// -0.039623
+0xFB
+// -0.228398
+0xE3
+// 0.246623
+0x20
+// 0.345102
+0x2C
+// 0.133288
+0x11
+// 0.213991
+0x1B
+// 0.023420
+0x03
+// -0.041398
+0xFB
+// -0.395589
+0xCD
+// 0.253309
+0x20
+// 0.112427
+0x0E
+// 0.394471
+0x32
+// 0.489624
+0x3F
+// 0.114581
+0x0F
+// 0.438264
+0x38
+// -0.055468
+0xF9
+// -0.272346
+0xDD
+// -0.119650
+0xF1
+// -0.082784
+0xF5
+// 0.401743
+0x33
+// -0.334639
+0xD5
+// 0.241669
+0x1F
+// -0.117850
+0xF1
+// -0.584923
+0xB5
+// 0.708233
+0x5B
+// -0.312848
+0xD8
+// 0.247822
+0x20
+// 0.321773
+0x29
+// -0.239804
+0xE1
+// -0.028447
+0xFC
+// -0.301590
+0xD9
+// 0.344852
+0x2C
+// 0.033323
+0x04
+// 0.438149
+0x38
+// 0.430245
+0x37
+// -0.445573
+0xC7
+// -0.266990
+0xDE
+// -0.023293
+0xFD
+// -0.555797
+0xB9
+// -0.173726
+0xEA
+// 0.046546
+0x06
+// 0.425950
+0x37
+// -0.531803
+0xBC
+// 0.362571
+0x2E
+// 0.512596
+0x42
+// -0.140679
+0xEE
+// -0.150299
+0xED
+// 0.166288
+0x15
+// 0.240719
+0x1F
+// -0.244234
+0xE1
+// -0.447730
+0xC7
+// -0.393510
+0xCE
+// 0.185880
+0x18
+// -0.386214
+0xCF
+// 0.348356
+0x2D
+// 0.057093
+0x07
+// -0.014210
+0xFE
+// -0.244661
+0xE1
+// 0.845345
+0x6C
+// 0.337321
+0x2B
+// 0.093928
+0x0C
+// -0.124593
+0xF0
+// -0.602422
+0xB3
+// 0.023643
+0x03
+// -0.124738
+0xF0
+// 0.431289
+0x37
+// 0.000157
+0x00
+// 0.309913
+0x28
+// -0.467329
+0xC4
+// -0.161538
+0xEB
+// -0.459892
+0xC5
+// 0.493975
+0x3F
+// -0.322709
+0xD7
+// 0.069546
+0x09
+// 0.562275
+0x48
+// -0.000547
+0x00
+// 0.063678
+0x08
+// -0.105082
+0xF3
+// 0.564432
+0x48
+// -0.218411
+0xE4
+// -0.650695
+0xAD
+// -0.032108
+0xFC
+// 0.072486
+0x09
+// 0.184277
+0x18
+// 0.692647
+0x59
+// -0.168405
+0xEA
+// 0.486680
+0x3E
+// 0.040659
+0x05
+// 0.412130
+0x35
+// 0.382047
+0x31
+// 0.546859
+0x46
+// 0.841747
+0x6C
+// -0.443951
+0xC7
+// 0.309924
+0x28
+// -0.032063
+0xFC
+// 0.196718
+0x19
+// 0.201013
+0x1A
+// 0.263203
+0x22
+// 0.895849
+0x73
+// 0.690541
+0x58
+// 0.081494
+0x0A
+// 0.052140
+0x07
+// -0.414259
+0xCB
+// -0.842474
+0x94
+// -0.690523
+0xA8
+// 0.256964
+0x21
+// -0.201897
+0xE6
+// 0.489058
+0x3F
+// -0.449845
+0xC6
+// 0.394458
+0x32
+// -0.107447
+0xF2
+// 0.585009
+0x4B
+// -0.239076
+0xE1
+// 0.024958
+0x03
+// 0.294220
+0x26
+// 0.410169
+0x35
+// -0.206047
+0xE6
+// 0.210445
+0x1B
+// -0.376485
+0xD0
+// 0.185220
+0x18
+// -0.118481
+0xF1
+// 0.308553
+0x27
+// -0.078522
+0xF6
+// 0.435731
+0x38
+// -0.702359
+0xA6
+// -0.157499
+0xEC

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/Input2_q7.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/Input2_q7.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/Input2_q7.txt
new file mode 100644
index 0000000..d1be699
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/Input2_q7.txt
@@ -0,0 +1,602 @@
+B
+300
+// 0.336472
+0x2B
+// 0.037057
+0x05
+// 0.550861
+0x47
+// 0.584122
+0x4B
+// 0.025721
+0x03
+// 0.202634
+0x1A
+// 0.324190
+0x29
+// 0.133293
+0x11
+// 0.483606
+0x3E
+// 0.220489
+0x1C
+// 0.176548
+0x17
+// 0.326102
+0x2A
+// 0.325763
+0x2A
+// 0.552751
+0x47
+// 0.664052
+0x55
+// 0.114834
+0x0F
+// 0.271745
+0x23
+// 0.091618
+0x0C
+// 0.297587
+0x26
+// 0.424934
+0x36
+// 0.702548
+0x5A
+// 0.007353
+0x01
+// 0.809123
+0x68
+// 0.066633
+0x09
+// 0.309378
+0x28
+// 0.516153
+0x42
+// 0.075236
+0x0A
+// 0.469042
+0x3C
+// 0.073283
+0x09
+// 0.608858
+0x4E
+// 0.444352
+0x39
+// 0.328469
+0x2A
+// 0.395310
+0x33
+// 0.219891
+0x1C
+// 0.798952
+0x66
+// 0.028930
+0x04
+// 0.285188
+0x25
+// 0.422101
+0x36
+// 0.079473
+0x0A
+// 0.010508
+0x01
+// 0.353825
+0x2D
+// 0.144078
+0x12
+// 0.031591
+0x04
+// 0.121744
+0x10
+// 0.001137
+0x00
+// 0.127015
+0x10
+// 0.177443
+0x17
+// 0.999251
+0x7F
+// 0.084107
+0x0B
+// 0.104454
+0x0D
+// 0.095199
+0x0C
+// 0.758359
+0x61
+// 0.315312
+0x28
+// 0.473112
+0x3D
+// 0.511980
+0x42
+// 0.216556
+0x1C
+// 0.081755
+0x0A
+// 0.286713
+0x25
+// 0.391452
+0x32
+// 0.327931
+0x2A
+// 0.130929
+0x11
+// 0.355871
+0x2E
+// 0.622184
+0x50
+// 0.106957
+0x0E
+// 0.018423
+0x02
+// 0.230594
+0x1E
+// 0.118188
+0x0F
+// 0.066469
+0x09
+// 0.420372
+0x36
+// 0.284430
+0x24
+// 0.120798
+0x0F
+// 0.060584
+0x08
+// 0.079495
+0x0A
+// 0.121367
+0x10
+// 0.472706
+0x3D
+// 0.242415
+0x1F
+// 0.035127
+0x04
+// 0.208263
+0x1B
+// 0.214276
+0x1B
+// 0.035605
+0x05
+// 0.130301
+0x11
+// 0.060339
+0x08
+// 0.658375
+0x54
+// 0.010486
+0x01
+// 0.021068
+0x03
+// 0.406017
+0x34
+// 0.187026
+0x18
+// 0.230990
+0x1E
+// 0.022368
+0x03
+// 0.545160
+0x46
+// 0.921352
+0x76
+// 0.600801
+0x4D
+// 0.204663
+0x1A
+// 0.626339
+0x50
+// 0.923039
+0x76
+// 0.318908
+0x29
+// 0.190401
+0x18
+// 0.517927
+0x42
+// 0.056022
+0x07
+// 0.318837
+0x29
+// 0.294974
+0x26
+// 0.163401
+0x15
+// 0.653063
+0x54
+// 0.212631
+0x1B
+// 0.293357
+0x26
+// 0.230299
+0x1D
+// 0.606099
+0x4E
+// 0.127240
+0x10
+// 0.320227
+0x29
+// 0.317252
+0x29
+// 0.363632
+0x2F
+// 0.002922
+0x00
+// 0.219795
+0x1C
+// 0.504394
+0x41
+// 0.387324
+0x32
+// 0.864405
+0x6F
+// 0.455149
+0x3A
+// 0.275463
+0x23
+// 0.847907
+0x6D
+// 0.283441
+0x24
+// 0.003484
+0x00
+// 0.227787
+0x1D
+// 0.575060
+0x4A
+// 0.402490
+0x34
+// 0.023542
+0x03
+// 0.407167
+0x34
+// 0.336904
+0x2B
+// 0.557382
+0x47
+// 0.084205
+0x0B
+// 0.228951
+0x1D
+// 0.025058
+0x03
+// 0.179602
+0x17
+// 0.300949
+0x27
+// 0.284894
+0x24
+// 1.000000
+0x7F
+// 0.017732
+0x02
+// 0.409844
+0x34
+// 0.070211
+0x09
+// 0.250999
+0x20
+// 0.667980
+0x56
+// 0.266442
+0x22
+// 0.430611
+0x37
+// 0.773349
+0x63
+// 0.907582
+0x74
+// 0.492479
+0x3F
+// 0.007743
+0x01
+// 0.149391
+0x13
+// 0.136825
+0x12
+// 0.445364
+0x39
+// 0.044592
+0x06
+// 0.049261
+0x06
+// 0.398502
+0x33
+// 0.144035
+0x12
+// 0.001349
+0x00
+// 0.319786
+0x29
+// 0.021230
+0x03
+// 0.121220
+0x10
+// 0.147020
+0x13
+// 0.113334
+0x0F
+// 0.405765
+0x34
+// 0.103759
+0x0D
+// 0.105568
+0x0E
+// 0.227935
+0x1D
+// 1.066898
+0x7F
+// 0.336402
+0x2B
+// 0.113244
+0x0E
+// 0.029219
+0x04
+// 0.509314
+0x41
+// 0.348557
+0x2D
+// 0.347828
+0x2D
+// 0.115661
+0x0F
+// 0.773868
+0x63
+// 0.027216
+0x03
+// 0.457371
+0x3B
+// 0.039623
+0x05
+// 0.228398
+0x1D
+// 0.246623
+0x20
+// 0.345102
+0x2C
+// 0.133288
+0x11
+// 0.213991
+0x1B
+// 0.023420
+0x03
+// 0.041398
+0x05
+// 0.395589
+0x33
+// 0.253309
+0x20
+// 0.112427
+0x0E
+// 0.394471
+0x32
+// 0.489624
+0x3F
+// 0.114581
+0x0F
+// 0.438264
+0x38
+// 0.055468
+0x07
+// 0.272346
+0x23
+// 0.119650
+0x0F
+// 0.082784
+0x0B
+// 0.401743
+0x33
+// 0.334639
+0x2B
+// 0.241669
+0x1F
+// 0.117850
+0x0F
+// 0.584923
+0x4B
+// 0.708233
+0x5B
+// 0.312848
+0x28
+// 0.247822
+0x20
+// 0.321773
+0x29
+// 0.239804
+0x1F
+// 0.028447
+0x04
+// 0.301590
+0x27
+// 0.344852
+0x2C
+// 0.033323
+0x04
+// 0.438149
+0x38
+// 0.430245
+0x37
+// 0.445573
+0x39
+// 0.266990
+0x22
+// 0.023293
+0x03
+// 0.555797
+0x47
+// 0.173726
+0x16
+// 0.046546
+0x06
+// 0.425950
+0x37
+// 0.531803
+0x44
+// 0.362571
+0x2E
+// 0.512596
+0x42
+// 0.140679
+0x12
+// 0.150299
+0x13
+// 0.166288
+0x15
+// 0.240719
+0x1F
+// 0.244234
+0x1F
+// 0.447730
+0x39
+// 0.393510
+0x32
+// 0.185880
+0x18
+// 0.386214
+0x31
+// 0.348356
+0x2D
+// 0.057093
+0x07
+// 0.014210
+0x02
+// 0.244661
+0x1F
+// 0.845345
+0x6C
+// 0.337321
+0x2B
+// 0.093928
+0x0C
+// 0.124593
+0x10
+// 0.602422
+0x4D
+// 0.023643
+0x03
+// 0.124738
+0x10
+// 0.431289
+0x37
+// 0.000157
+0x00
+// 0.309913
+0x28
+// 0.467329
+0x3C
+// 0.161538
+0x15
+// 0.459892
+0x3B
+// 0.493975
+0x3F
+// 0.322709
+0x29
+// 0.069546
+0x09
+// 0.562275
+0x48
+// 0.000547
+0x00
+// 0.063678
+0x08
+// 0.105082
+0x0D
+// 0.564432
+0x48
+// 0.218411
+0x1C
+// 0.650695
+0x53
+// 0.032108
+0x04
+// 0.072486
+0x09
+// 0.184277
+0x18
+// 0.692647
+0x59
+// 0.168405
+0x16
+// 0.486680
+0x3E
+// 0.040659
+0x05
+// 0.412130
+0x35
+// 0.382047
+0x31
+// 0.546859
+0x46
+// 0.841747
+0x6C
+// 0.443951
+0x39
+// 0.309924
+0x28
+// 0.032063
+0x04
+// 0.196718
+0x19
+// 0.201013
+0x1A
+// 0.263203
+0x22
+// 0.895849
+0x73
+// 0.690541
+0x58
+// 0.081494
+0x0A
+// 0.052140
+0x07
+// 0.414259
+0x35
+// 0.842474
+0x6C
+// 0.690523
+0x58
+// 0.256964
+0x21
+// 0.201897
+0x1A
+// 0.489058
+0x3F
+// 0.449845
+0x3A
+// 0.394458
+0x32
+// 0.107447
+0x0E
+// 0.585009
+0x4B
+// 0.239076
+0x1F
+// 0.024958
+0x03
+// 0.294220
+0x26
+// 0.410169
+0x35
+// 0.206047
+0x1A
+// 0.210445
+0x1B
+// 0.376485
+0x30
+// 0.185220
+0x18
+// 0.118481
+0x0F
+// 0.308553
+0x27
+// 0.078522
+0x0A
+// 0.435731
+0x38
+// 0.702359
+0x5A
+// 0.157499
+0x14

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/InputMaxIndexMax1_q7.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/InputMaxIndexMax1_q7.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/InputMaxIndexMax1_q7.txt
new file mode 100644
index 0000000..8b99527
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/InputMaxIndexMax1_q7.txt
@@ -0,0 +1,562 @@
+B
+280
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.000000
+0x00
+// 0.800000
+0x66
+// 0.900000
+0x73

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/InputMinIndexMax3_q7.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/InputMinIndexMax3_q7.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/InputMinIndexMax3_q7.txt
new file mode 100644
index 0000000..05d9caa
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/InputMinIndexMax3_q7.txt
@@ -0,0 +1,562 @@
+B
+280
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.900000
+0x73
+// 0.100000
+0x0D
+// 0.000000
+0x00

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MaxIndexes1_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MaxIndexes1_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MaxIndexes1_s16.txt
new file mode 100644
index 0000000..c553090
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MaxIndexes1_s16.txt
@@ -0,0 +1,10 @@
+H
+4
+// 3
+0x0003
+// 29
+0x001D
+// 29
+0x001D
+// 279
+0x0117

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MaxVals1_q7.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MaxVals1_q7.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MaxVals1_q7.txt
new file mode 100644
index 0000000..036b0d8
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MaxVals1_q7.txt
@@ -0,0 +1,10 @@
+B
+4
+// 0.584122
+0x4B
+// 0.608858
+0x4E
+// 0.608858
+0x4E
+// 0.900000
+0x73

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MeanVals2_q7.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MeanVals2_q7.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MeanVals2_q7.txt
new file mode 100644
index 0000000..dadfdc2
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MeanVals2_q7.txt
@@ -0,0 +1,8 @@
+B
+3
+// 0.329577
+0x2A
+// 0.329838
+0x2A
+// 0.331822
+0x2A

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MinIndexes3_s16.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MinIndexes3_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MinIndexes3_s16.txt
new file mode 100644
index 0000000..fcb37c0
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MinIndexes3_s16.txt
@@ -0,0 +1,10 @@
+H
+4
+// 14
+0x000E
+// 22
+0x0016
+// 22
+0x0016
+// 279
+0x0117

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MinVals3_q7.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MinVals3_q7.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MinVals3_q7.txt
new file mode 100644
index 0000000..e2f8435
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/MinVals3_q7.txt
@@ -0,0 +1,10 @@
+B
+4
+// -0.664052
+0xAB
+// -0.809123
+0x98
+// -0.809123
+0x98
+// 0.000000
+0x00

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/PowerVals4_q31.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/PowerVals4_q31.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/PowerVals4_q31.txt
new file mode 100644
index 0000000..7c5ed02
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/PowerVals4_q31.txt
@@ -0,0 +1,8 @@
+W
+3
+// 0.000017
+0x00008C93
+// 0.000038
+0x00013EE9
+// 0.000039
+0x000148E9

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/RmsVals5_q7.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/RmsVals5_q7.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/RmsVals5_q7.txt
new file mode 100644
index 0000000..d096868
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/RmsVals5_q7.txt
@@ -0,0 +1,8 @@
+B
+3
+// 0.382661
+0x31
+// 0.394610
+0x33
+// 0.394631
+0x33

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/StdVals6_q7.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/StdVals6_q7.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/StdVals6_q7.txt
new file mode 100644
index 0000000..413cd23
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/StdVals6_q7.txt
@@ -0,0 +1,8 @@
+B
+3
+// 0.372551
+0x30
+// 0.399834
+0x33
+// 0.398668
+0x33

CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/VarVals7_q7.txt

diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/VarVals7_q7.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/VarVals7_q7.txt
new file mode 100644
index 0000000..90050bc
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsQ7/VarVals7_q7.txt
@@ -0,0 +1,8 @@
+B
+3
+// 0.138794
+0x12
+// 0.159868
+0x14
+// 0.158936
+0x14

CMSIS/DSP/Testing/README.md

diff --git a/CMSIS/DSP/Testing/README.md b/CMSIS/DSP/Testing/README.md
index 803f2a8..e36f282 100644
--- a/CMSIS/DSP/Testing/README.md
+++ b/CMSIS/DSP/Testing/README.md
@@ -313,16 +313,30 @@
 
 ### Generate the cpp,h and txt files from the desc.txt file
 
+
     cd ..
-    python processTests.py -f desc.txt
+
+    python preprocess.py -f desc.txt 
+
+This will create a file Output.pickle which is containing a Python object representing
+the parsed data structure. It is done because parsing a big test descriptino file is quite slow.
+
+So, it is only done once.
+
+    python processTests.py -f Output.pickle
+
+or just
+
+    python processTests.py
+
 
 You can pass a C++ class to specifiy that you want to generate tests only for a specific group or suite.
 
-    python processTests.py -f desc.txt BasicTests
+    python processTests.py BasicTests
 
 You can add a test ID to specify that you wan to run only a specific test in the suite:
 
-    python processTests.py -f desc.txt BasicTests 4
+    python processTests.py BasicTests 4
 
 First time this script is run, it is expecting some folder and some headers.
 To create the folder, the script createDefaultFolder.sh can be used.
@@ -343,18 +357,22 @@
 ### Parse the results
 
     cd ..
-    python processResult.py -f desc.txt -r build\result.txt
+    python processResult.py -r build\result.txt
 
 -e option is needed if the mode -e was used with processTests because the output has a different
 format with or without -e option.
 
+It is also using the Output.pickle file by default for the test description.
+
 ### Generate summary statistics
 
 The result parsing may have generated some statistics in FullBenchmark folder.
 
 The script summaryBench can parse those results and compute regression formula.
 
-    python summaryBench.py -f desc.txt -r build\result.txt
+    python summaryBench.py -r build\result.txt
+
+The Output.pickle file is used by default. It can be changed with -f option.
 
 The output of this script may look like:
 
@@ -369,13 +387,15 @@
 To convert some benchmark to an older format.
 The PARAMS must be compatible between all suites which are children of AGroup
 
-    python convertToOld.py -f desc.txt -e AGroup
+    python convertToOld.py -e AGroup
 
+Output.pickle is used by default. It can be changed with -f option.
 
 To add a to sqlite3 databse:
 
-    python addToDB.py -f desc.txt -e AGroup
+    python addToDB.py -e AGroup
 
+Output.pickle is used by default. It can be changed with -f option.
 
 The database must be created with createDb.sql before this script can be used.
 
@@ -538,7 +558,9 @@
 
 To add a to sqlite3 databse:
 
-    python addToDB.py -f desc.txt AGroup
+    python addToDB.py AGroup
+
+Output.pickle is used by default. It can be changed with -f option.
 
 AGroup should be the class name of a Group in the desc.txt
 
@@ -551,13 +573,15 @@
 
 If you use:
 
-    python addToDB.py -f desc.txt BasicBenchmarks
+    python addToDB.py BasicBenchmarks
+
+Output.pickle is used by default. It can be changed with -f option.
 
 A table BasicBenchmarks will be create and the benchmarks result for F32, Q31, Q15 and Q7 will be added to this table.
 
 But, if you do:
 
-    python addToDB.py -f desc.txt BasicMathsBenchmarksF32
+    python addToDB.py BasicMathsBenchmarksF32
 
 The a table BasicMathsBenchmarksF32 will be created which is probably not what you want since the table is containing a type column (f32,q31, q15, q7)
 

CMSIS/DSP/Testing/Source/Tests/StatsTestsF32.cpp

diff --git a/CMSIS/DSP/Testing/Source/Tests/StatsTestsF32.cpp b/CMSIS/DSP/Testing/Source/Tests/StatsTestsF32.cpp
index d848be7..da53704 100755
--- a/CMSIS/DSP/Testing/Source/Tests/StatsTestsF32.cpp
+++ b/CMSIS/DSP/Testing/Source/Tests/StatsTestsF32.cpp
@@ -5,6 +5,176 @@
 
 #include <cstdio>
 
+#define SNR_THRESHOLD 120
+/* 
+
+Reference patterns are generated with
+a double precision computation.
+
+*/
+#define REL_ERROR (1.0e-6)
+
+    void StatsTestsF32::test_max_f32()
+    {
+        const float32_t *inp  = inputA.ptr();
+
+        float32_t result;
+        uint32_t  indexval;
+
+        float32_t *refp  = ref.ptr();
+        int16_t  *refind = maxIndexes.ptr();
+
+        float32_t *outp  = output.ptr();
+        int16_t  *ind    = index.ptr();
+
+        arm_max_f32(inp,
+              inputA.nbSamples(),
+              &result,
+              &indexval);
+
+        outp[0] = result;
+        ind[0] = indexval;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);
+
+    }
+
+    void StatsTestsF32::test_min_f32()
+    {
+        const float32_t *inp  = inputA.ptr();
+
+        float32_t result;
+        uint32_t  indexval;
+
+        float32_t *refp  = ref.ptr();
+        int16_t  *refind = minIndexes.ptr();
+
+        float32_t *outp  = output.ptr();
+        int16_t  *ind    = index.ptr();
+
+        arm_min_f32(inp,
+              inputA.nbSamples(),
+              &result,
+              &indexval);
+
+        outp[0] = result;
+        ind[0] = indexval;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);
+
+    }
+
+    void StatsTestsF32::test_mean_f32()
+    {
+        const float32_t *inp  = inputA.ptr();
+
+        float32_t result;
+
+        float32_t *refp  = ref.ptr();
+
+        float32_t *outp  = output.ptr();
+
+        arm_mean_f32(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);
+
+    }
+
+    void StatsTestsF32::test_power_f32()
+    {
+        const float32_t *inp  = inputA.ptr();
+
+        float32_t result;
+
+        float32_t *refp  = ref.ptr();
+
+        float32_t *outp  = output.ptr();
+
+        arm_power_f32(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);
+
+    }
+
+    void StatsTestsF32::test_rms_f32()
+    {
+        const float32_t *inp  = inputA.ptr();
+
+        float32_t result;
+
+        float32_t *refp  = ref.ptr();
+
+        float32_t *outp  = output.ptr();
+
+        arm_rms_f32(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);
+
+    }
+
+    void StatsTestsF32::test_std_f32()
+    {
+        const float32_t *inp  = inputA.ptr();
+
+        float32_t result;
+
+        float32_t *refp  = ref.ptr();
+
+        float32_t *outp  = output.ptr();
+
+        arm_std_f32(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);
+
+    }
+
+    void StatsTestsF32::test_var_f32()
+    {
+        const float32_t *inp  = inputA.ptr();
+
+        float32_t result;
+
+        float32_t *refp  = ref.ptr();
+
+        float32_t *outp  = output.ptr();
+
+        arm_var_f32(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);
+
+    }
 
     void StatsTestsF32::test_entropy_f32()
     {
@@ -86,11 +256,275 @@
     {
         switch(id)
         {
-            case StatsTestsF32::TEST_ENTROPY_F32_1:
+            case StatsTestsF32::TEST_MAX_F32_1:
             {
-               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr);
-               dims.reload(StatsTestsF32::DIM1_S16_ID,mgr);
-               ref.reload(StatsTestsF32::REF1_ENTROPY_F32_ID,mgr);
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3);
+              
+               maxIndexes.reload(StatsTestsF32::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsF32::MAXVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+               index.create(1,StatsTestsF32::OUT_S16_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF32::TEST_MAX_F32_2:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8);
+              
+               maxIndexes.reload(StatsTestsF32::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsF32::MAXVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+               index.create(1,StatsTestsF32::OUT_S16_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF32::TEST_MAX_F32_3:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,9);
+              
+               maxIndexes.reload(StatsTestsF32::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsF32::MAXVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+               index.create(1,StatsTestsF32::OUT_S16_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF32::TEST_MEAN_F32_4:
+            {
+               inputA.reload(StatsTestsF32::INPUT2_F32_ID,mgr,3);
+              
+               ref.reload(StatsTestsF32::MEANVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF32::TEST_MEAN_F32_5:
+            {
+               inputA.reload(StatsTestsF32::INPUT2_F32_ID,mgr,8);
+              
+               ref.reload(StatsTestsF32::MEANVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF32::TEST_MEAN_F32_6:
+            {
+               inputA.reload(StatsTestsF32::INPUT2_F32_ID,mgr,9);
+              
+               ref.reload(StatsTestsF32::MEANVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF32::TEST_MIN_F32_7:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3);
+              
+               minIndexes.reload(StatsTestsF32::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+               index.create(1,StatsTestsF32::OUT_S16_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF32::TEST_MIN_F32_8:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8);
+              
+               minIndexes.reload(StatsTestsF32::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+               index.create(1,StatsTestsF32::OUT_S16_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF32::TEST_MIN_F32_9:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,9);
+              
+               minIndexes.reload(StatsTestsF32::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+               index.create(1,StatsTestsF32::OUT_S16_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF32::TEST_POWER_F32_10:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3);
+              
+               ref.reload(StatsTestsF32::POWERVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF32::TEST_POWER_F32_11:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8);
+              
+               ref.reload(StatsTestsF32::POWERVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF32::TEST_POWER_F32_12:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,9);
+              
+               ref.reload(StatsTestsF32::POWERVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF32::TEST_RMS_F32_13:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3);
+              
+               ref.reload(StatsTestsF32::RMSVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF32::TEST_RMS_F32_14:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8);
+              
+               ref.reload(StatsTestsF32::RMSVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF32::TEST_RMS_F32_15:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,9);
+              
+               ref.reload(StatsTestsF32::RMSVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF32::TEST_STD_F32_16:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3);
+              
+               ref.reload(StatsTestsF32::STDVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF32::TEST_STD_F32_17:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8);
+              
+               ref.reload(StatsTestsF32::STDVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF32::TEST_STD_F32_18:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,9);
+              
+               ref.reload(StatsTestsF32::STDVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF32::TEST_VAR_F32_19:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3);
+              
+               ref.reload(StatsTestsF32::VARVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF32::TEST_VAR_F32_20:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8);
+              
+               ref.reload(StatsTestsF32::VARVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF32::TEST_VAR_F32_21:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,9);
+              
+               ref.reload(StatsTestsF32::VARVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF32::TEST_ENTROPY_F32_22:
+            {
+               inputA.reload(StatsTestsF32::INPUT22_F32_ID,mgr);
+               dims.reload(StatsTestsF32::DIM22_S16_ID,mgr);
+               ref.reload(StatsTestsF32::REF22_ENTROPY_F32_ID,mgr);
                output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr);
 
                const int16_t *dimsp  = dims.ptr();
@@ -99,11 +533,11 @@
             }
             break;
 
-            case StatsTestsF32::TEST_LOGSUMEXP_F32_2:
+            case StatsTestsF32::TEST_LOGSUMEXP_F32_23:
             {
-               inputA.reload(StatsTestsF32::INPUT2_F32_ID,mgr);
-               dims.reload(StatsTestsF32::DIM2_S16_ID,mgr);
-               ref.reload(StatsTestsF32::REF2_LOGSUMEXP_F32_ID,mgr);
+               inputA.reload(StatsTestsF32::INPUT23_F32_ID,mgr);
+               dims.reload(StatsTestsF32::DIM23_S16_ID,mgr);
+               ref.reload(StatsTestsF32::REF23_LOGSUMEXP_F32_ID,mgr);
                output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr);
 
                const int16_t *dimsp  = dims.ptr();
@@ -112,12 +546,12 @@
             }
             break;
 
-            case StatsTestsF32::TEST_KULLBACK_LEIBLER_F32_3:
+            case StatsTestsF32::TEST_KULLBACK_LEIBLER_F32_24:
             {
-               inputA.reload(StatsTestsF32::INPUTA3_F32_ID,mgr);
-               inputB.reload(StatsTestsF32::INPUTB3_F32_ID,mgr);
-               dims.reload(StatsTestsF32::DIM3_S16_ID,mgr);
-               ref.reload(StatsTestsF32::REF3_KL_F32_ID,mgr);
+               inputA.reload(StatsTestsF32::INPUTA24_F32_ID,mgr);
+               inputB.reload(StatsTestsF32::INPUTB24_F32_ID,mgr);
+               dims.reload(StatsTestsF32::DIM24_S16_ID,mgr);
+               ref.reload(StatsTestsF32::REF24_KL_F32_ID,mgr);
                output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr);
 
                const int16_t *dimsp  = dims.ptr();
@@ -126,12 +560,12 @@
             }
             break;
 
-            case StatsTestsF32::TEST_LOGSUMEXP_DOT_PROD_F32_4:
+            case StatsTestsF32::TEST_LOGSUMEXP_DOT_PROD_F32_25:
             {
-               inputA.reload(StatsTestsF32::INPUTA4_F32_ID,mgr);
-               inputB.reload(StatsTestsF32::INPUTB4_F32_ID,mgr);
-               dims.reload(StatsTestsF32::DIM4_S16_ID,mgr);
-               ref.reload(StatsTestsF32::REF4_LOGSUMEXP_DOT_F32_ID,mgr);
+               inputA.reload(StatsTestsF32::INPUTA25_F32_ID,mgr);
+               inputB.reload(StatsTestsF32::INPUTB25_F32_ID,mgr);
+               dims.reload(StatsTestsF32::DIM25_S16_ID,mgr);
+               ref.reload(StatsTestsF32::REF25_LOGSUMEXP_DOT_F32_ID,mgr);
                output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr);
 
                const int16_t *dimsp  = dims.ptr();
@@ -147,5 +581,19 @@
 
     void StatsTestsF32::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
     {
-       output.dump(mgr);
+      switch(id)
+      {
+            case StatsTestsF32::TEST_MAX_F32_1:
+            case StatsTestsF32::TEST_MAX_F32_2:
+            case StatsTestsF32::TEST_MAX_F32_3:
+            case StatsTestsF32::TEST_MIN_F32_7:
+            case StatsTestsF32::TEST_MIN_F32_8:
+            case StatsTestsF32::TEST_MIN_F32_9:
+              index.dump(mgr);
+              output.dump(mgr);
+            break;
+
+            default:
+              output.dump(mgr);
+      }
     }

CMSIS/DSP/Testing/Source/Tests/StatsTestsQ15.cpp

diff --git a/CMSIS/DSP/Testing/Source/Tests/StatsTestsQ15.cpp b/CMSIS/DSP/Testing/Source/Tests/StatsTestsQ15.cpp
new file mode 100755
index 0000000..c609fe5
--- /dev/null
+++ b/CMSIS/DSP/Testing/Source/Tests/StatsTestsQ15.cpp
@@ -0,0 +1,478 @@
+#include "arm_math.h"
+#include "StatsTestsQ15.h"
+#include "Error.h"
+#include "Test.h"
+
+//#include <cstdio>
+
+#define SNR_THRESHOLD 60
+/* 
+
+Reference patterns are generated with
+a double precision computation.
+
+*/
+#define ABS_ERROR_Q15 ((q15_t)20)
+#define ABS_ERROR_Q63 (1<<17)
+
+    void StatsTestsQ15::test_max_q15()
+    {
+        const q15_t *inp  = inputA.ptr();
+
+        q15_t result;
+        uint32_t  indexval;
+
+        q15_t *refp  = ref.ptr();
+        int16_t  *refind = maxIndexes.ptr();
+
+        q15_t *outp  = output.ptr();
+        int16_t  *ind    = index.ptr();
+
+        arm_max_q15(inp,
+              inputA.nbSamples(),
+              &result,
+              &indexval);
+
+        outp[0] = result;
+        ind[0] = indexval;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);
+
+    }
+
+    void StatsTestsQ15::test_min_q15()
+    {
+        const q15_t *inp  = inputA.ptr();
+
+        q15_t result;
+        uint32_t  indexval;
+
+        q15_t *refp  = ref.ptr();
+        int16_t  *refind = minIndexes.ptr();
+
+        q15_t *outp  = output.ptr();
+        int16_t  *ind    = index.ptr();
+
+        arm_min_q15(inp,
+              inputA.nbSamples(),
+              &result,
+              &indexval);
+
+        outp[0] = result;
+        ind[0] = indexval;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);
+
+    }
+
+    void StatsTestsQ15::test_mean_q15()
+    {
+        const q15_t *inp  = inputA.ptr();
+
+        q15_t result;
+
+        q15_t *refp  = ref.ptr();
+
+        q15_t *outp  = output.ptr();
+
+        arm_mean_q15(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q15);
+
+    }
+
+    void StatsTestsQ15::test_power_q15()
+    {
+        const q15_t *inp  = inputA.ptr();
+
+        q63_t result;
+
+        q63_t *refp  = refPower.ptr();
+
+        q63_t *outp  = outputPower.ptr();
+
+        arm_power_q15(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],(q63_t)ABS_ERROR_Q63);
+
+    }
+
+    void StatsTestsQ15::test_rms_q15()
+    {
+        const q15_t *inp  = inputA.ptr();
+
+        q15_t result;
+
+        q15_t *refp  = ref.ptr();
+
+        q15_t *outp  = output.ptr();
+
+        arm_rms_q15(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q15);
+
+    }
+
+    void StatsTestsQ15::test_std_q15()
+    {
+        const q15_t *inp  = inputA.ptr();
+
+        q15_t result;
+
+        q15_t *refp  = ref.ptr();
+
+        q15_t *outp  = output.ptr();
+
+        arm_std_q15(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q15);
+
+    }
+
+    void StatsTestsQ15::test_var_q15()
+    {
+        const q15_t *inp  = inputA.ptr();
+
+        q15_t result;
+
+        q15_t *refp  = ref.ptr();
+
+        q15_t *outp  = output.ptr();
+
+        arm_var_q15(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q15);
+
+    }
+
+  
+  
+    void StatsTestsQ15::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
+    {
+        switch(id)
+        {
+            case StatsTestsQ15::TEST_MAX_Q15_1:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,7);
+              
+               maxIndexes.reload(StatsTestsQ15::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ15::MAXVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+               index.create(1,StatsTestsQ15::OUT_S16_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MAX_Q15_2:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,16);
+              
+               maxIndexes.reload(StatsTestsQ15::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ15::MAXVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+               index.create(1,StatsTestsQ15::OUT_S16_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MAX_Q15_3:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,17);
+              
+               maxIndexes.reload(StatsTestsQ15::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ15::MAXVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+               index.create(1,StatsTestsQ15::OUT_S16_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MEAN_Q15_4:
+            {
+               inputA.reload(StatsTestsQ15::INPUT2_Q15_ID,mgr,7);
+              
+               ref.reload(StatsTestsQ15::MEANVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MEAN_Q15_5:
+            {
+               inputA.reload(StatsTestsQ15::INPUT2_Q15_ID,mgr,16);
+              
+               ref.reload(StatsTestsQ15::MEANVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MEAN_Q15_6:
+            {
+               inputA.reload(StatsTestsQ15::INPUT2_Q15_ID,mgr,17);
+              
+               ref.reload(StatsTestsQ15::MEANVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MIN_Q15_7:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,7);
+              
+               minIndexes.reload(StatsTestsQ15::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ15::MINVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+               index.create(1,StatsTestsQ15::OUT_S16_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MIN_Q15_8:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,16);
+              
+               minIndexes.reload(StatsTestsQ15::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ15::MINVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+               index.create(1,StatsTestsQ15::OUT_S16_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MIN_Q15_9:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,17);
+              
+               minIndexes.reload(StatsTestsQ15::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ15::MINVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+               index.create(1,StatsTestsQ15::OUT_S16_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_POWER_Q15_10:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,7);
+              
+               refPower.reload(StatsTestsQ15::POWERVALS_Q63_ID,mgr);
+               
+               outputPower.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_POWER_Q15_11:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,16);
+              
+               refPower.reload(StatsTestsQ15::POWERVALS_Q63_ID,mgr);
+               
+               outputPower.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_POWER_Q15_12:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,17);
+              
+               refPower.reload(StatsTestsQ15::POWERVALS_Q63_ID,mgr);
+               
+               outputPower.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_RMS_Q15_13:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,7);
+              
+               ref.reload(StatsTestsQ15::RMSVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_RMS_Q15_14:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,16);
+              
+               ref.reload(StatsTestsQ15::RMSVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_RMS_Q15_15:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,17);
+              
+               ref.reload(StatsTestsQ15::RMSVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_STD_Q15_16:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,7);
+              
+               ref.reload(StatsTestsQ15::STDVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_STD_Q15_17:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,16);
+              
+               ref.reload(StatsTestsQ15::STDVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_STD_Q15_18:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,17);
+              
+               ref.reload(StatsTestsQ15::STDVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_VAR_Q15_19:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,7);
+              
+               ref.reload(StatsTestsQ15::VARVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_VAR_Q15_20:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,16);
+              
+               ref.reload(StatsTestsQ15::VARVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_VAR_Q15_21:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,17);
+              
+               ref.reload(StatsTestsQ15::VARVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+          
+        }
+        
+    }
+
+    void StatsTestsQ15::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
+    {
+      switch(id)
+      {
+            case StatsTestsQ15::TEST_MAX_Q15_1:
+            case StatsTestsQ15::TEST_MAX_Q15_2:
+            case StatsTestsQ15::TEST_MAX_Q15_3:
+            case StatsTestsQ15::TEST_MIN_Q15_7:
+            case StatsTestsQ15::TEST_MIN_Q15_8:
+            case StatsTestsQ15::TEST_MIN_Q15_9:
+              index.dump(mgr);
+              output.dump(mgr);
+            break;
+
+            case TEST_POWER_Q15_10:
+            case TEST_POWER_Q15_11:
+            case TEST_POWER_Q15_12:
+              outputPower.dump(mgr);
+            break;
+
+            default:
+              output.dump(mgr);
+      }
+    }

CMSIS/DSP/Testing/Source/Tests/StatsTestsQ31.cpp

diff --git a/CMSIS/DSP/Testing/Source/Tests/StatsTestsQ31.cpp b/CMSIS/DSP/Testing/Source/Tests/StatsTestsQ31.cpp
new file mode 100755
index 0000000..9e8ce71
--- /dev/null
+++ b/CMSIS/DSP/Testing/Source/Tests/StatsTestsQ31.cpp
@@ -0,0 +1,475 @@
+#include "arm_math.h"
+#include "StatsTestsQ31.h"
+#include "Error.h"
+#include "Test.h"
+
+//#include <cstdio>
+
+#define SNR_THRESHOLD 100
+/* 
+
+Reference patterns are generated with
+a double precision computation.
+
+*/
+#define ABS_ERROR_Q31 40
+#define ABS_ERROR_Q63 (1<<17)
+
+    void StatsTestsQ31::test_max_q31()
+    {
+        const q31_t *inp  = inputA.ptr();
+
+        q31_t result;
+        uint32_t  indexval;
+
+        q31_t *refp  = ref.ptr();
+        int16_t  *refind = maxIndexes.ptr();
+
+        q31_t *outp  = output.ptr();
+        int16_t  *ind    = index.ptr();
+
+        arm_max_q31(inp,
+              inputA.nbSamples(),
+              &result,
+              &indexval);
+
+        outp[0] = result;
+        ind[0] = indexval;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);
+
+    }
+
+    void StatsTestsQ31::test_min_q31()
+    {
+        const q31_t *inp  = inputA.ptr();
+
+        q31_t result;
+        uint32_t  indexval;
+
+        q31_t *refp  = ref.ptr();
+        int16_t  *refind = minIndexes.ptr();
+
+        q31_t *outp  = output.ptr();
+        int16_t  *ind    = index.ptr();
+
+        arm_min_q31(inp,
+              inputA.nbSamples(),
+              &result,
+              &indexval);
+
+        outp[0] = result;
+        ind[0] = indexval;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);
+
+    }
+
+    void StatsTestsQ31::test_mean_q31()
+    {
+        const q31_t *inp  = inputA.ptr();
+
+        q31_t result;
+
+        q31_t *refp  = ref.ptr();
+
+        q31_t *outp  = output.ptr();
+
+        arm_mean_q31(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q31);
+
+    }
+
+    void StatsTestsQ31::test_power_q31()
+    {
+        const q31_t *inp  = inputA.ptr();
+
+        q63_t result;
+
+        q63_t *refp  = refPower.ptr();
+
+        q63_t *outp  = outputPower.ptr();
+
+        arm_power_q31(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],(q63_t)ABS_ERROR_Q63);
+
+    }
+
+    void StatsTestsQ31::test_rms_q31()
+    {
+        const q31_t *inp  = inputA.ptr();
+
+        q31_t result;
+
+        q31_t *refp  = ref.ptr();
+
+        q31_t *outp  = output.ptr();
+
+        arm_rms_q31(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q31);
+
+    }
+
+    void StatsTestsQ31::test_std_q31()
+    {
+        const q31_t *inp  = inputA.ptr();
+
+        q31_t result;
+
+        q31_t *refp  = ref.ptr();
+
+        q31_t *outp  = output.ptr();
+
+        arm_std_q31(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q31);
+
+    }
+
+    void StatsTestsQ31::test_var_q31()
+    {
+        const q31_t *inp  = inputA.ptr();
+
+        q31_t result;
+
+        q31_t *refp  = ref.ptr();
+
+        q31_t *outp  = output.ptr();
+
+        arm_var_q31(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q31);
+
+    }
+
+  
+  
+    void StatsTestsQ31::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
+    {
+        switch(id)
+        {
+            case StatsTestsQ31::TEST_MAX_Q31_1:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,3);
+              
+               maxIndexes.reload(StatsTestsQ31::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ31::MAXVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+               index.create(1,StatsTestsQ31::OUT_S16_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MAX_Q31_2:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,8);
+              
+               maxIndexes.reload(StatsTestsQ31::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ31::MAXVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+               index.create(1,StatsTestsQ31::OUT_S16_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MAX_Q31_3:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,9);
+              
+               maxIndexes.reload(StatsTestsQ31::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ31::MAXVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+               index.create(1,StatsTestsQ31::OUT_S16_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MEAN_Q31_4:
+            {
+               inputA.reload(StatsTestsQ31::INPUT2_Q31_ID,mgr,3);
+              
+               ref.reload(StatsTestsQ31::MEANVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MEAN_Q31_5:
+            {
+               inputA.reload(StatsTestsQ31::INPUT2_Q31_ID,mgr,8);
+              
+               ref.reload(StatsTestsQ31::MEANVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MEAN_Q31_6:
+            {
+               inputA.reload(StatsTestsQ31::INPUT2_Q31_ID,mgr,9);
+              
+               ref.reload(StatsTestsQ31::MEANVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MIN_Q31_7:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,3);
+              
+               minIndexes.reload(StatsTestsQ31::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ31::MINVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+               index.create(1,StatsTestsQ31::OUT_S16_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MIN_Q31_8:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,8);
+              
+               minIndexes.reload(StatsTestsQ31::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ31::MINVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+               index.create(1,StatsTestsQ31::OUT_S16_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MIN_Q31_9:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,9);
+              
+               minIndexes.reload(StatsTestsQ31::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ31::MINVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+               index.create(1,StatsTestsQ31::OUT_S16_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_POWER_Q31_10:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,3);
+              
+               refPower.reload(StatsTestsQ31::POWERVALS_Q63_ID,mgr);
+               
+               outputPower.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_POWER_Q31_11:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,8);
+              
+               refPower.reload(StatsTestsQ31::POWERVALS_Q63_ID,mgr);
+               
+               outputPower.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_POWER_Q31_12:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,9);
+              
+               refPower.reload(StatsTestsQ31::POWERVALS_Q63_ID,mgr);
+               
+               outputPower.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_RMS_Q31_13:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,3);
+              
+               ref.reload(StatsTestsQ31::RMSVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_RMS_Q31_14:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,8);
+              
+               ref.reload(StatsTestsQ31::RMSVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_RMS_Q31_15:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,9);
+              
+               ref.reload(StatsTestsQ31::RMSVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_STD_Q31_16:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,3);
+              
+               ref.reload(StatsTestsQ31::STDVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_STD_Q31_17:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,8);
+              
+               ref.reload(StatsTestsQ31::STDVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_STD_Q31_18:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,9);
+              
+               ref.reload(StatsTestsQ31::STDVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_VAR_Q31_19:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,3);
+              
+               ref.reload(StatsTestsQ31::VARVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_VAR_Q31_20:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,8);
+              
+               ref.reload(StatsTestsQ31::VARVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_VAR_Q31_21:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,9);
+              
+               ref.reload(StatsTestsQ31::VARVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+          
+        }
+        
+    }
+
+    void StatsTestsQ31::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
+    {
+      switch(id)
+      {
+            case StatsTestsQ31::TEST_MAX_Q31_1:
+            case StatsTestsQ31::TEST_MAX_Q31_2:
+            case StatsTestsQ31::TEST_MAX_Q31_3:
+              index.dump(mgr);
+              output.dump(mgr);
+            break;
+
+            case TEST_POWER_Q31_10:
+            case TEST_POWER_Q31_11:
+            case TEST_POWER_Q31_12:
+              outputPower.dump(mgr);
+            break;
+
+            default:
+              output.dump(mgr);
+      }
+    }

CMSIS/DSP/Testing/Source/Tests/StatsTestsQ7.cpp

diff --git a/CMSIS/DSP/Testing/Source/Tests/StatsTestsQ7.cpp b/CMSIS/DSP/Testing/Source/Tests/StatsTestsQ7.cpp
new file mode 100755
index 0000000..43b92a7
--- /dev/null
+++ b/CMSIS/DSP/Testing/Source/Tests/StatsTestsQ7.cpp
@@ -0,0 +1,531 @@
+#include "arm_math.h"
+#include "StatsTestsQ7.h"
+#include "Error.h"
+#include "Test.h"
+
+//#include <cstdio>
+
+#define SNR_THRESHOLD 20
+/* 
+
+Reference patterns are generated with
+a double precision computation.
+
+*/
+#define ABS_ERROR_Q7 ((q7_t)20)
+#define ABS_ERROR_Q31 ((q31_t)(1<<15))
+
+
+    void StatsTestsQ7::test_max_q7()
+    {
+        const q7_t *inp  = inputA.ptr();
+
+        q7_t result;
+        uint32_t  indexval;
+
+        q7_t *refp  = ref.ptr();
+        int16_t  *refind = maxIndexes.ptr();
+
+        q7_t *outp  = output.ptr();
+        int16_t  *ind    = index.ptr();
+
+        arm_max_q7(inp,
+              inputA.nbSamples(),
+              &result,
+              &indexval);
+
+        outp[0] = result;
+        ind[0] = indexval;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);
+
+    }
+
+    void StatsTestsQ7::test_min_q7()
+    {
+        const q7_t *inp  = inputA.ptr();
+
+        q7_t result;
+        uint32_t  indexval;
+
+        q7_t *refp  = ref.ptr();
+        int16_t  *refind = minIndexes.ptr();
+
+        q7_t *outp  = output.ptr();
+        int16_t  *ind    = index.ptr();
+
+        arm_min_q7(inp,
+              inputA.nbSamples(),
+              &result,
+              &indexval);
+
+        outp[0] = result;
+        ind[0] = indexval;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+        ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);
+
+    }
+
+    void StatsTestsQ7::test_mean_q7()
+    {
+        const q7_t *inp  = inputA.ptr();
+
+        q7_t result;
+
+        q7_t *refp  = ref.ptr();
+
+        q7_t *outp  = output.ptr();
+
+        arm_mean_q7(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)5);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q7);
+
+    }
+
+    void StatsTestsQ7::test_power_q7()
+    {
+        const q7_t *inp  = inputA.ptr();
+
+        q31_t result;
+
+        q31_t *refp  = refPower.ptr();
+
+        q31_t *outp  = outputPower.ptr();
+
+        arm_power_q7(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],(q31_t)ABS_ERROR_Q31);
+
+    }
+
+#if 0
+/*
+
+Those functions do not yet exist in CMSIS-DSP.
+But the tests are kept for when they will be available.
+
+*/
+    void StatsTestsQ7::test_rms_q7()
+    {
+        const q7_t *inp  = inputA.ptr();
+
+        q7_t result;
+
+        q7_t *refp  = ref.ptr();
+
+        q7_t *outp  = output.ptr();
+
+        arm_rms_q7(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q7);
+
+    }
+
+    void StatsTestsQ7::test_std_q7()
+    {
+        const q7_t *inp  = inputA.ptr();
+
+        q7_t result;
+
+        q7_t *refp  = ref.ptr();
+
+        q7_t *outp  = output.ptr();
+
+        arm_std_q7(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q7);
+
+    }
+
+    void StatsTestsQ7::test_var_q7()
+    {
+        const q7_t *inp  = inputA.ptr();
+
+        q7_t result;
+
+        q7_t *refp  = ref.ptr();
+
+        q7_t *outp  = output.ptr();
+
+        arm_var_q7(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_SNR(result,refp[this->refOffset],(float32_t)SNR_THRESHOLD);
+
+        ASSERT_NEAR_EQ(result,refp[this->refOffset],ABS_ERROR_Q7);
+
+    }
+
+#endif
+  
+    void StatsTestsQ7::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
+    {
+        switch(id)
+        {
+            case StatsTestsQ7::TEST_MAX_Q7_1:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,15);
+              
+               maxIndexes.reload(StatsTestsQ7::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ7::MAXVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+               index.create(1,StatsTestsQ7::OUT_S16_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MAX_Q7_2:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,32);
+              
+               maxIndexes.reload(StatsTestsQ7::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ7::MAXVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+               index.create(1,StatsTestsQ7::OUT_S16_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MAX_Q7_3:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,33);
+              
+               maxIndexes.reload(StatsTestsQ7::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ7::MAXVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+               index.create(1,StatsTestsQ7::OUT_S16_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            /*
+
+            For MEAN tests, INPUT2 pattern is used.
+            It contains only positive values and prevent the average
+            value from being too close to zero which make the estimation
+            of the errors difficult.
+
+            */
+            case StatsTestsQ7::TEST_MEAN_Q7_4:
+            {
+               inputA.reload(StatsTestsQ7::INPUT2_Q7_ID,mgr,15);
+              
+               ref.reload(StatsTestsQ7::MEANVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MEAN_Q7_5:
+            {
+               inputA.reload(StatsTestsQ7::INPUT2_Q7_ID,mgr,32);
+              
+               ref.reload(StatsTestsQ7::MEANVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MEAN_Q7_6:
+            {
+               inputA.reload(StatsTestsQ7::INPUT2_Q7_ID,mgr,33);
+              
+               ref.reload(StatsTestsQ7::MEANVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MIN_Q7_7:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,15);
+              
+               minIndexes.reload(StatsTestsQ7::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ7::MINVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+               index.create(1,StatsTestsQ7::OUT_S16_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MIN_Q7_8:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,32);
+              
+               minIndexes.reload(StatsTestsQ7::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ7::MINVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+               index.create(1,StatsTestsQ7::OUT_S16_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MIN_Q7_9:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,33);
+              
+               minIndexes.reload(StatsTestsQ7::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ7::MINVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+               index.create(1,StatsTestsQ7::OUT_S16_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_POWER_Q7_10:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,15);
+              
+               refPower.reload(StatsTestsQ7::POWERVALS_Q31_ID,mgr);
+               
+               outputPower.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_POWER_Q7_11:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,32);
+              
+               refPower.reload(StatsTestsQ7::POWERVALS_Q31_ID,mgr);
+               
+               outputPower.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_POWER_Q7_12:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,33);
+              
+               refPower.reload(StatsTestsQ7::POWERVALS_Q31_ID,mgr);
+               
+               outputPower.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+#if 0
+/*
+
+Those functions do not yet exist in CMSIS-DSP.
+But the tests are kept for when they will be available.
+
+*/
+            case StatsTestsQ7::TEST_RMS_Q7_13:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,15);
+              
+               ref.reload(StatsTestsQ7::RMSVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_RMS_Q7_14:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,32);
+              
+               ref.reload(StatsTestsQ7::RMSVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_RMS_Q7_15:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,33);
+              
+               ref.reload(StatsTestsQ7::RMSVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_STD_Q7_16:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,15);
+              
+               ref.reload(StatsTestsQ7::STDVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_STD_Q7_17:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,32);
+              
+               ref.reload(StatsTestsQ7::STDVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_STD_Q7_18:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,33);
+              
+               ref.reload(StatsTestsQ7::STDVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_VAR_Q7_19:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,15);
+              
+               ref.reload(StatsTestsQ7::VARVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_VAR_Q7_20:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,32);
+              
+               ref.reload(StatsTestsQ7::VARVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_VAR_Q7_21:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,33);
+              
+               ref.reload(StatsTestsQ7::VARVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+#endif
+
+            case StatsTestsQ7::TEST_MAX_Q7_13:
+            {
+               inputA.reload(StatsTestsQ7::MAXINDEXMAX_Q7_ID,mgr,280);
+              
+               maxIndexes.reload(StatsTestsQ7::MAXINDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ7::MAXVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+               index.create(1,StatsTestsQ7::OUT_S16_ID,mgr);
+
+               refOffset = 3;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MIN_Q7_14:
+            {
+               inputA.reload(StatsTestsQ7::MININDEXMAX_Q7_ID,mgr,280);
+              
+               minIndexes.reload(StatsTestsQ7::MININDEXES_S16_ID,mgr);
+               ref.reload(StatsTestsQ7::MINVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+               index.create(1,StatsTestsQ7::OUT_S16_ID,mgr);
+
+               refOffset = 3;
+            }
+            break;
+          
+        }
+        
+    }
+
+    void StatsTestsQ7::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
+    {
+      switch(id)
+      {
+            case StatsTestsQ7::TEST_MAX_Q7_1:
+            case StatsTestsQ7::TEST_MAX_Q7_2:
+            case StatsTestsQ7::TEST_MAX_Q7_3:
+            case StatsTestsQ7::TEST_MIN_Q7_7:
+            case StatsTestsQ7::TEST_MIN_Q7_8:
+            case StatsTestsQ7::TEST_MIN_Q7_9:
+            case StatsTestsQ7::TEST_MAX_Q7_13:
+            case StatsTestsQ7::TEST_MIN_Q7_14:
+              index.dump(mgr);
+              output.dump(mgr);
+            break;
+
+            case TEST_POWER_Q7_10:
+            case TEST_POWER_Q7_11:
+            case TEST_POWER_Q7_12:
+              outputPower.dump(mgr);
+            break;
+
+            default:
+              output.dump(mgr);
+      }
+    }

CMSIS/DSP/Testing/TestScripts/NewParser.py

diff --git a/CMSIS/DSP/Testing/TestScripts/NewParser.py b/CMSIS/DSP/Testing/TestScripts/NewParser.py
index f3b3ce8..7b08d5b 100644
--- a/CMSIS/DSP/Testing/TestScripts/NewParser.py
+++ b/CMSIS/DSP/Testing/TestScripts/NewParser.py
@@ -1,7 +1,12 @@
 from pyparsing import *
 import TestScripts.Parser as p
+import pickle
 
-
+def loadRoot(f):
+    root = None
+    with open(f,"rb") as inf:
+         root=pickle.load(inf)
+    return(root)
 
 class Params:
     def __init__(self):

CMSIS/DSP/Testing/addToDB.py

diff --git a/CMSIS/DSP/Testing/addToDB.py b/CMSIS/DSP/Testing/addToDB.py
index 252e41a..5b2d117 100755
--- a/CMSIS/DSP/Testing/addToDB.py
+++ b/CMSIS/DSP/Testing/addToDB.py
@@ -287,7 +287,7 @@
 
 parser = argparse.ArgumentParser(description='Generate summary benchmarks')
 
-parser.add_argument('-f', nargs='?',type = str, default=None, help="Test description file path")
+parser.add_argument('-f', nargs='?',type = str, default="Output.pickle", help="Test description file path")
 parser.add_argument('-b', nargs='?',type = str, default="FullBenchmark", help="Full Benchmark dir path")
 #parser.add_argument('-e', action='store_true', help="Embedded test")
 parser.add_argument('-o', nargs='?',type = str, default="bench.db", help="Benchmark database")
@@ -297,9 +297,10 @@
 args = parser.parse_args()
 
 if args.f is not None:
-    p = parse.Parser()
+    #p = parse.Parser()
     # Parse the test description file
-    root = p.parse(args.f)
+    #root = p.parse(args.f)
+    root=parse.loadRoot(args.f)
     d.deprecate(root,args.others)
     if args.others:
       group=args.others[0] 

CMSIS/DSP/Testing/addToRegDB.py

diff --git a/CMSIS/DSP/Testing/addToRegDB.py b/CMSIS/DSP/Testing/addToRegDB.py
index 899faf8..cf21085 100755
--- a/CMSIS/DSP/Testing/addToRegDB.py
+++ b/CMSIS/DSP/Testing/addToRegDB.py
@@ -298,7 +298,7 @@
 
 parser = argparse.ArgumentParser(description='Generate summary benchmarks')
 
-parser.add_argument('-f', nargs='?',type = str, default=None, help="Test description file path")
+parser.add_argument('-f', nargs='?',type = str, default="Output.pickle", help="Test description file path")
 parser.add_argument('-b', nargs='?',type = str, default="FullBenchmark", help="Full Benchmark dir path")
 #parser.add_argument('-e', action='store_true', help="Embedded test")
 parser.add_argument('-o', nargs='?',type = str, default="reg.db", help="Regression benchmark database")
@@ -308,9 +308,10 @@
 args = parser.parse_args()
 
 if args.f is not None:
-    p = parse.Parser()
+    #p = parse.Parser()
     # Parse the test description file
-    root = p.parse(args.f)
+    #root = p.parse(args.f)
+    root=parse.loadRoot(args.f)
     d.deprecate(root,args.others)
     if args.others:
       group=args.others[0] 

CMSIS/DSP/Testing/convertToOld.py

diff --git a/CMSIS/DSP/Testing/convertToOld.py b/CMSIS/DSP/Testing/convertToOld.py
index 5920155..477cf2a 100755
--- a/CMSIS/DSP/Testing/convertToOld.py
+++ b/CMSIS/DSP/Testing/convertToOld.py
@@ -87,7 +87,7 @@
 
 parser = argparse.ArgumentParser(description='Generate summary benchmarks')
 
-parser.add_argument('-f', nargs='?',type = str, default=None, help="Test description file path")
+parser.add_argument('-f', nargs='?',type = str, default="Output.pickle", help="Test description file path")
 parser.add_argument('-b', nargs='?',type = str, default="FullBenchmark", help="Full Benchmark dir path")
 parser.add_argument('-e', action='store_true', help="Embedded test")
 parser.add_argument('-o', nargs='?',type = str, default="bench.csv", help="Output csv file using old format")
@@ -97,9 +97,10 @@
 args = parser.parse_args()
 
 if args.f is not None:
-    p = parse.Parser()
+    #p = parse.Parser()
     # Parse the test description file
-    root = p.parse(args.f)
+    #root = p.parse(args.f)
+    root=parse.loadRoot(args.f)
     d.deprecate(root,args.others)
     extractBenchmarks(args.b,root)
     finalResult = pd.concat(result)

CMSIS/DSP/Testing/desc.txt

diff --git a/CMSIS/DSP/Testing/desc.txt b/CMSIS/DSP/Testing/desc.txt
index f636806..4540024 100644
--- a/CMSIS/DSP/Testing/desc.txt
+++ b/CMSIS/DSP/Testing/desc.txt
@@ -14,27 +14,68 @@
               folder = StatsF32
 
               Pattern INPUT1_F32_ID : Input1_f32.txt 
-              Pattern DIM1_S16_ID : Dims1_s16.txt 
-              Pattern REF1_ENTROPY_F32_ID : RefEntropy1_f32.txt
-
               Pattern INPUT2_F32_ID : Input2_f32.txt 
-              Pattern DIM2_S16_ID : Dims2_s16.txt 
-              Pattern REF2_LOGSUMEXP_F32_ID : RefLogSumExp2_f32.txt
+              Pattern MAXINDEXES_S16_ID : MaxIndexes1_s16.txt
+              Pattern MAXVALS_F32_ID : MaxVals1_f32.txt
+              Pattern MEANVALS_F32_ID : MeanVals2_f32.txt
+              Pattern MININDEXES_S16_ID : MinIndexes3_s16.txt
+              Pattern MINVALS_F32_ID : MinVals3_f32.txt
+              Pattern POWERVALS_F32_ID : PowerVals4_f32.txt
+              Pattern RMSVALS_F32_ID : RmsVals5_f32.txt
+              Pattern STDVALS_F32_ID : StdVals6_f32.txt
+              Pattern VARVALS_F32_ID : VarVals7_f32.txt
 
-              Pattern INPUTA3_F32_ID : InputA3_f32.txt 
-              Pattern INPUTB3_F32_ID : InputB3_f32.txt
-              Pattern DIM3_S16_ID : Dims3_s16.txt 
-              Pattern REF3_KL_F32_ID : RefKL3_f32.txt
+              Pattern INPUT22_F32_ID : Input22_f32.txt 
+              Pattern DIM22_S16_ID : Dims22_s16.txt 
+              Pattern REF22_ENTROPY_F32_ID : RefEntropy22_f32.txt
 
-              Pattern INPUTA4_F32_ID : InputA4_f32.txt 
-              Pattern INPUTB4_F32_ID : InputB4_f32.txt
-              Pattern DIM4_S16_ID : Dims4_s16.txt 
-              Pattern REF4_LOGSUMEXP_DOT_F32_ID : RefLogSumExpDot4_f32.txt
+              Pattern INPUT23_F32_ID : Input23_f32.txt 
+              Pattern DIM23_S16_ID : Dims23_s16.txt 
+              Pattern REF23_LOGSUMEXP_F32_ID : RefLogSumExp23_f32.txt
+
+              Pattern INPUTA24_F32_ID : InputA24_f32.txt 
+              Pattern INPUTB24_F32_ID : InputB24_f32.txt
+              Pattern DIM24_S16_ID : Dims24_s16.txt 
+              Pattern REF24_KL_F32_ID : RefKL24_f32.txt
+
+              Pattern INPUTA25_F32_ID : InputA25_f32.txt 
+              Pattern INPUTB25_F32_ID : InputB25_f32.txt
+              Pattern DIM25_S16_ID : Dims25_s16.txt 
+              Pattern REF25_LOGSUMEXP_DOT_F32_ID : RefLogSumExpDot25_f32.txt
 
               Output  OUT_F32_ID : Output
+              Output  OUT_S16_ID : Index
               Output  TMP_F32_ID : Temp
 
               Functions {
+                Test nb=3    arm_max_f32:test_max_f32
+                Test nb=4n   arm_max_f32:test_max_f32
+                Test nb=4n+1 arm_max_f32:test_max_f32
+
+                Test nb=3    arm_mean_f32:test_mean_f32
+                Test nb=4n   arm_mean_f32:test_mean_f32
+                Test nb=4n+1 arm_mean_f32:test_mean_f32
+
+                Test nb=3    arm_min_f32:test_min_f32
+                Test nb=4n   arm_min_f32:test_min_f32
+                Test nb=4n+1 arm_min_f32:test_min_f32
+
+                Test nb=3    arm_power_f32:test_power_f32
+                Test nb=4n   arm_power_f32:test_power_f32
+                Test nb=4n+1 arm_power_f32:test_power_f32
+
+                Test nb=3    arm_rms_f32:test_rms_f32
+                Test nb=4n   arm_rms_f32:test_rms_f32
+                Test nb=4n+1 arm_rms_f32:test_rms_f32
+
+                Test nb=3    arm_std_f32:test_std_f32
+                Test nb=4n   arm_std_f32:test_std_f32
+                Test nb=4n+1 arm_std_f32:test_std_f32
+
+                Test nb=3    arm_var_f32:test_var_f32
+                Test nb=4n   arm_var_f32:test_var_f32
+                Test nb=4n+1 arm_var_f32:test_var_f32
+
                 arm_entropy_f32:test_entropy_f32
                 arm_logsumexp_f32:test_logsumexp_f32
                 arm_kullback_leibler_f32:test_kullback_leibler_f32
@@ -42,6 +83,162 @@
               }
 
            }
+
+           suite Statistics Tests Q31 {
+              class = StatsTestsQ31
+              folder = StatsQ31
+
+              Pattern INPUT1_Q31_ID : Input1_q31.txt 
+              Pattern INPUT2_Q31_ID : Input2_q31.txt 
+              Pattern MAXINDEXES_S16_ID : MaxIndexes1_s16.txt
+              Pattern MAXVALS_Q31_ID : MaxVals1_q31.txt
+              Pattern MEANVALS_Q31_ID : MeanVals2_q31.txt
+              Pattern MININDEXES_S16_ID : MinIndexes3_s16.txt
+              Pattern MINVALS_Q31_ID : MinVals3_q31.txt
+              Pattern POWERVALS_Q63_ID : PowerVals4_q63.txt
+              Pattern RMSVALS_Q31_ID : RmsVals5_q31.txt
+              Pattern STDVALS_Q31_ID : StdVals6_q31.txt
+              Pattern VARVALS_Q31_ID : VarVals7_q31.txt
+
+              Output  OUT_Q31_ID : Output
+              Output  OUT_Q63_ID : Output
+              Output  OUT_S16_ID : Index
+              Output  TMP_Q31_ID : Temp
+
+              Functions {
+                Test nb=3    arm_max_q31:test_max_q31
+                Test nb=4n   arm_max_q31:test_max_q31
+                Test nb=4n+1 arm_max_q31:test_max_q31
+
+                Test nb=3    arm_mean_q31:test_mean_q31
+                Test nb=4n   arm_mean_q31:test_mean_q31
+                Test nb=4n+1 arm_mean_q31:test_mean_q31
+
+                Test nb=3    arm_min_q31:test_min_q31
+                Test nb=4n   arm_min_q31:test_min_q31
+                Test nb=4n+1 arm_min_q31:test_min_q31
+
+                Test nb=3    arm_power_q31:test_power_q31
+                Test nb=4n   arm_power_q31:test_power_q31
+                Test nb=4n+1 arm_power_q31:test_power_q31
+
+                Test nb=3    arm_rms_q31:test_rms_q31
+                Test nb=4n   arm_rms_q31:test_rms_q31
+                Test nb=4n+1 arm_rms_q31:test_rms_q31
+
+                Test nb=3    arm_std_q31:test_std_q31
+                Test nb=4n   arm_std_q31:test_std_q31
+                Test nb=4n+1 arm_std_q31:test_std_q31
+
+                Test nb=3    arm_var_q31:test_var_q31
+                Test nb=4n   arm_var_q31:test_var_q31
+                Test nb=4n+1 arm_var_q31:test_var_q31
+
+              }
+
+           }
+
+           suite Statistics Tests Q15 {
+              class = StatsTestsQ15
+              folder = StatsQ15
+
+              Pattern INPUT1_Q15_ID : Input1_q15.txt 
+              Pattern INPUT2_Q15_ID : Input2_q15.txt 
+              Pattern MAXINDEXES_S16_ID : MaxIndexes1_s16.txt
+              Pattern MAXVALS_Q15_ID : MaxVals1_q15.txt
+              Pattern MEANVALS_Q15_ID : MeanVals2_q15.txt
+              Pattern MININDEXES_S16_ID : MinIndexes3_s16.txt
+              Pattern MINVALS_Q15_ID : MinVals3_q15.txt
+              Pattern POWERVALS_Q63_ID : PowerVals4_q63.txt
+              Pattern RMSVALS_Q15_ID : RmsVals5_q15.txt
+              Pattern STDVALS_Q15_ID : StdVals6_q15.txt
+              Pattern VARVALS_Q15_ID : VarVals7_q15.txt
+
+              Output  OUT_Q15_ID : Output
+              Output  OUT_Q63_ID : Output
+              Output  OUT_S16_ID : Index
+              Output  TMP_Q15_ID : Temp
+
+              Functions {
+                Test nb=7    arm_max_q15:test_max_q15
+                Test nb=8n   arm_max_q15:test_max_q15
+                Test nb=8n+1 arm_max_q15:test_max_q15
+
+                Test nb=7    arm_mean_q15:test_mean_q15
+                Test nb=8n   arm_mean_q15:test_mean_q15
+                Test nb=8n+1 arm_mean_q15:test_mean_q15
+
+                Test nb=7    arm_min_q15:test_min_q15
+                Test nb=8n   arm_min_q15:test_min_q15
+                Test nb=8n+1 arm_min_q15:test_min_q15
+
+                Test nb=7    arm_power_q15:test_power_q15
+                Test nb=8n   arm_power_q15:test_power_q15
+                Test nb=8n+1 arm_power_q15:test_power_q15
+
+                Test nb=7    arm_rms_q15:test_rms_q15
+                Test nb=8n   arm_rms_q15:test_rms_q15
+                Test nb=8n+1 arm_rms_q15:test_rms_q15
+
+                Test nb=7    arm_std_q15:test_std_q15
+                Test nb=8n   arm_std_q15:test_std_q15
+                Test nb=8n+1 arm_std_q15:test_std_q15
+
+                Test nb=7    arm_var_q15:test_var_q15
+                Test nb=8n   arm_var_q15:test_var_q15
+                Test nb=8n+1 arm_var_q15:test_var_q15
+
+              }
+
+           }
+
+           suite Statistics Tests Q7 {
+              class = StatsTestsQ7
+              folder = StatsQ7
+
+              Pattern INPUT1_Q7_ID : Input1_q7.txt 
+              Pattern INPUT2_Q7_ID : Input2_q7.txt 
+              Pattern MAXINDEXES_S16_ID : MaxIndexes1_s16.txt
+              Pattern MAXVALS_Q7_ID : MaxVals1_q7.txt
+              Pattern MEANVALS_Q7_ID : MeanVals2_q7.txt
+              Pattern MININDEXES_S16_ID : MinIndexes3_s16.txt
+              Pattern MINVALS_Q7_ID : MinVals3_q7.txt
+              Pattern POWERVALS_Q31_ID : PowerVals4_q31.txt
+              Pattern MAXINDEXMAX_Q7_ID : InputMaxIndexMax1_q7.txt
+              Pattern MININDEXMAX_Q7_ID : InputMinIndexMax3_q7.txt
+
+              //Pattern RMSVALS_Q7_ID : RmsVals5_q7.txt
+              //Pattern STDVALS_Q7_ID : StdVals6_q7.txt
+              //Pattern VARVALS_Q7_ID : VarVals7_q7.txt
+
+              Output  OUT_Q7_ID : Output
+              Output  OUT_Q31_ID : Output
+              Output  OUT_S16_ID : Index
+              Output  TMP_Q7_ID : Temp
+
+              Functions {
+                Test nb=15    arm_max_q7:test_max_q7
+                Test nb=16n   arm_max_q7:test_max_q7
+                Test nb=16n+1 arm_max_q7:test_max_q7
+
+                Test nb=15    arm_mean_q7:test_mean_q7
+                Test nb=16n   arm_mean_q7:test_mean_q7
+                Test nb=16n+1 arm_mean_q7:test_mean_q7
+
+                Test nb=15    arm_min_q7:test_min_q7
+                Test nb=16n   arm_min_q7:test_min_q7
+                Test nb=16n+1 arm_min_q7:test_min_q7
+
+                Test nb=15    arm_power_q7:test_power_q7
+                Test nb=16n   arm_power_q7:test_power_q7
+                Test nb=16n+1 arm_power_q7:test_power_q7
+
+                Test big index  arm_max_q7:test_max_q7
+                Test big index  arm_min_q7:test_min_q7
+
+              }
+
+           }
         }
 
         group Support Tests {

CMSIS/DSP/Testing/preprocess.py

diff --git a/CMSIS/DSP/Testing/preprocess.py b/CMSIS/DSP/Testing/preprocess.py
new file mode 100755
index 0000000..f2dadec
--- /dev/null
+++ b/CMSIS/DSP/Testing/preprocess.py
@@ -0,0 +1,18 @@
+import argparse

+import TestScripts.NewParser as parse

+import pickle

+

+parser = argparse.ArgumentParser(description='Parse test description')

+

+parser.add_argument('-f', nargs='?',type = str, default=None, help="Test description file path")

+

+parser.add_argument('-o', nargs='?',type = str, default="Output.pickle", help="output file for parsed description")

+

+args = parser.parse_args()

+

+if args.f is not None:

+    p = parse.Parser()

+    # Parse the test description file

+    root = p.parse(args.f)

+    with open(args.o,"wb") as output:

+         pickle.dump(root, output)

CMSIS/DSP/Testing/processResult.py

diff --git a/CMSIS/DSP/Testing/processResult.py b/CMSIS/DSP/Testing/processResult.py
index 1da7d66..c9c3d22 100644
--- a/CMSIS/DSP/Testing/processResult.py
+++ b/CMSIS/DSP/Testing/processResult.py
@@ -14,6 +14,31 @@
 
 init()
 
+def errorStr(id):
+  if id == 1:
+     return("UNKNOWN_ERROR")
+  if id == 2:
+     return("Equality error")
+  if id == 3:
+     return("Absolute difference error")
+  if id == 4:
+     return("Relative difference error")
+  if id == 5:
+     return("SNR error")
+  if id == 6:
+     return("Different length error")
+  if id == 7:
+     return("Assertion error")
+  if id == 8:
+     return("Memory allocation error")
+  if id == 9:
+     return("Empty pattern error")
+  if id == 10:
+     return("Buffer tail corrupted")
+
+  return("Unknown error %d" % id)
+
+
 def findItem(root,path):
         """ Find a node in a tree
       
@@ -74,7 +99,7 @@
              if params:
                 print("%s %s" % (ident,params))
              if passed != 1:
-                print(Fore.RED + ("%s Error = %d at line %d" % (ident, theError, theLine)) + Style.RESET_ALL)
+                print(Fore.RED + ("%s %s at line %d" % (ident, errorStr(theError), theLine)) + Style.RESET_ALL)
 
       def pop(self):
           None
@@ -421,7 +446,7 @@
 
 parser = argparse.ArgumentParser(description='Parse test description')
 
-parser.add_argument('-f', nargs='?',type = str, default=None, help="Test description file path")
+parser.add_argument('-f', nargs='?',type = str, default="Output.pickle", help="Test description file path")
 # Where the result file can be found
 parser.add_argument('-r', nargs='?',type = str, default=None, help="Result file path")
 parser.add_argument('-c', action='store_true', help="CSV output")
@@ -437,9 +462,10 @@
 
 
 if args.f is not None:
-    p = parse.Parser()
+    #p = parse.Parser()
     # Parse the test description file
-    root = p.parse(args.f)
+    #root = p.parse(args.f)
+    root=parse.loadRoot(args.f)
     if args.t:
        with open(args.t,"r") as trace:
          with open(args.r,"r") as results:

CMSIS/DSP/Testing/processTests.py

diff --git a/CMSIS/DSP/Testing/processTests.py b/CMSIS/DSP/Testing/processTests.py
index deef594..14b29c5 100644
--- a/CMSIS/DSP/Testing/processTests.py
+++ b/CMSIS/DSP/Testing/processTests.py
@@ -5,7 +5,7 @@
 
 
 parser = argparse.ArgumentParser(description='Parse test description')
-parser.add_argument('-f', nargs='?',type = str, default="test.txt", help="File path")
+parser.add_argument('-f', nargs='?',type = str, default="Output.pickle", help="File path")
 
 parser.add_argument('-p', nargs='?',type = str, default="Patterns", help="Pattern dir path")
 parser.add_argument('-d', nargs='?',type = str, default="Parameters", help="Parameter dir path")
@@ -23,11 +23,12 @@
 
 if args.f is not None:
     # Create a treeelemt object
-    p = parse.Parser()
+    #p = parse.Parser()
     # Create a codegen object
     c = TestScripts.CodeGen.CodeGen(args.p,args.d, args.e)
     # Parse the test description.
-    root = p.parse(args.f)
+    #root = p.parse(args.f)
+    root=parse.loadRoot(args.f)
     d.deprecate(root,args.others)
     #print(root)
     # Generate code with the tree of tests

CMSIS/DSP/Testing/summaryBench.py

diff --git a/CMSIS/DSP/Testing/summaryBench.py b/CMSIS/DSP/Testing/summaryBench.py
index ff758bc..10aef20 100644
--- a/CMSIS/DSP/Testing/summaryBench.py
+++ b/CMSIS/DSP/Testing/summaryBench.py
@@ -107,7 +107,7 @@
 
 parser = argparse.ArgumentParser(description='Generate summary benchmarks')
 
-parser.add_argument('-f', nargs='?',type = str, default=None, help="Test description file path")
+parser.add_argument('-f', nargs='?',type = str, default="Output.pickle", help="Test description file path")
 parser.add_argument('-b', nargs='?',type = str, default="FullBenchmark", help="Full Benchmark dir path")
 # Needed to find the currentConfig.csv and know the headers
 parser.add_argument('-r', nargs='?',type = str, default=None, help="Result file path")
@@ -117,9 +117,10 @@
 args = parser.parse_args()
 
 if args.f is not None:
-    p = parse.Parser()
+    #p = parse.Parser()
     # Parse the test description file
-    root = p.parse(args.f)
+    #root = p.parse(args.f)
+    root=parse.loadRoot(args.f)
     d.deprecate(root,args.others)
     resultPath=os.path.dirname(args.r)
     extractBenchmarks(resultPath,args.b,root)