CMSIS-DSP: Added Helium support for functions in BasicMaths.

Added test patterns for functions in BasicMaths.
Corrected github issue 622 (clarified comment for lms_norm_f32).
Added support for q63_t to the test framework.

Include/arm_helium_utils.h

@@ -36,35 +36,6 @@ Definitions available for MVEF and MVEI
 ***************************************/
 #if defined (ARM_MATH_HELIUM) || defined(ARM_MATH_MVEF) || defined(ARM_MATH_MVEI)
 
-#define nbLanes(sz)             (128/sz)
-
-#define VEC_LANES_F32       nbLanes(32)
-#define VEC_LANES_F16       nbLanes(16)
-#define VEC_LANES_Q63       nbLanes(64)
-#define VEC_LANES_Q31       nbLanes(32)
-#define VEC_LANES_Q15       nbLanes(16)
-#define VEC_LANES_Q7        nbLanes(8)
-
-#define nb_vec_lanes(ptr) _Generic((ptr), \
-               uint32_t *: VEC_LANES_Q31, \
-               uint16_t *: VEC_LANES_Q15, \
-                uint8_t *: VEC_LANES_Q7,  \
-                  q31_t *: VEC_LANES_Q31, \
-                  q15_t *: VEC_LANES_Q15, \
-                   q7_t *: VEC_LANES_Q7,  \
-               float32_t*: VEC_LANES_F32, \
-               float16_t*: VEC_LANES_F16, \
-            const q31_t *: VEC_LANES_Q31, \
-            const q15_t *: VEC_LANES_Q15, \
-             const q7_t *: VEC_LANES_Q7,  \
-         const float32_t*: VEC_LANES_F32, \
-         const float16_t*: VEC_LANES_F16, \
-                  default: "err")
-
-
-
-#define post_incr_vec_size(ptr)         ptr += nb_vec_lanes(ptr)
-
 #endif /* defined (ARM_MATH_HELIUM) || defined(ARM_MATH_MVEF) || defined(ARM_MATH_MVEI) */
 
 /***************************************

Include/arm_math.h

@@ -386,10 +386,22 @@ extern "C"
   #define ARM_MATH_DSP                   1
 #endif
 
-#if defined(__ARM_NEON)
+#if defined(ARM_MATH_NEON)
 #include <arm_neon.h>
 #endif
 
+#if defined (ARM_MATH_HELIUM)
+  #define ARM_MATH_MVEF
+#endif
+
+#if defined (ARM_MATH_MVEF)
+  #define ARM_MATH_MVEI
+#endif
+
+#if defined (ARM_MATH_HELIUM) || defined(ARM_MATH_MVEF) || defined(ARM_MATH_MVEI)
+#include <arm_mve.h>
+#endif
+
 
   /**
    * @brief Macros required for reciprocal calculation in Normalized LMS
@@ -466,6 +478,308 @@ extern "C"
    */
   typedef double float64_t;
 
+  /**
+   * @brief vector types
+   */
+#if defined(ARM_MATH_NEON) || defined (ARM_MATH_MVEI)
+  /**
+   * @brief 64-bit fractional 128-bit vector data type in 1.63 format
+   */
+  typedef int64x2_t q63x2_t;
+
+  /**
+   * @brief 32-bit fractional 128-bit vector data type in 1.31 format.
+   */
+  typedef int32x4_t q31x4_t;
+
+  /**
+   * @brief 16-bit fractional 128-bit vector data type with 16-bit alignement in 1.15 format.
+   */
+  typedef __ALIGNED(2) int16x8_t q15x8_t;
+
+ /**
+   * @brief 8-bit fractional 128-bit vector data type with 8-bit alignement in 1.7 format.
+   */
+  typedef __ALIGNED(1) int8x16_t q7x16_t;
+
+    /**
+   * @brief 32-bit fractional 128-bit vector pair data type in 1.31 format.
+   */
+  typedef int32x4x2_t q31x4x2_t;
+
+  /**
+   * @brief 32-bit fractional 128-bit vector quadruplet data type in 1.31 format.
+   */
+  typedef int32x4x4_t q31x4x4_t;
+
+  /**
+   * @brief 16-bit fractional 128-bit vector pair data type in 1.15 format.
+   */
+  typedef int16x8x2_t q15x8x2_t;
+
+  /**
+   * @brief 16-bit fractional 128-bit vector quadruplet data type in 1.15 format.
+   */
+  typedef int16x8x4_t q15x8x4_t;
+
+  /**
+   * @brief 8-bit fractional 128-bit vector pair data type in 1.7 format.
+   */
+  typedef int8x16x2_t q7x16x2_t;
+
+  /**
+   * @brief 8-bit fractional 128-bit vector quadruplet data type in 1.7 format.
+   */
+   typedef int8x16x4_t q7x16x4_t;
+
+  /**
+   * @brief 32-bit fractional data type in 9.23 format.
+   */
+  typedef int32_t q23_t;
+
+  /**
+   * @brief 32-bit fractional 128-bit vector data type in 9.23 format.
+   */
+  typedef int32x4_t q23x4_t;
+
+  /**
+   * @brief 64-bit status 128-bit vector data type.
+   */
+  typedef int64x2_t status64x2_t;
+
+  /**
+   * @brief 32-bit status 128-bit vector data type.
+   */
+  typedef int32x4_t status32x4_t;
+
+  /**
+   * @brief 16-bit status 128-bit vector data type.
+   */
+  typedef int16x8_t status16x8_t;
+
+  /**
+   * @brief 8-bit status 128-bit vector data type.
+   */
+  typedef int8x16_t status8x16_t;
+
+
+#endif
+
+
+#if defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF) /* floating point vector*/
+  /**
+   * @brief 32-bit floating-point 128-bit vector type
+   */
+  typedef float32x4_t f32x4_t;
+
+  /**
+   * @brief 16-bit floating-point 128-bit vector data type
+   */
+  typedef __ALIGNED(2) float16x8_t f16x8_t;
+
+  /**
+   * @brief 32-bit floating-point 128-bit vector pair data type
+   */
+  typedef float32x4x2_t f32x4x2_t;
+
+  /**
+   * @brief 32-bit floating-point 128-bit vector quadruplet data type
+   */
+  typedef float32x4x4_t f32x4x4_t;
+
+  /**
+   * @brief 16-bit floating-point 128-bit vector pair data type
+   */
+  typedef float16x8x2_t f16x8x2_t;
+
+  /**
+   * @brief 16-bit floating-point 128-bit vector quadruplet data type
+   */
+  typedef float16x8x4_t f16x8x4_t;
+
+  /**
+   * @brief 32-bit ubiquitous 128-bit vector data type
+   */
+  typedef union _any32x4_t
+  {
+      float32x4_t     f;
+      int32x4_t       i;
+  } any32x4_t;
+
+  /**
+   * @brief 16-bit ubiquitous 128-bit vector data type
+   */
+  typedef union _any16x8_t
+  {
+      float16x8_t     f;
+      int16x8_t       i;
+  } any16x8_t;
+
+#endif
+
+#if defined(ARM_MATH_NEON)
+  /**
+   * @brief 32-bit fractional 64-bit vector data type in 1.31 format.
+   */
+  typedef int32x2_t  q31x2_t;
+
+  /**
+   * @brief 16-bit fractional 64-bit vector data type in 1.15 format.
+   */
+  typedef  __ALIGNED(2) int16x4_t q15x4_t;
+
+  /**
+   * @brief 8-bit fractional 64-bit vector data type in 1.7 format.
+   */
+  typedef  __ALIGNED(1) int8x8_t q7x8_t;
+
+  /**
+   * @brief 32-bit float 64-bit vector data type.
+   */
+  typedef float32x2_t  f32x2_t;
+
+  /**
+   * @brief 16-bit float 64-bit vector data type.
+   */
+  typedef  __ALIGNED(2) float16x4_t f16x4_t;
+
+  /**
+   * @brief 32-bit floating-point 128-bit vector triplet data type
+   */
+  typedef float32x4x3_t f32x4x3_t;
+
+  /**
+   * @brief 16-bit floating-point 128-bit vector triplet data type
+   */
+  typedef float16x8x3_t f16x8x3_t;
+
+
+  /**
+   * @brief 32-bit fractional 128-bit vector triplet data type in 1.31 format
+   */
+  typedef int32x4x3_t q31x4x3_t;
+
+  /**
+   * @brief 16-bit fractional 128-bit vector triplet data type in 1.15 format
+   */
+  typedef int16x8x3_t q15x8x3_t;
+
+  /**
+   * @brief 8-bit fractional 128-bit vector triplet data type in 1.7 format
+   */
+  typedef int8x16x3_t q7x16x3_t;
+
+  /**
+   * @brief 32-bit floating-point 64-bit vector pair data type
+   */
+  typedef float32x2x2_t f32x2x2_t;
+
+  /**
+   * @brief 32-bit floating-point 64-bit vector triplet data type
+   */
+  typedef float32x2x3_t f32x2x3_t;
+
+  /**
+   * @brief 32-bit floating-point 64-bit vector quadruplet data type
+   */
+  typedef float32x2x4_t f32x2x4_t;
+
+  /**
+   * @brief 16-bit floating-point 64-bit vector pair data type
+   */
+  typedef float16x4x2_t f16x4x2_t;
+
+  /**
+   * @brief 16-bit floating-point 64-bit vector triplet data type
+   */
+  typedef float16x4x3_t f16x4x3_t;
+
+  /**
+   * @brief 16-bit floating-point 64-bit vector quadruplet data type
+   */
+  typedef float16x4x4_t f16x4x4_t;
+
+  /**
+   * @brief 32-bit fractional 64-bit vector pair data type in 1.31 format
+   */
+  typedef int32x2x2_t q31x2x2_t;
+
+  /**
+   * @brief 32-bit fractional 64-bit vector triplet data type in 1.31 format
+   */
+  typedef int32x2x3_t q31x2x3_t;
+
+  /**
+   * @brief 32-bit fractional 64-bit vector quadruplet data type in 1.31 format
+   */
+  typedef int32x4x3_t q31x2x4_t;
+
+  /**
+   * @brief 16-bit fractional 64-bit vector pair data type in 1.15 format
+   */
+  typedef int16x4x2_t q15x4x2_t;
+
+  /**
+   * @brief 16-bit fractional 64-bit vector triplet data type in 1.15 format
+   */
+  typedef int16x4x2_t q15x4x3_t;
+
+  /**
+   * @brief 16-bit fractional 64-bit vector quadruplet data type in 1.15 format
+   */
+  typedef int16x4x3_t q15x4x4_t;
+
+  /**
+   * @brief 8-bit fractional 64-bit vector pair data type in 1.7 format
+   */
+  typedef int8x8x2_t q7x8x2_t;
+
+  /**
+   * @brief 8-bit fractional 64-bit vector triplet data type in 1.7 format
+   */
+  typedef int8x8x3_t q7x8x3_t;
+
+  /**
+   * @brief 8-bit fractional 64-bit vector quadruplet data type in 1.7 format
+   */
+  typedef int8x8x4_t q7x8x4_t;
+
+  /**
+   * @brief 32-bit ubiquitous 64-bit vector data type
+   */
+  typedef union _any32x2_t
+  {
+      float32x2_t     f;
+      int32x2_t       i;
+  } any32x2_t;
+
+  /**
+   * @brief 16-bit ubiquitous 64-bit vector data type
+   */
+  typedef union _any16x4_t
+  {
+      float16x4_t     f;
+      int16x4_t       i;
+  } any16x4_t;
+
+  /**
+   * @brief 32-bit status 64-bit vector data type.
+   */
+  typedef int32x4_t status32x2_t;
+
+  /**
+   * @brief 16-bit status 64-bit vector data type.
+   */
+  typedef int16x8_t status16x4_t;
+
+  /**
+   * @brief 8-bit status 64-bit vector data type.
+   */
+  typedef int8x16_t status8x8_t;
+
+#endif
+
+
 
 /**
   @brief definition to read/write two 16 bit values.

Source/BasicMathFunctions/arm_abs_f32.c

@@ -60,6 +60,55 @@
   @return        none
  */
 
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_abs_f32(
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize)
+{
+    uint32_t blkCnt;                               /* Loop counter */
+    f32x4_t vec1;
+    f32x4_t res;
+
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+
+    while (blkCnt > 0U)
+    {
+        /* C = |A| */
+
+        /* Calculate absolute values and then store the results in the destination buffer. */
+        vec1 = vld1q(pSrc);
+        res = vabsq(vec1);
+        vst1q(pDst, res);
+
+        /* Increment pointers */
+        pSrc += 4;
+        pDst += 4;
+        
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+
+
+    if (blkCnt > 0U)
+    {
+      /* C = |A| */
+      mve_pred16_t p0 = vctp32q(blkCnt);
+      vec1 = vld1q(pSrc);
+      vstrwq_p(pDst, vabsq(vec1), p0);
+    }
+
+}
+
+#else
 void arm_abs_f32(
   const float32_t * pSrc,
         float32_t * pDst,
@@ -67,9 +116,9 @@ void arm_abs_f32(
 {
         uint32_t blkCnt;                               /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    float32x4_t vec1;
-    float32x4_t res;
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    f32x4_t vec1;
+    f32x4_t res;
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
@@ -95,7 +144,7 @@ void arm_abs_f32(
     blkCnt = blockSize & 0x3;
 
 #else
-#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;
@@ -140,7 +189,7 @@ void arm_abs_f32(
   }
 
 }
-
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 /**
   @} end of BasicAbs group
  */

Source/BasicMathFunctions/arm_abs_q15.c

@@ -49,6 +49,51 @@
                    The Q15 value -1 (0x8000) will be saturated to the maximum allowable positive value 0x7FFF.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_abs_q15(
+    const q15_t * pSrc,
+    q15_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q15x8_t vecSrc;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = |A|
+         * Calculate absolute and then store the results in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vst1q(pDst, vqabsq(vecSrc));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 8;
+        pDst += 8;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrhq_p(pDst, vqabsq(vecSrc), p0);
+    }
+}
+
+#else
 void arm_abs_q15(
   const q15_t * pSrc,
         q15_t * pDst,
@@ -126,6 +171,7 @@ void arm_abs_q15(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicAbs group

Source/BasicMathFunctions/arm_abs_q31.c

@@ -49,6 +49,51 @@
                    The Q31 value -1 (0x80000000) will be saturated to the maximum allowable positive value 0x7FFFFFFF.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_abs_q31(
+    const q31_t * pSrc,
+    q31_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q31x4_t vecSrc;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = |A|
+         * Calculate absolute and then store the results in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vst1q(pDst, vqabsq(vecSrc));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 4;
+        pDst += 4;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrwq_p(pDst, vqabsq(vecSrc), p0);
+    }
+}
+
+#else
 void arm_abs_q31(
   const q31_t * pSrc,
         q31_t * pDst,
@@ -126,7 +171,7 @@ void arm_abs_q31(
   }
 
 }
-
+#endif /* defined(ARM_MATH_MVEI) */
 /**
   @} end of BasicAbs group
  */

Source/BasicMathFunctions/arm_abs_q7.c

@@ -51,6 +51,51 @@
                    The Q7 value -1 (0x80) will be saturated to the maximum allowable positive value 0x7F.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_abs_q7(
+    const q7_t * pSrc,
+    q7_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q7x16_t vecSrc;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = |A|
+         * Calculate absolute and then store the results in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vst1q(pDst, vqabsq(vecSrc));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 16;
+        pDst += 16;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrbq_p(pDst, vqabsq(vecSrc), p0);
+    }
+}
+
+#else
 void arm_abs_q7(
   const q7_t * pSrc,
         q7_t * pDst,
@@ -128,6 +173,7 @@ void arm_abs_q7(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicAbs group

Source/BasicMathFunctions/arm_add_f32.c

@@ -58,6 +58,59 @@
   @return        none
  */
 
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_add_f32(
+  const float32_t * pSrcA,
+  const float32_t * pSrcB,
+        float32_t * pDst,
+        uint32_t blockSize)
+{
+    uint32_t blkCnt;                               /* Loop counter */
+
+    f32x4_t vec1;
+    f32x4_t vec2;
+    f32x4_t res;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+
+    while (blkCnt > 0U)
+    {
+        /* C = A + B */
+
+        /* Add and then store the results in the destination buffer. */
+        vec1 = vld1q(pSrcA);
+        vec2 = vld1q(pSrcB);
+        res = vaddq(vec1, vec2);
+        vst1q(pDst, res);
+
+        /* Increment pointers */
+        pSrcA += 4;
+        pSrcB += 4; 
+        pDst += 4;
+        
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+
+    if (blkCnt > 0U)
+    {
+      /* C = A + B */
+      mve_pred16_t p0 = vctp32q(blkCnt);
+      vec1 = vld1q(pSrcA);
+      vec2 = vld1q(pSrcB);
+      vstrwq_p(pDst, vaddq(vec1,vec2), p0);
+    }
+
+}
+
+#else
 void arm_add_f32(
   const float32_t * pSrcA,
   const float32_t * pSrcB,
@@ -66,10 +119,10 @@ void arm_add_f32(
 {
         uint32_t blkCnt;                               /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    float32x4_t vec1;
-    float32x4_t vec2;
-    float32x4_t res;
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    f32x4_t vec1;
+    f32x4_t vec2;
+    f32x4_t res;
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
@@ -97,7 +150,7 @@ void arm_add_f32(
     blkCnt = blockSize & 0x3;
 
 #else
-#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;
@@ -139,6 +192,7 @@ void arm_add_f32(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of BasicAdd group

Source/BasicMathFunctions/arm_add_q15.c

@@ -50,6 +50,56 @@
                    Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_add_q15(
+    const q15_t * pSrcA,
+    const q15_t * pSrcB,
+    q15_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q15x8_t vecA;
+    q15x8_t vecB;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A + B
+         * Add and then store the results in the destination buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vst1q(pDst, vqaddq(vecA, vecB));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA  += 8;
+        pSrcB  += 8;
+        pDst   += 8;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vstrhq_p(pDst, vqaddq(vecA, vecB), p0);
+    }
+}
+
+#else
 void arm_add_q15(
   const q15_t * pSrcA,
   const q15_t * pSrcB,
@@ -120,7 +170,7 @@ void arm_add_q15(
   }
 
 }
-
+#endif /* defined(ARM_MATH_MVEI) */
 /**
   @} end of BasicAdd group
  */

Source/BasicMathFunctions/arm_add_q31.c

@@ -50,6 +50,56 @@
                    Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_add_q31(
+  const q31_t * pSrcA,
+  const q31_t * pSrcB,
+        q31_t * pDst,
+        uint32_t blockSize)
+{
+    uint32_t blkCnt;   
+    q31x4_t vecA;
+    q31x4_t vecB;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A + B
+         * Add and then store the results in the destination buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vst1q(pDst, vqaddq(vecA, vecB));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA  += 4;
+        pSrcB  += 4;
+        pDst   += 4;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vstrwq_p(pDst, vqaddq(vecA, vecB), p0);
+    }
+}
+
+#else
 void arm_add_q31(
   const q31_t * pSrcA,
   const q31_t * pSrcB,
@@ -103,6 +153,7 @@ void arm_add_q31(
 
 }
 
+#endif /* defined(ARM_MATH_MVEI) */
 /**
   @} end of BasicAdd group
  */

Source/BasicMathFunctions/arm_add_q7.c

@@ -50,6 +50,55 @@
                    Results outside of the allowable Q7 range [0x80 0x7F] are saturated.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_add_q7(
+    const q7_t * pSrcA,
+    const q7_t * pSrcB,
+    q7_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q7x16_t vecA;
+    q7x16_t vecB;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A + B
+         * Add and then store the results in the destination buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vst1q(pDst, vqaddq(vecA, vecB));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA  += 16;
+        pSrcB  += 16;
+        pDst   += 16;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vstrbq_p(pDst, vqaddq(vecA, vecB), p0);
+    }
+}
+#else
 void arm_add_q7(
   const q7_t * pSrcA,
   const q7_t * pSrcB,
@@ -103,7 +152,7 @@ void arm_add_q7(
   }
 
 }
-
+#endif /* defined(ARM_MATH_MVEI) */
 /**
   @} end of BasicAdd group
  */

Source/BasicMathFunctions/arm_dot_prod_f32.c

@@ -59,42 +59,62 @@
   @return        none
  */
 
-#if defined (ARM_MATH_HELIUM)
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
 
-#include "arm_mve.h"
 #include "arm_helium_utils.h"
 
+
 void arm_dot_prod_f32(
     const float32_t * pSrcA,
     const float32_t * pSrcB,
     uint32_t    blockSize,
     float32_t * result)
 {
-    float32x4_t vecA, vecB;
-    float32x4_t vecSum;
+    f32x4_t vecA, vecB;
+    f32x4_t vecSum;
+    uint32_t blkCnt; 
+    float32_t sum = 0.0f;  
     vecSum = vdupq_n_f32(0.0);
 
-    do {
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
         /*
          * C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1]
          * Calculate dot product and then store the result in a temporary buffer.
+         * and advance vector source and destination pointers
          */
-        mve_pred16_t p = vctp32q(blockSize);
+        vecA = vld1q(pSrcA);
+        pSrcA += 4;
+        
+        vecB = vld1q(pSrcB);
+        pSrcB += 4;
 
-        vecA = vldrwq_z_f32(pSrcA, p);
-        vecB = vldrwq_z_f32(pSrcB, p);
-        vecSum = vfmaq_m(vecSum, vecA, vecB, p);
+        vecSum = vfmaq(vecSum, vecA, vecB);
         /*
          * Decrement the blockSize loop counter
-         * Advance vector source and destination pointers
          */
-        post_incr_vec_size(pSrcA);
-        post_incr_vec_size(pSrcB);
-        blockSize -= VEC_LANES_F32;
+        blkCnt --;
     }
-    while ((int32_t) blockSize > 0);
 
-    *result = vecAddAcrossF32Mve(vecSum);
+
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0U)
+    {
+        /* C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1] */
+
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vecSum = vfmaq_m(vecSum, vecA, vecB, p0);
+    }
+
+    sum = vecAddAcrossF32Mve(vecSum);
+
+    /* Store result in destination buffer */
+    *result = sum;
+
 }
 
 #else
@@ -108,11 +128,11 @@ void arm_dot_prod_f32(
         uint32_t blkCnt;                               /* Loop counter */
         float32_t sum = 0.0f;                          /* Temporary return variable */
 
-#if defined(ARM_MATH_NEON)
-    float32x4_t vec1;
-    float32x4_t vec2;
-    float32x4_t res;
-    float32x4_t accum = vdupq_n_f32(0);    
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    f32x4_t vec1;
+    f32x4_t vec2;
+    f32x4_t res;
+    f32x4_t accum = vdupq_n_f32(0);    
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
@@ -125,7 +145,7 @@ void arm_dot_prod_f32(
         /* C = A[0]*B[0] + A[1]*B[1] + A[2]*B[2] + ... + A[blockSize-1]*B[blockSize-1] */
         /* Calculate dot product and then store the result in a temporary buffer. */
         
-	accum = vmlaq_f32(accum, vec1, vec2);
+	      accum = vmlaq_f32(accum, vec1, vec2);
 	
         /* Increment pointers */
         pSrcA += 4;
@@ -148,7 +168,7 @@ void arm_dot_prod_f32(
     blkCnt = blockSize & 0x3;
 
 #else
-#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;
@@ -198,7 +218,7 @@ void arm_dot_prod_f32(
   *result = sum;
 }
 
-#endif /* ARM_MATH_HELIUM */
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 /**
   @} end of BasicDotProd group
  */

Source/BasicMathFunctions/arm_dot_prod_q15.c

@@ -52,7 +52,58 @@
                    there is no risk of overflow.
                    The return result is in 34.30 format.
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_dot_prod_q15(
+    const q15_t * pSrcA,
+    const q15_t * pSrcB,
+    uint32_t blockSize,
+    q63_t * result)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q15x8_t vecA;
+    q15x8_t vecB;
+    q63_t     sum = 0LL;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1]
+         * Calculate dot product and then store the result in a temporary buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        sum = vmlaldavaq(sum, vecA, vecB);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA += 8;
+        pSrcB += 8;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        sum = vmlaldavaq_p(sum, vecA, vecB, p0);
+    }
+
+    *result = sum;
+}
+
+#else
 void arm_dot_prod_q15(
   const q15_t * pSrcA,
   const q15_t * pSrcB,
@@ -114,6 +165,7 @@ void arm_dot_prod_q15(
   /* Store result in destination buffer in 34.30 format */
   *result = sum;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicDotProd group

Source/BasicMathFunctions/arm_dot_prod_q31.c

@@ -54,6 +54,64 @@
                    The return result is in 16.48 format.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_dot_prod_q31(
+    const q31_t * pSrcA,
+    const q31_t * pSrcB,
+    uint32_t blockSize,
+    q63_t * result)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q31x4_t vecA;
+    q31x4_t vecB;
+    q63_t     sum = 0LL;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1]
+         * Calculate dot product and then store the result in a temporary buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        sum = vrmlaldavhaq(sum, vecA, vecB);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA += 4;
+        pSrcB += 4;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        sum = vrmlaldavhaq_p(sum, vecA, vecB, p0);
+    }
+
+    /*
+     * vrmlaldavhaq provides extra intermediate accumulator headroom.
+     * limiting the need of intermediate scaling
+     * Scalar variant uses 2.48 accu format by right shifting accumulators by 14.
+     * 16.48 output conversion is performed outside the loop by scaling accu. by 6
+     */
+    *result = asrl(sum, (14 - 8));
+}
+
+#else
 void arm_dot_prod_q31(
   const q31_t * pSrcA,
   const q31_t * pSrcB,
@@ -109,6 +167,7 @@ void arm_dot_prod_q31(
   /* Store result in destination buffer in 16.48 format */
   *result = sum;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicDotProd group

Source/BasicMathFunctions/arm_dot_prod_q7.c

@@ -53,6 +53,57 @@
                    The return result is in 18.14 format.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_dot_prod_q7(
+    const q7_t * pSrcA,
+    const q7_t * pSrcB,
+    uint32_t blockSize,
+    q31_t * result)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q7x16_t vecA;
+    q7x16_t vecB;
+    q31_t     sum = 0;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A[0]* B[0] + A[1]* B[1] + A[2]* B[2] + .....+ A[blockSize-1]* B[blockSize-1]
+         * Calculate dot product and then store the result in a temporary buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        sum = vmladavaq(sum, vecA, vecB);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA += 16;
+        pSrcB += 16;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        sum = vmladavaq_p(sum, vecA, vecB, p0);
+    }
+
+    *result = sum;
+}
+#else
 void arm_dot_prod_q7(
   const q7_t * pSrcA,
   const q7_t * pSrcB,
@@ -133,6 +184,7 @@ void arm_dot_prod_q7(
   /* Store result in destination buffer in 18.14 format */
   *result = sum;
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicDotProd group

Source/BasicMathFunctions/arm_mult_f32.c

@@ -58,6 +58,57 @@
   @return        none
  */
 
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_mult_f32(
+  const float32_t * pSrcA,
+  const float32_t * pSrcB,
+        float32_t * pDst,
+        uint32_t blockSize)
+{
+    uint32_t blkCnt;                               /* Loop counter */
+
+    f32x4_t vec1;
+    f32x4_t vec2;
+    f32x4_t res;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+        /* C = A + B */
+
+      /* Add and then store the results in the destination buffer. */
+        vec1 = vld1q(pSrcA);
+        vec2 = vld1q(pSrcB);
+        res = vmulq(vec1, vec2);
+        vst1q(pDst, res);
+
+        /* Increment pointers */
+        pSrcA += 4;
+        pSrcB += 4; 
+        pDst += 4;
+        
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+    if (blkCnt > 0U)
+    {
+      /* C = A + B */
+      mve_pred16_t p0 = vctp32q(blkCnt);
+      vec1 = vld1q(pSrcA);
+      vec2 = vld1q(pSrcB);
+      vstrwq_p(pDst, vmulq(vec1,vec2), p0);
+    }
+
+}
+
+#else
 void arm_mult_f32(
   const float32_t * pSrcA,
   const float32_t * pSrcB,
@@ -66,10 +117,10 @@ void arm_mult_f32(
 {
     uint32_t blkCnt;                               /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    float32x4_t vec1;
-    float32x4_t vec2;
-    float32x4_t res;
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    f32x4_t vec1;
+    f32x4_t vec2;
+    f32x4_t res;
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
@@ -97,7 +148,7 @@ void arm_mult_f32(
     blkCnt = blockSize & 0x3;
 
 #else
-#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;
@@ -142,6 +193,7 @@ void arm_mult_f32(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of BasicMult group

Source/BasicMathFunctions/arm_mult_q15.c

@@ -49,7 +49,55 @@
                    The function uses saturating arithmetic.
                    Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_mult_q15(
+    const q15_t * pSrcA,
+    const q15_t * pSrcB,
+    q15_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q15x8_t vecA, vecB;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A * B
+         * Multiply the inputs and then store the results in the destination buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vst1q(pDst, vqdmulhq(vecA, vecB));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA  += 8;
+        pSrcB  += 8;
+        pDst   += 8;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vstrhq_p(pDst, vqdmulhq(vecA, vecB), p0);
+    }
+}
+
+#else
 void arm_mult_q15(
   const q15_t * pSrcA,
   const q15_t * pSrcB,
@@ -137,6 +185,7 @@ void arm_mult_q15(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicMult group

Source/BasicMathFunctions/arm_mult_q31.c

@@ -49,7 +49,55 @@
                    The function uses saturating arithmetic.
                    Results outside of the allowable Q31 range[0x80000000 0x7FFFFFFF] are saturated.
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_mult_q31(
+    const q31_t * pSrcA,
+    const q31_t * pSrcB,
+    q31_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q31x4_t vecA, vecB;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A * B
+         * Multiply the inputs and then store the results in the destination buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vst1q(pDst, vqdmulhq(vecA, vecB));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA  += 4;
+        pSrcB  += 4;
+        pDst   += 4;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vstrwq_p(pDst, vqdmulhq(vecA, vecB), p0);
+    }
+}
+
+#else
 void arm_mult_q31(
   const q31_t * pSrcA,
   const q31_t * pSrcB,
@@ -113,6 +161,7 @@ void arm_mult_q31(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicMult group

Source/BasicMathFunctions/arm_mult_q7.c

@@ -49,7 +49,55 @@
                    The function uses saturating arithmetic.
                    Results outside of the allowable Q7 range [0x80 0x7F] are saturated.
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_mult_q7(
+    const q7_t * pSrcA,
+    const q7_t * pSrcB,
+    q7_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q7x16_t vecA, vecB;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A * B
+         * Multiply the inputs and then store the results in the destination buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vst1q(pDst, vqdmulhq(vecA, vecB));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA  += 16;
+        pSrcB  += 16;
+        pDst   += 16;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vstrbq_p(pDst, vqdmulhq(vecA, vecB), p0);
+    }
+}
+
+#else
 void arm_mult_q7(
   const q7_t * pSrcA,
   const q7_t * pSrcB,
@@ -113,6 +161,7 @@ void arm_mult_q7(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicMult group

Source/BasicMathFunctions/arm_negate_f32.c

@@ -59,6 +59,52 @@
   @return        none
  */
 
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_negate_f32(
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize)
+{
+    uint32_t blkCnt;                               /* Loop counter */
+    f32x4_t vec1;
+    f32x4_t res;
+
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+        /* C = |A| */
+
+        /* Calculate absolute values and then store the results in the destination buffer. */
+        vec1 = vld1q(pSrc);
+        res = vnegq(vec1);
+        vst1q(pDst, res);
+
+        /* Increment pointers */
+        pSrc += 4;
+        pDst += 4;
+        
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+    if (blkCnt > 0U)
+    {
+      /* C = |A| */
+      mve_pred16_t p0 = vctp32q(blkCnt);
+      vec1 = vld1q((float32_t const *) pSrc);
+      vstrwq_p(pDst, vnegq(vec1), p0);
+    }
+
+}
+
+#else
 void arm_negate_f32(
   const float32_t * pSrc,
         float32_t * pDst,
@@ -66,9 +112,9 @@ void arm_negate_f32(
 {
         uint32_t blkCnt;                               /* Loop counter */
 
-#if defined(ARM_MATH_NEON_EXPERIMENTAL)
-    float32x4_t vec1;
-    float32x4_t res;
+#if defined(ARM_MATH_NEON_EXPERIMENTAL) && !defined(ARM_MATH_AUTOVECTORIZE)
+    f32x4_t vec1;
+    f32x4_t res;
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
@@ -94,7 +140,7 @@ void arm_negate_f32(
     blkCnt = blockSize & 0x3;
 
 #else
-#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;
@@ -139,6 +185,7 @@ void arm_negate_f32(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of BasicNegate group

Source/BasicMathFunctions/arm_negate_q15.c

@@ -50,7 +50,51 @@
                    The function uses saturating arithmetic.
                    The Q15 value -1 (0x8000) is saturated to the maximum allowable positive value 0x7FFF.
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_negate_q15(
+    const q15_t  * pSrc,
+    q15_t  * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q15x8_t vecSrc;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = -A
+         * Negate and then store the results in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vst1q(pDst, vqnegq(vecSrc));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 8;
+        pDst += 8;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrhq_p(pDst, vqnegq(vecSrc), p0);
+    }
+}
+
+#else
 void arm_negate_q15(
   const q15_t * pSrc,
         q15_t * pDst,
@@ -120,6 +164,7 @@ void arm_negate_q15(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicNegate group

Source/BasicMathFunctions/arm_negate_q31.c

@@ -49,6 +49,51 @@
                    The Q31 value -1 (0x80000000) is saturated to the maximum allowable positive value 0x7FFFFFFF.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_negate_q31(
+    const q31_t * pSrc,
+    q31_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q31x4_t vecSrc;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = -A
+         * Negate and then store the results in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vst1q(pDst, vqnegq(vecSrc));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 4;
+        pDst += 4;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrwq_p(pDst, vqnegq(vecSrc), p0);
+    }
+}
+
+#else
 void arm_negate_q31(
   const q31_t * pSrc,
         q31_t * pDst,
@@ -126,6 +171,7 @@ void arm_negate_q31(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicNegate group

Source/BasicMathFunctions/arm_negate_q7.c

@@ -48,7 +48,51 @@
                    The function uses saturating arithmetic.
                    The Q7 value -1 (0x80) is saturated to the maximum allowable positive value 0x7F.
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_negate_q7(
+    const q7_t   * pSrc,
+    q7_t   * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q7x16_t vecSrc;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = -A
+         * Negate and then store the results in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vst1q(pDst, vqnegq(vecSrc));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 16;
+        pDst += 16;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrbq_p(pDst, vqnegq(vecSrc), p0);
+    }
+}
+
+#else
 void arm_negate_q7(
   const q7_t * pSrc,
         q7_t * pDst,
@@ -110,7 +154,7 @@ void arm_negate_q7(
     in = *pSrc++;
 
 #if defined (ARM_MATH_DSP)
-    *pDst++ = (q7_t) __QSUB(0, in);
+    *pDst++ = (q7_t) __QSUB8(0, in);
 #else
     *pDst++ = (in == (q7_t) 0x80) ? (q7_t) 0x7f : -in;
 #endif
@@ -120,6 +164,7 @@ void arm_negate_q7(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicNegate group

Source/BasicMathFunctions/arm_offset_f32.c

@@ -60,6 +60,54 @@
   @return        none
  */
 
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_offset_f32(
+  const float32_t * pSrc,
+        float32_t offset,
+        float32_t * pDst,
+        uint32_t blockSize)
+{
+        uint32_t blkCnt;                               /* Loop counter */
+
+    f32x4_t vec1;
+    f32x4_t res;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+    while (blkCnt > 0U)
+    {
+        /* C = A + offset */
+ 
+        /* Add offset and then store the results in the destination buffer. */
+        vec1 = vld1q(pSrc);
+        res = vaddq(vec1,offset);
+        vst1q(pDst, res);
+
+        /* Increment pointers */
+        pSrc += 4;
+        pDst += 4;
+        
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vec1 = vld1q((float32_t const *) pSrc);
+        vstrwq_p(pDst, vaddq(vec1, offset), p0);
+    }
+
+
+}
+
+#else
 void arm_offset_f32(
   const float32_t * pSrc,
         float32_t offset,
@@ -68,9 +116,9 @@ void arm_offset_f32(
 {
         uint32_t blkCnt;                               /* Loop counter */
 
-#if defined(ARM_MATH_NEON_EXPERIMENTAL)
-    float32x4_t vec1;
-    float32x4_t res;
+#if defined(ARM_MATH_NEON_EXPERIMENTAL) && !defined(ARM_MATH_AUTOVECTORIZE)
+    f32x4_t vec1;
+    f32x4_t res;
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
@@ -96,7 +144,7 @@ void arm_offset_f32(
     blkCnt = blockSize & 0x3;
 
 #else
-#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;
@@ -141,6 +189,7 @@ void arm_offset_f32(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of BasicOffset group

Source/BasicMathFunctions/arm_offset_q15.c

@@ -49,7 +49,53 @@
                    The function uses saturating arithmetic.
                    Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_offset_q15(
+    const q15_t * pSrc,
+    q15_t   offset,
+    q15_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q15x8_t vecSrc;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A + offset
+         * Add offset and then store the result in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vst1q(pDst, vqaddq(vecSrc, offset));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 8;
+        pDst += 8;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrhq_p(pDst, vqaddq(vecSrc, offset), p0);
+    }
+}
+
+
+#else
 void arm_offset_q15(
   const q15_t * pSrc,
         q15_t offset,
@@ -115,6 +161,7 @@ void arm_offset_q15(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicOffset group

Source/BasicMathFunctions/arm_offset_q31.c

@@ -50,6 +50,52 @@
                    Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_offset_q31(
+    const q31_t * pSrc,
+    q31_t   offset,
+    q31_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q31x4_t vecSrc;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A + offset
+         * Add offset and then store the result in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vst1q(pDst, vqaddq(vecSrc, offset));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 4;
+        pDst += 4;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrwq_p(pDst, vqaddq(vecSrc, offset), p0);
+    }
+}
+
+#else
 void arm_offset_q31(
   const q31_t * pSrc,
         q31_t offset,
@@ -122,6 +168,7 @@ void arm_offset_q31(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicOffset group

Source/BasicMathFunctions/arm_offset_q7.c

@@ -49,7 +49,52 @@
                    The function uses saturating arithmetic.
                    Results outside of the allowable Q7 range [0x80 0x7F] are saturated.
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_offset_q7(
+    const q7_t * pSrc,
+    q7_t   offset,
+    q7_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q7x16_t vecSrc;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A + offset
+         * Add offset and then store the result in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vst1q(pDst, vqaddq(vecSrc, offset));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 16;
+        pDst += 16;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrbq_p(pDst, vqaddq(vecSrc, offset), p0);
+    }
+}
+
+#else
 void arm_offset_q7(
   const q7_t * pSrc,
         q7_t offset,
@@ -110,6 +155,7 @@ void arm_offset_q7(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicOffset group

Source/BasicMathFunctions/arm_scale_f32.c

@@ -73,6 +73,55 @@
   @return        none
  */
 
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_scale_f32(
+  const float32_t * pSrc,
+        float32_t scale,
+        float32_t * pDst,
+        uint32_t blockSize)
+{
+        uint32_t blkCnt;                               /* Loop counter */
+
+    f32x4_t vec1;
+    f32x4_t res;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+
+    while (blkCnt > 0U)
+    {
+        /* C = A + offset */
+ 
+        /* Add offset and then store the results in the destination buffer. */
+        vec1 = vld1q(pSrc);
+        res = vmulq(vec1,scale);
+        vst1q(pDst, res);
+
+        /* Increment pointers */
+        pSrc += 4;
+        pDst += 4;
+        
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vec1 = vld1q((float32_t const *) pSrc);
+        vstrwq_p(pDst, vmulq(vec1, scale), p0);
+    }
+
+
+}
+
+#else
 void arm_scale_f32(
   const float32_t *pSrc,
         float32_t scale,
@@ -81,8 +130,8 @@ void arm_scale_f32(
 {
   uint32_t blkCnt;                               /* Loop counter */
 #if defined(ARM_MATH_NEON_EXPERIMENTAL)
-    float32x4_t vec1;
-    float32x4_t res;
+    f32x4_t vec1;
+    f32x4_t res;
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
@@ -153,6 +202,7 @@ void arm_scale_f32(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of BasicScale group

Source/BasicMathFunctions/arm_scale_q15.c

@@ -51,6 +51,62 @@
                    These are multiplied to yield a 2.30 intermediate result and this is shifted with saturation to 1.15 format.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_scale_q15(
+    const q15_t * pSrc,
+    q15_t   scaleFract,
+    int8_t  shift,
+    q15_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q15x8_t vecSrc;
+    q15x8_t vecDst;
+
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A * scale
+         * Scale the input and then store the result in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vecDst = vmulhq(vecSrc, vdupq_n_s16(scaleFract));
+        vecDst = vqshlq_r(vecDst, shift + 1);
+        vst1q(pDst, vecDst);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 8;
+        pDst += 8;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);;
+        vecSrc = vld1q(pSrc);
+        vecDst = vmulhq(vecSrc, vdupq_n_s16(scaleFract));
+        vecDst = vqshlq_r(vecDst, shift + 1);
+        vstrhq_p(pDst, vecDst, p0);
+    }
+
+}
+
+
+#else
 void arm_scale_q15(
   const q15_t *pSrc,
         q15_t scaleFract,
@@ -138,6 +194,7 @@ void arm_scale_q15(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicScale group

Source/BasicMathFunctions/arm_scale_q31.c

@@ -51,6 +51,58 @@
                    These are multiplied to yield a 2.62 intermediate result and this is shifted with saturation to 1.31 format.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_scale_q31(
+    const q31_t * pSrc,
+    q31_t   scaleFract,
+    int8_t  shift,
+    q31_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q31x4_t vecSrc;
+    q31x4_t vecDst;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A * scale
+         * Scale the input and then store the result in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vecDst = vmulhq(vecSrc, vdupq_n_s32(scaleFract));
+        vecDst = vqshlq_r(vecDst, shift + 1);
+        vst1q(pDst, vecDst);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 4;
+        pDst += 4;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vecDst = vmulhq(vecSrc, vdupq_n_s32(scaleFract));
+        vecDst = vqshlq_r(vecDst, shift + 1);
+        vstrwq_p(pDst, vecDst, p0);
+    }
+}
+
+#else
 void arm_scale_q31(
   const q31_t *pSrc,
         q31_t scaleFract,
@@ -185,6 +237,7 @@ void arm_scale_q31(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicScale group

Source/BasicMathFunctions/arm_scale_q7.c

@@ -51,6 +51,62 @@
                    These are multiplied to yield a 2.14 intermediate result and this is shifted with saturation to 1.7 format.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+
+void arm_scale_q7(
+    const q7_t * pSrc,
+    q7_t   scaleFract,
+    int8_t  shift,
+    q7_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q7x16_t vecSrc;
+    q7x16_t vecDst;
+
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A * scale
+         * Scale the input and then store the result in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vecDst = vmulhq(vecSrc, vdupq_n_s8(scaleFract));
+        vecDst = vqshlq_r(vecDst, shift + 1);
+        vst1q(pDst, vecDst);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 16;
+        pDst += 16;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vecDst = vmulhq(vecSrc, vdupq_n_s8(scaleFract));
+        vecDst = vqshlq_r(vecDst, shift + 1);
+        vstrbq_p(pDst, vecDst, p0);
+    }
+
+}
+
+#else
 void arm_scale_q7(
   const q7_t * pSrc,
         q7_t scaleFract,
@@ -123,6 +179,7 @@ void arm_scale_q7(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicScale group

Source/BasicMathFunctions/arm_shift_q15.c

@@ -50,6 +50,55 @@
                    Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_shift_q15(
+    const q15_t * pSrc,
+    int8_t shiftBits,
+    q15_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q15x8_t vecSrc;
+    q15x8_t vecDst;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A (>> or <<) shiftBits
+         * Shift the input and then store the result in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vecDst = vqshlq_r(vecSrc, shiftBits);
+        vst1q(pDst, vecDst);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 8;
+        pDst += 8;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vecDst = vqshlq_r(vecSrc, shiftBits);
+        vstrhq_p(pDst, vecDst, p0);
+    }
+}
+
+#else
 void arm_shift_q15(
   const q15_t * pSrc,
         int8_t shiftBits,
@@ -195,6 +244,7 @@ void arm_shift_q15(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicShift group

Source/BasicMathFunctions/arm_shift_q31.c

@@ -67,6 +67,56 @@
                    Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_shift_q31(
+    const q31_t * pSrc,
+    int8_t shiftBits,
+    q31_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q31x4_t vecSrc;
+    q31x4_t vecDst;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A (>> or <<) shiftBits
+         * Shift the input and then store the result in the destination buffer.
+         */
+        vecSrc = vld1q((q31_t const *) pSrc);
+        vecDst = vqshlq_r(vecSrc, shiftBits);
+        vst1q(pDst, vecDst);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 4;
+        pDst += 4;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecSrc = vld1q((q31_t const *) pSrc);
+        vecDst = vqshlq_r(vecSrc, shiftBits);
+        vstrwq_p(pDst, vecDst, p0);
+    }
+}
+
+
+#else
 void arm_shift_q31(
   const q31_t * pSrc,
         int8_t shiftBits,
@@ -175,6 +225,7 @@ void arm_shift_q31(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicShift group

Source/BasicMathFunctions/arm_shift_q7.c

@@ -52,6 +52,55 @@
                    Results outside of the allowable Q7 range [0x80 0x7F] are saturated.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_shift_q7(
+    const q7_t * pSrc,
+    int8_t shiftBits,
+    q7_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q7x16_t vecSrc;
+    q7x16_t vecDst;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A (>> or <<) shiftBits
+         * Shift the input and then store the result in the destination buffer.
+         */
+        vecSrc = vld1q(pSrc);
+        vecDst = vqshlq_r(vecSrc, shiftBits);
+        vst1q(pDst, vecDst);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrc += 16;
+        pDst += 16;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vecDst = vqshlq_r(vecSrc, shiftBits);
+        vstrbq_p(pDst, vecDst, p0);
+    }
+}
+
+#else
 void arm_shift_q7(
   const q7_t * pSrc,
         int8_t shiftBits,
@@ -169,6 +218,7 @@ void arm_shift_q7(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicShift group

Source/BasicMathFunctions/arm_sub_f32.c

@@ -58,6 +58,59 @@
   @return        none
  */
 
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_sub_f32(
+  const float32_t * pSrcA,
+  const float32_t * pSrcB,
+        float32_t * pDst,
+        uint32_t blockSize)
+{
+    uint32_t blkCnt;                               /* Loop counter */
+
+    f32x4_t vec1;
+    f32x4_t vec2;
+    f32x4_t res;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2U;
+
+    while (blkCnt > 0U)
+    {
+        /* C = A + B */
+
+      /* Add and then store the results in the destination buffer. */
+        vec1 = vld1q(pSrcA);
+        vec2 = vld1q(pSrcB);
+        res = vsubq(vec1, vec2);
+        vst1q(pDst, res);
+
+        /* Increment pointers */
+        pSrcA += 4;
+        pSrcB += 4; 
+        pDst += 4;
+        
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0x3;
+
+    if (blkCnt > 0U)
+    {
+      /* C = A + B */
+      mve_pred16_t p0 = vctp32q(blkCnt);
+      vec1 = vld1q(pSrcA);
+      vec2 = vld1q(pSrcB);
+      vstrwq_p(pDst, vsubq(vec1,vec2), p0);
+    }
+
+}
+
+#else
 void arm_sub_f32(
   const float32_t * pSrcA,
   const float32_t * pSrcB,
@@ -66,10 +119,10 @@ void arm_sub_f32(
 {
         uint32_t blkCnt;                               /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    float32x4_t vec1;
-    float32x4_t vec2;
-    float32x4_t res;
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    f32x4_t vec1;
+    f32x4_t vec2;
+    f32x4_t res;
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
@@ -97,7 +150,7 @@ void arm_sub_f32(
     blkCnt = blockSize & 0x3;
 
 #else
-#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;
@@ -142,6 +195,7 @@ void arm_sub_f32(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
 
 /**
   @} end of BasicSub group

Source/BasicMathFunctions/arm_sub_q15.c

@@ -50,6 +50,57 @@
                    Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_sub_q15(
+    const q15_t * pSrcA,
+    const q15_t * pSrcB,
+    q15_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q15x8_t vecA;
+    q15x8_t vecB;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A - B
+         * Subtract and then store the results in the destination buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vst1q(pDst, vqsubq(vecA, vecB));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA  += 8;
+        pSrcB  += 8;
+        pDst   += 8;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vstrhq_p(pDst, vqsubq(vecA, vecB), p0);
+    }
+}
+
+
+#else
 void arm_sub_q15(
   const q15_t * pSrcA,
   const q15_t * pSrcB,
@@ -120,6 +171,7 @@ void arm_sub_q15(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicSub group

Source/BasicMathFunctions/arm_sub_q31.c

@@ -50,6 +50,56 @@
                    Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.
  */
 
+#if defined(ARM_MATH_MVEI)
+
+#include "arm_helium_utils.h"
+
+void arm_sub_q31(
+  const q31_t * pSrcA,
+  const q31_t * pSrcB,
+        q31_t * pDst,
+        uint32_t blockSize)
+{
+    uint32_t blkCnt;   
+    q31x4_t vecA;
+    q31x4_t vecB;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A + B
+         * Add and then store the results in the destination buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vst1q(pDst, vqsubq(vecA, vecB));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA  += 4;
+        pSrcB  += 4;
+        pDst   += 4;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vstrwq_p(pDst, vqsubq(vecA, vecB), p0);
+    }
+}
+
+#else
 void arm_sub_q31(
   const q31_t * pSrcA,
   const q31_t * pSrcB,
@@ -102,6 +152,7 @@ void arm_sub_q31(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicSub group

Source/BasicMathFunctions/arm_sub_q7.c

@@ -49,7 +49,55 @@
                    The function uses saturating arithmetic.
                    Results outside of the allowable Q7 range [0x80 0x7F] will be saturated.
  */
+#if defined(ARM_MATH_MVEI)
 
+#include "arm_helium_utils.h"
+
+void arm_sub_q7(
+    const q7_t * pSrcA,
+    const q7_t * pSrcB,
+    q7_t * pDst,
+    uint32_t blockSize)
+{
+    uint32_t  blkCnt;           /* loop counters */
+    q7x16_t vecA;
+    q7x16_t vecB;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0U)
+    {
+        /*
+         * C = A - B
+         * Subtract and then store the results in the destination buffer.
+         */
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vst1q(pDst, vqsubq(vecA, vecB));
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+        /*
+         * advance vector source and destination pointers
+         */
+        pSrcA  += 16;
+        pSrcB  += 16;
+        pDst   += 16;
+    }
+    /*
+     * tail
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecA = vld1q(pSrcA);
+        vecB = vld1q(pSrcB);
+        vstrbq_p(pDst, vqsubq(vecA, vecB), p0);
+    }
+}
+#else
 void arm_sub_q7(
   const q7_t * pSrcA,
   const q7_t * pSrcB,
@@ -103,6 +151,7 @@ void arm_sub_q7(
   }
 
 }
+#endif /* defined(ARM_MATH_MVEI) */
 
 /**
   @} end of BasicSub group

Source/FilteringFunctions/arm_lms_norm_f32.c

@@ -126,7 +126,7 @@
                    - Scaling of coefficients
                    - Overflow and saturation
 
- @par            Scaling of Coefficients
+ @par            Scaling of Coefficients (fixed point versions)
                    Filter coefficients are represented as fractional values and
                    coefficients are restricted to lie in the range <code>[-1 +1)</code>.
                    The fixed-point functions have an additional scaling parameter <code>postShift</code>.
@@ -135,7 +135,7 @@
                    allows the filter coefficients to exceed the range <code>[+1 -1)</code>.
                    The value of <code>postShift</code> is set by the user based on the expected gain through the system being modeled.
 
- @par            Overflow and Saturation
+ @par            Overflow and Saturation (fixed point versions)
                    Overflow and saturation behavior of the fixed-point Q15 and Q31 versions are
                    described separately as part of the function specific documentation below.
  */

Testing/CMakeLists.txt

@@ -139,6 +139,9 @@ else()
 
 set(TESTSRC 
   Source/Tests/BasicTestsF32.cpp
+  Source/Tests/BasicTestsQ31.cpp
+  Source/Tests/BasicTestsQ15.cpp
+  Source/Tests/BasicTestsQ7.cpp
   Source/Tests/SVMF32.cpp
   Source/Tests/BayesF32.cpp
   Source/Tests/TransformF32.cpp

Testing/FrameworkInclude/FPGA.h

@@ -59,6 +59,7 @@ FPGA driver. Used to read a C array describing how to drive the test.
 
       virtual void ImportPattern_f64(Testing::PatternID_t,char*,Testing::nbSamples_t nb);
       virtual void ImportPattern_f32(Testing::PatternID_t,char*,Testing::nbSamples_t nb);
+      virtual void ImportPattern_q63(Testing::PatternID_t,char*,Testing::nbSamples_t nb);
       virtual void ImportPattern_q31(Testing::PatternID_t,char*,Testing::nbSamples_t nb);
       virtual void ImportPattern_q15(Testing::PatternID_t,char*,Testing::nbSamples_t nb);
       virtual void ImportPattern_q7(Testing::PatternID_t,char*,Testing::nbSamples_t nb);
@@ -73,6 +74,7 @@ FPGA driver. Used to read a C array describing how to drive the test.
 
       virtual void DumpPattern_f64(Testing::outputID_t,Testing::nbSamples_t nb, float64_t* data);
       virtual void DumpPattern_f32(Testing::outputID_t,Testing::nbSamples_t nb, float32_t* data);
+      virtual void DumpPattern_q63(Testing::outputID_t,Testing::nbSamples_t nb, q63_t* data);
       virtual void DumpPattern_q31(Testing::outputID_t,Testing::nbSamples_t nb, q31_t* data);
       virtual void DumpPattern_q15(Testing::outputID_t,Testing::nbSamples_t nb, q15_t* data);
       virtual void DumpPattern_q7(Testing::outputID_t,Testing::nbSamples_t nb, q7_t* data);

Testing/FrameworkInclude/Pattern.h

@@ -45,6 +45,9 @@ float64_t *loadPattern(Testing::PatternID_t id, PatternMgr *mgr,Testing::nbSampl
 template <>
 float32_t *loadPattern(Testing::PatternID_t id, PatternMgr *mgr,Testing::nbSamples_t &nb, Testing::nbSamples_t maxSamples);
 
+template <>
+q63_t *loadPattern(Testing::PatternID_t id, PatternMgr *mgr,Testing::nbSamples_t &nb, Testing::nbSamples_t maxSamples);
+
 template <>
 q31_t *loadPattern(Testing::PatternID_t id, PatternMgr *mgr,Testing::nbSamples_t &nb, Testing::nbSamples_t maxSamples);
 
@@ -75,6 +78,9 @@ float64_t *localPattern(Testing::nbSamples_t nb, PatternMgr *mgr);
 template <>
 float32_t *localPattern(Testing::nbSamples_t nb, PatternMgr *mgr);
 
+template <>
+q63_t *localPattern(Testing::nbSamples_t nb, PatternMgr *mgr);
+
 template <>
 q31_t *localPattern(Testing::nbSamples_t nb, PatternMgr *mgr);
 
@@ -95,6 +101,7 @@ uint8_t *localPattern(Testing::nbSamples_t nb, PatternMgr *mgr);
 
 extern void dumpPattern(Testing::outputID_t id,Testing::nbSamples_t nb,float64_t* data,PatternMgr *mgr);
 extern void dumpPattern(Testing::outputID_t id,Testing::nbSamples_t,float32_t*,PatternMgr *);
+extern void dumpPattern(Testing::outputID_t id,Testing::nbSamples_t,q63_t*,PatternMgr *);
 extern void dumpPattern(Testing::outputID_t id,Testing::nbSamples_t,q31_t*,PatternMgr *);
 extern void dumpPattern(Testing::outputID_t id,Testing::nbSamples_t,q15_t*,PatternMgr *);
 extern void dumpPattern(Testing::outputID_t id,Testing::nbSamples_t,q7_t*,PatternMgr *);

Testing/FrameworkInclude/Semihosting.h

@@ -63,6 +63,7 @@ Semihosting driver. Used to read a text file describing how to drive the test.
       
       virtual void ImportPattern_f64(Testing::PatternID_t,char*,Testing::nbSamples_t nb=0);
       virtual void ImportPattern_f32(Testing::PatternID_t,char*,Testing::nbSamples_t nb=0);
+      virtual void ImportPattern_q63(Testing::PatternID_t,char*,Testing::nbSamples_t nb=0);
       virtual void ImportPattern_q31(Testing::PatternID_t,char*,Testing::nbSamples_t nb=0);
       virtual void ImportPattern_q15(Testing::PatternID_t,char*,Testing::nbSamples_t nb=0);
       virtual void ImportPattern_q7(Testing::PatternID_t,char*,Testing::nbSamples_t nb=0);
@@ -78,6 +79,7 @@ Semihosting driver. Used to read a text file describing how to drive the test.
 
       virtual void DumpPattern_f64(Testing::outputID_t,Testing::nbSamples_t nb, float64_t*);
       virtual void DumpPattern_f32(Testing::outputID_t,Testing::nbSamples_t nb, float32_t*);
+      virtual void DumpPattern_q63(Testing::outputID_t,Testing::nbSamples_t nb, q63_t*);
       virtual void DumpPattern_q31(Testing::outputID_t,Testing::nbSamples_t nb, q31_t*);
       virtual void DumpPattern_q15(Testing::outputID_t,Testing::nbSamples_t nb, q15_t*);
       virtual void DumpPattern_q7(Testing::outputID_t,Testing::nbSamples_t nb, q7_t*);

Testing/FrameworkInclude/Test.h

@@ -280,6 +280,7 @@ API of Memory managers used in the test framework
       */
       virtual void ImportPattern_f64(Testing::PatternID_t,char*,Testing::nbSamples_t nb=MAX_NB_SAMPLES)=0;
       virtual void ImportPattern_f32(Testing::PatternID_t,char*,Testing::nbSamples_t nb=MAX_NB_SAMPLES)=0;
+      virtual void ImportPattern_q63(Testing::PatternID_t,char*,Testing::nbSamples_t nb=MAX_NB_SAMPLES)=0;
       virtual void ImportPattern_q31(Testing::PatternID_t,char*,Testing::nbSamples_t nb=MAX_NB_SAMPLES)=0;
       virtual void ImportPattern_q15(Testing::PatternID_t,char*,Testing::nbSamples_t nb=MAX_NB_SAMPLES)=0;
       virtual void ImportPattern_q7(Testing::PatternID_t,char*,Testing::nbSamples_t nb=MAX_NB_SAMPLES)=0;
@@ -308,6 +309,7 @@ API of Memory managers used in the test framework
       */
       virtual void DumpPattern_f64(Testing::outputID_t,Testing::nbSamples_t nb, float64_t*)=0;
       virtual void DumpPattern_f32(Testing::outputID_t,Testing::nbSamples_t nb, float32_t*)=0;
+      virtual void DumpPattern_q63(Testing::outputID_t,Testing::nbSamples_t nb, q63_t*)=0;
       virtual void DumpPattern_q31(Testing::outputID_t,Testing::nbSamples_t nb, q31_t*)=0;
       virtual void DumpPattern_q15(Testing::outputID_t,Testing::nbSamples_t nb, q15_t*)=0;
       virtual void DumpPattern_q7(Testing::outputID_t,Testing::nbSamples_t nb, q7_t*)=0;
@@ -386,6 +388,7 @@ public:
     */
     float64_t *load_f64(Testing::PatternID_t,Testing::nbSamples_t&,Testing::nbSamples_t maxSamples=MAX_NB_SAMPLES);
     float32_t *load_f32(Testing::PatternID_t,Testing::nbSamples_t&,Testing::nbSamples_t maxSamples=MAX_NB_SAMPLES);
+    q63_t *load_q63(Testing::PatternID_t,Testing::nbSamples_t&,Testing::nbSamples_t maxSamples=MAX_NB_SAMPLES);
     q31_t *load_q31(Testing::PatternID_t,Testing::nbSamples_t&,Testing::nbSamples_t maxSamples=MAX_NB_SAMPLES);
     q15_t *load_q15(Testing::PatternID_t,Testing::nbSamples_t&,Testing::nbSamples_t maxSamples=MAX_NB_SAMPLES);
     q7_t *load_q7(Testing::PatternID_t,Testing::nbSamples_t&,Testing::nbSamples_t maxSamples=MAX_NB_SAMPLES);
@@ -402,6 +405,7 @@ public:
     */
     float64_t *local_f64(Testing::nbSamples_t);
     float32_t *local_f32(Testing::nbSamples_t);
+    q63_t *local_q63(Testing::nbSamples_t);
     q31_t *local_q31(Testing::nbSamples_t);
     q15_t *local_q15(Testing::nbSamples_t);
     q7_t *local_q7(Testing::nbSamples_t);
@@ -416,6 +420,7 @@ public:
     void dumpPattern_f64(Testing::outputID_t,Testing::nbSamples_t,float64_t*);
     void dumpPattern_f32(Testing::outputID_t,Testing::nbSamples_t,float32_t*);
 
+    void dumpPattern_q63(Testing::outputID_t,Testing::nbSamples_t,q63_t*);
     void dumpPattern_q31(Testing::outputID_t,Testing::nbSamples_t,q31_t*);
     void dumpPattern_q15(Testing::outputID_t,Testing::nbSamples_t,q15_t*);
     void dumpPattern_q7(Testing::outputID_t,Testing::nbSamples_t,q7_t*);

Testing/FrameworkSource/Error.cpp

@@ -187,8 +187,8 @@ float arm_snr_q15(q15_t *pRef, q15_t *pTest, uint32_t buffSize)
 {
   float EnergySignal = 0.0, EnergyError = 0.0;
   uint32_t i;
-  float SNR;
- 
+  float SNR; 
+
   float32_t testVal,refVal;
 
   for (i = 0; i < buffSize; i++)
@@ -331,6 +331,7 @@ void assert_snr_error(unsigned long nb,AnyPattern<q15_t> &pa,AnyPattern<q15_t> &
 
    snr = arm_snr_q15(ptrA, ptrB, pa.nbSamples());
 
+   //printf("SNR = %f\n",snr);
 
    if (snr < threshold)
    {
@@ -353,6 +354,7 @@ void assert_snr_error(unsigned long nb,AnyPattern<q7_t> &pa,AnyPattern<q7_t> &pb
 
    snr = arm_snr_q7(ptrA, ptrB, pa.nbSamples());
 
+   //printf("SNR = %f\n",snr);
 
    if (snr < threshold)
    {

Testing/FrameworkSource/FPGA.cpp

@@ -96,6 +96,10 @@ namespace Client
       delete(this->outputNames);
     }
 
+    /** Read word 64 from C array
+
+    */
+
     /** Read word 32 from C array
 
     */
@@ -531,6 +535,25 @@ namespace Client
 
     }
 
+    void FPGA::ImportPattern_q63(Testing::PatternID_t id,char* p,Testing::nbSamples_t nb)
+    {
+        unsigned long offset,i;
+
+        offset=this->getPatternOffset(id);
+
+        const char *patternStart = this->m_patterns + offset;
+        const q63_t *src = (const q63_t*)patternStart;
+        q63_t *dst = (q63_t*)p;
+
+        if (dst)
+        {
+           for(i=0; i < nb; i++)
+           {
+               *dst++ = *src++;
+           }
+        }
+    }
+
     void FPGA::ImportPattern_q31(Testing::PatternID_t id,char* p,Testing::nbSamples_t nb)
     {
         unsigned long offset,i;
@@ -691,6 +714,25 @@ namespace Client
         }
     }
 
+    void FPGA::DumpPattern_q63(Testing::outputID_t id,Testing::nbSamples_t nb, q63_t* data)
+    {
+        std::string fileName = this->getOutputPath(id); 
+        if (data)
+        {
+           printf("D: %s\n",fileName.c_str());
+           Testing::nbSamples_t i=0;
+           uint64_t t;
+           q63_t v;
+           for(i=0; i < nb; i++)
+           {
+              v = data[i];
+              t = (uint64_t)v;
+              printf("D: 0x%016llx\n",t);
+           }
+           printf("D: END\n");
+        }
+    }
+
     void FPGA::DumpPattern_q31(Testing::outputID_t id,Testing::nbSamples_t nb, q31_t* data)
     {
         std::string fileName = this->getOutputPath(id); 

Testing/FrameworkSource/Pattern.cpp

@@ -45,6 +45,12 @@ float32_t *loadPattern(Testing::PatternID_t id, Client::PatternMgr *mgr,Testing:
     return(mgr->load_f32(id,nb,maxSamples));
 }
 
+template <> 
+q63_t *loadPattern(Testing::PatternID_t id, Client::PatternMgr *mgr,Testing::nbSamples_t &nb, Testing::nbSamples_t maxSamples)
+{
+    return(mgr->load_q63(id,nb,maxSamples));
+}
+
 template <> 
 q31_t *loadPattern(Testing::PatternID_t id, Client::PatternMgr *mgr,Testing::nbSamples_t &nb, Testing::nbSamples_t maxSamples)
 {
@@ -94,6 +100,12 @@ float32_t *localPattern(Testing::PatternID_t id, Client::PatternMgr *mgr)
     return(mgr->local_f32(id));
 }
 
+template <> 
+q63_t *localPattern(Testing::PatternID_t id, Client::PatternMgr *mgr)
+{
+    return(mgr->local_q63(id));
+}
+
 template <> 
 q31_t *localPattern(Testing::PatternID_t id, Client::PatternMgr *mgr)
 {
@@ -140,6 +152,11 @@ void dumpPattern(Testing::outputID_t id,Testing::nbSamples_t nbSamples,float32_t
   mgr->dumpPattern_f32(id,nbSamples,data);
 }
 
+void dumpPattern(Testing::outputID_t id,Testing::nbSamples_t nbSamples,q63_t* data,PatternMgr *mgr)
+{
+  mgr->dumpPattern_q63(id,nbSamples,data);
+}
+
 void dumpPattern(Testing::outputID_t id,Testing::nbSamples_t nbSamples,q31_t* data,PatternMgr *mgr)
 {
   mgr->dumpPattern_q31(id,nbSamples,data);

Testing/FrameworkSource/PatternMgr.cpp

@@ -46,6 +46,7 @@ TYPE *PatternMgr::local_##EXT(Testing::nbSamples_t nbSamples) \
 
 LOCAL(float64_t,f64)
 LOCAL(float32_t,f32)
+LOCAL(q63_t,q63)
 LOCAL(q31_t,q31)
 LOCAL(q15_t,q15)
 LOCAL(q7_t,q7)
@@ -90,6 +91,24 @@ float32_t *PatternMgr::load_f32(Testing::PatternID_t id,Testing::nbSamples_t& nb
    
 }
 
+q63_t *PatternMgr::load_q63(Testing::PatternID_t id,Testing::nbSamples_t& nbSamples,Testing::nbSamples_t maxSamples)
+{
+    nbSamples=m_io->GetPatternSize(id);
+
+    if ((maxSamples != MAX_NB_SAMPLES) && (maxSamples < nbSamples))
+    {
+        nbSamples = maxSamples;
+    }
+
+    char *b = m_mem->NewBuffer(sizeof(q63_t)*nbSamples);
+    if (b != NULL)
+    {
+       m_io->ImportPattern_q63(id,b,nbSamples);
+    }
+    return((q63_t*)b);
+}
+
+
 q31_t *PatternMgr::load_q31(Testing::PatternID_t id,Testing::nbSamples_t& nbSamples,Testing::nbSamples_t maxSamples)
 {
     nbSamples=m_io->GetPatternSize(id);
@@ -203,6 +222,11 @@ void PatternMgr::dumpPattern_f32(Testing::outputID_t id,Testing::nbSamples_t nbS
    m_io->DumpPattern_f32(id,nbSamples,data);
 }
 
+void PatternMgr::dumpPattern_q63(Testing::outputID_t id,Testing::nbSamples_t nbSamples,q63_t* data)
+{
+   m_io->DumpPattern_q63(id,nbSamples,data);
+}
+
 void PatternMgr::dumpPattern_q31(Testing::outputID_t id,Testing::nbSamples_t nbSamples,q31_t* data)
 {
    m_io->DumpPattern_q31(id,nbSamples,data);

Testing/FrameworkSource/Semihosting.cpp

@@ -663,6 +663,44 @@ namespace Client
           
       }
 
+      void Semihosting::ImportPattern_q63(Testing::PatternID_t id,char* p,Testing::nbSamples_t nb)
+      {
+          char tmp[256];
+          Testing::nbSamples_t len;
+          Testing::nbSamples_t i=0;
+
+          uint64_t val;
+          q63_t *ptr=(q63_t*)p;
+
+          std::string fileName = this->getPatternPath(id);
+          FILE *pattern=fopen(fileName.c_str(), "r");
+          // Ignore word size format
+          fgets(tmp,256,pattern);
+          // Get nb of samples
+          fgets(tmp,256,pattern);
+          len=atoi(tmp);
+
+          if ((nb != MAX_NB_SAMPLES) && (nb < len))
+          {
+             len = nb;
+          }
+
+          if (ptr)
+          {
+             for(i=0;i<len;i++)
+             {
+               // Ignore comment
+                fgets(tmp,256,pattern);
+                fscanf(pattern,"0x%016llX\n",&val);
+                *ptr = TOTYP(q63_t,val);
+                ptr++;
+             }
+          }
+
+          fclose(pattern);
+          
+      }
+
       void Semihosting::ImportPattern_q31(Testing::PatternID_t id,char* p,Testing::nbSamples_t nb)
       {
           char tmp[256];
@@ -928,6 +966,24 @@ namespace Client
                fclose(f);
             }
       }
+
+      void Semihosting::DumpPattern_q63(Testing::outputID_t id,Testing::nbSamples_t nb, q63_t* data)
+      {
+            std::string fileName = this->getOutputPath(id);
+            if (data)
+            {
+                FILE *f = fopen(fileName.c_str(),"w");
+                Testing::nbSamples_t i=0;
+                uint64_t t;
+                for(i=0; i < nb; i++)
+                {
+                   t = (uint64_t)data[i];
+                   fprintf(f,"0x%016llx\n",t);
+                }
+                fclose(f);
+            }
+      }
+
       void Semihosting::DumpPattern_q31(Testing::outputID_t id,Testing::nbSamples_t nb, q31_t* data)
       {
             std::string fileName = this->getOutputPath(id);

Testing/Include/Benchmarks/BasicMathsBenchmarksF32.h

@@ -12,10 +12,15 @@ class BasicMathsBenchmarksF32:public Client::Suite
             Client::Pattern<float32_t> input2;
             Client::LocalPattern<float32_t> output;
 
+            Client::RefPattern<float32_t> ref;
+
+
             int nb;
 
             float32_t *inp1;
             float32_t *inp2;
             float32_t *outp;
+
+            float32_t *refp;
             
     };

Testing/Include/Tests/BasicTestsQ15.h

@@ -0,0 +1,25 @@
+#include "Test.h"
+#include "Pattern.h"
+class BasicTestsQ15:public Client::Suite
+    {
+        public:
+            BasicTestsQ15(Testing::testID_t id);
+            virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr);
+            virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "BasicTestsQ15_decl.h"
+            
+            Client::Pattern<q15_t> input1;
+            Client::Pattern<q15_t> input2;
+
+            Client::LocalPattern<q15_t> output;
+            Client::LocalPattern<q63_t> dotOutput;
+
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<q15_t> ref;
+
+            Client::RefPattern<q63_t> dotRef;
+
+            /* Offset or scale value */
+            q15_t scalar;
+    };

Testing/Include/Tests/BasicTestsQ31.h

@@ -0,0 +1,25 @@
+#include "Test.h"
+#include "Pattern.h"
+class BasicTestsQ31:public Client::Suite
+    {
+        public:
+            BasicTestsQ31(Testing::testID_t id);
+            virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr);
+            virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "BasicTestsQ31_decl.h"
+            
+            Client::Pattern<q31_t> input1;
+            Client::Pattern<q31_t> input2;
+
+            Client::LocalPattern<q31_t> output;
+            Client::LocalPattern<q63_t> dotOutput;
+
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<q31_t> ref;
+
+            Client::RefPattern<q63_t> dotRef;
+
+            /* Offset or scale value */
+            q31_t scalar;
+    };

Testing/Include/Tests/BasicTestsQ7.h

@@ -0,0 +1,25 @@
+#include "Test.h"
+#include "Pattern.h"
+class BasicTestsQ7:public Client::Suite
+    {
+        public:
+            BasicTestsQ7(Testing::testID_t id);
+            virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr);
+            virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "BasicTestsQ7_decl.h"
+            
+            Client::Pattern<q7_t> input1;
+            Client::Pattern<q7_t> input2;
+
+            Client::LocalPattern<q7_t> output;
+            Client::LocalPattern<q31_t> dotOutput;
+
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<q7_t> ref;
+
+            Client::RefPattern<q31_t> dotRef;
+
+            /* Offset or scale value */
+            q7_t scalar;
+    };

Testing/PatternGeneration/BasicMaths.py

@@ -7,7 +7,7 @@ import Tools
 # Those patterns are used for tests and benchmarks.
 # For tests, there is the need to add tests for saturation
 
-def writeTests(config):
+def writeTests(config,format):
     NBSAMPLES=256
 
     data1=np.random.randn(NBSAMPLES)
@@ -39,16 +39,31 @@ def writeTests(config):
     config.writeReference(6, ref)
     
     nb = 3
-    ref = np.array([np.dot(data1[0:nb] ,data2[0:nb])])
-    config.writeReference(7, ref)
+    ref = np.array([np.dot(data1[0:nb] ,data2[0:nb])]) / 2**15
+    if format == 31 or format == 15:
+       config.writeReferenceQ63(7, ref)
+    elif format == 7:
+       config.writeReferenceQ31(7, ref)
+    else:
+       config.writeReference(7, ref)
     
     nb = 8
-    ref = np.array([np.dot(data1[0:nb] ,data2[0:nb])])
-    config.writeReference(8, ref)
+    ref = np.array([np.dot(data1[0:nb] ,data2[0:nb])]) / 2**15
+    if format == 31 or format == 15:
+       config.writeReferenceQ63(8, ref)
+    elif format == 7:
+       config.writeReferenceQ31(8, ref)
+    else:
+       config.writeReference(8, ref)
     
     nb = 9
-    ref = np.array([np.dot(data1[0:nb] ,data2[0:nb])])
-    config.writeReference(9, ref)
+    ref = np.array([np.dot(data1[0:nb] ,data2[0:nb])]) / 2**15
+    if format == 31 or format == 15:
+       config.writeReferenceQ63(9, ref)
+    elif format == 7:
+       config.writeReferenceQ31(9, ref)
+    else:
+       config.writeReference(9, ref)
     
     ref = abs(data1)
     config.writeReference(10, ref)
@@ -56,6 +71,88 @@ def writeTests(config):
     ref = np.array([np.dot(data1 ,data2)])
     config.writeReference(11, ref)
 
+    return(11)
+
+
+def writeTestsWithSat(config,format):
+    if format == 31:
+       NBSAMPLES=9
+
+    if format == 15:
+       NBSAMPLES=17
+
+    if format == 7:
+       NBSAMPLES=33
+
+    nb = writeTests(config,format)
+
+    data1 = np.full(NBSAMPLES, 2**format - 1)
+    data1[1::2] = 2
+    data2 = np.full(NBSAMPLES, -2**format)
+    data2[1::2] = -2
+
+    datar=np.random.randn(NBSAMPLES)
+    datar = datar/max(datar)
+    datar = datar / 3.0 # Because used to test shift of 2 without saturation
+
+    config.writeInput(12, datar)
+
+    if format == 31:
+       config.writeInputS32(12,data1-1,"MaxPosInput")
+       config.writeInputS32(12,data2+1,"MaxNegInput")
+       config.writeInputS32(12,data2,"MaxNeg2Input")
+
+    if format == 15:
+       config.writeInputS16(12,data1-1,"MaxPosInput")
+       config.writeInputS16(12,data2+1,"MaxNegInput")
+       config.writeInputS16(12,data2,"MaxNeg2Input")
+
+    if format == 7:
+       config.writeInputS8(12,data1-1,"MaxPosInput")
+       config.writeInputS8(12,data2+1,"MaxNegInput")
+       config.writeInputS8(12,data2,"MaxNeg2Input")
+       
+    d1 = 1.0*(data1-1) / 2**format
+    d2 = 1.0*(data2+1) / 2**format
+    d3 = 1.0*(data2) / 2**format
+
+    ref = d1 + d1
+    config.writeReference(nb+1, ref,"PosSat")
+    ref = d2 + d2
+    config.writeReference(nb+2, ref,"NegSat")
+
+    d1 = 1.0*(data1-1) / 2**format
+    d2 = 1.0*(data2+1) / 2**format
+    ref = d1 - d2
+    config.writeReference(nb+3, ref,"PosSat")
+
+    ref = d2 - d1
+    config.writeReference(nb+4, ref,"NegSat")
+
+    ref = d3*d3
+    config.writeReference(nb+5, ref,"PosSat")
+
+    ref = -d3
+    config.writeReference(nb+6, ref,"PosSat")
+
+    ref = d1 + 0.9
+    config.writeReference(nb+7, ref,"PosSat")
+    ref = d2 - 0.9
+    config.writeReference(nb+8, ref,"NegSat")
+
+    ref = d3 * d3[0]
+    config.writeReference(nb+9, ref,"PosSat")
+
+    ref = datar * 2.0
+    config.writeReference(nb+10, ref,"Shift")
+
+    ref = d1 * 2.0
+    config.writeReference(nb+11, ref,"Shift")
+
+    ref = d2 * 2.0
+    config.writeReference(nb+12, ref,"Shift")
+
+
 
 PATTERNDIR = os.path.join("Patterns","DSP","BasicMaths","BasicMaths")
 PARAMDIR = os.path.join("Parameters","DSP","BasicMaths","BasicMaths")
@@ -67,10 +164,10 @@ configq7=Tools.Config(PATTERNDIR,PARAMDIR,"q7")
 
 
 
-writeTests(configf32)
-writeTests(configq31)
-writeTests(configq15)
-writeTests(configq7)
+#writeTests(configf32,0)
+writeTestsWithSat(configq31,31)
+writeTestsWithSat(configq15,15)
+writeTestsWithSat(configq7,7)
 
 # Params just as example
 someLists=[[1,3,5],[1,3,5],[1,3,5]]

Testing/PatternGeneration/Tools.py

@@ -52,6 +52,14 @@ def float64_to_hex(f):
     """
     return hex(struct.unpack('<Q', struct.pack('<d', f))[0])
 
+def to_q63(v):
+    r = int(round(v * 2**63))
+    if (r > 0x07FFFFFFFFFFFFFFF):
+      r = 0x07FFFFFFFFFFFFFFF
+    if (r < -0x08000000000000000):
+      r = -0x08000000000000000
+    return ("0x%s" % format(struct.unpack('<Q', struct.pack('<q', r))[0],'016X'))
+
 def to_q31(v):
     r = int(round(v * 2**31))
     if (r > 0x07FFFFFFF):
@@ -113,6 +121,21 @@ class Config:
         else:
           return(os.path.join(self._patternDir,"Input%d_%s.txt" % (i,self._ext)))
 
+    def inputS32P(self,i,name=None):
+        """ Path to a reference pattern from the ID
+      
+        Args:
+          i (int): ID to the reference pattern
+        Raises:
+          Nothing 
+        Returns:
+          str : path to the file where to generate the pattern data
+        """
+        if name:
+          return(os.path.join(self._patternDir,"%s%d_%s.txt" % (name,i,"s32")))
+        else:
+          return(os.path.join(self._patternDir,"Input%d_%s.txt" % (i,"s32")))
+
     def inputS16P(self,i,name=None):
         """ Path to a reference pattern from the ID
       
@@ -128,6 +151,21 @@ class Config:
         else:
           return(os.path.join(self._patternDir,"Input%d_%s.txt" % (i,"s16")))
 
+    def inputS8P(self,i,name=None):
+        """ Path to a reference pattern from the ID
+      
+        Args:
+          i (int): ID to the reference pattern
+        Raises:
+          Nothing 
+        Returns:
+          str : path to the file where to generate the pattern data
+        """
+        if name:
+          return(os.path.join(self._patternDir,"%s%d_%s.txt" % (name,i,"s8")))
+        else:
+          return(os.path.join(self._patternDir,"Input%d_%s.txt" % (i,"s8")))
+
     def inputQ31P(self,i,name=None):
         """ Path to a reference pattern from the ID
       
@@ -248,6 +286,36 @@ class Config:
         else:
           return(os.path.join(self._patternDir,"Reference%d_%s.txt" % (i,"s32")))
 
+    def refQ63P(self,i,name=None):
+        """ Path to a reference pattern from the ID
+      
+        Args:
+          i (int): ID to the reference pattern
+        Raises:
+          Nothing 
+        Returns:
+          str : path to the file where to generate the pattern data
+        """
+        if name:
+          return(os.path.join(self._patternDir,"%s%d_%s.txt" % (name,i,"q63")))
+        else:
+          return(os.path.join(self._patternDir,"Reference%d_%s.txt" % (i,"q63")))
+
+    def refQ31P(self,i,name=None):
+        """ Path to a reference pattern from the ID
+      
+        Args:
+          i (int): ID to the reference pattern
+        Raises:
+          Nothing 
+        Returns:
+          str : path to the file where to generate the pattern data
+        """
+        if name:
+          return(os.path.join(self._patternDir,"%s%d_%s.txt" % (name,i,"q31")))
+        else:
+          return(os.path.join(self._patternDir,"Reference%d_%s.txt" % (i,"q31")))
+
     def refF32P(self,i,name=None):
         """ Path to a reference pattern from the ID
       
@@ -328,6 +396,31 @@ class Config:
                 f.write("// %f\n" % v)
                 f.write("%s\n" % float_to_hex(v))
 
+    def _writeVectorQ63(self,i,data):
+        """ Write pattern data
+        
+        The format is recognized by the text framework script.
+        First line is the sample width (B,H or W for 8,16 or 32 bits)
+        Second line is number of samples
+        Other lines are hexadecimal representation of the samples in format
+        which can be read on big endian ARM.
+        
+          Args:
+            j (int): ID of pattern file
+            data (array): Vector containing the data
+          Raises:
+            Nothing 
+          Returns:
+            Nothing
+        """
+        with open(i,"w") as f:
+            # Write sample dimension nb sample header
+            #np.savetxt(i, data, newline="\n", header="W\n%d" % len(data),comments ="" )
+            f.write("D\n%d\n" % len(data))
+            for v in data:
+                f.write("// %f\n" % v)
+                f.write("%s\n" % to_q63(v))
+
     def _writeVectorQ31(self,i,data):
         """ Write pattern data
         
@@ -508,6 +601,8 @@ class Config:
           self._writeVectorF64(self.refP(j,name),data)
         if (self._ext == "f32"):
           self._writeVectorF32(self.refP(j,name),data)
+        if (self._ext == "q63"):
+          self._writeVectorQ63(self.refP(j,name),data)
         if (self._ext == "q31"):
           self._writeVectorQ31(self.refP(j,name),data)
         if (self._ext == "q15"):
@@ -519,6 +614,12 @@ class Config:
         if (self._ext == "s8"):
           self._writeVectorS8(self.refP(j,name),data)
 
+    def writeReferenceQ63(self,j,data,name=None):
+        self._writeVectorQ63(self.refQ63P(j,name),data)
+
+    def writeReferenceQ31(self,j,data,name=None):
+        self._writeVectorQ31(self.refQ31P(j,name),data)
+
     def writeReferenceS8(self,j,data,name=None):
         self._writeVectorS8(self.refS8P(j,name),data)
 
@@ -556,9 +657,15 @@ class Config:
     def writeInputQ7(self,j,data,name=None):
         self._writeVectorQ7(self.inputQ7P(j,name),data)
 
+    def writeInputS32(self,j,data,name=None):
+        self._writeVectorS32(self.inputS32P(j,name),data)
+
     def writeInputS16(self,j,data,name=None):
         self._writeVectorS16(self.inputS16P(j,name),data)
 
+    def writeInputS8(self,j,data,name=None):
+        self._writeVectorS8(self.inputS8P(j,name),data)
+
     def writeInputU32(self,j,data,name=None):
         self._writeVectorU32(self.inputU32P(j,name),data)
 

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Input12_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// -0.127026
+0xEFBE
+// 0.135563
+0x115A
+// -0.055957
+0xF8D6
+// 0.005012
+0x00A4
+// 0.049539
+0x0657
+// 0.143211
+0x1255
+// 0.041455
+0x054E
+// -0.054525
+0xF905
+// 0.016068
+0x020F
+// -0.120403
+0xF097
+// 0.097939
+0x0C89
+// -0.110690
+0xF1D5
+// 0.333333
+0x2AAB
+// 0.004649
+0x0098
+// 0.090070
+0x0B87
+// 0.027590
+0x0388
+// 0.058612
+0x0781

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Input1_q15.txt

@@ -1,514 +1,514 @@
 H
 256
-// -0.291372
-0xDAB4
-// 0.112738
-0x0E6E
-// 0.238117
-0x1E7B
-// 0.038878
-0x04FA
-// 0.294852
-0x25BE
-// -0.107647
-0xF239
-// 0.769109
-0x6272
-// 0.084075
-0x0AC3
-// 0.329781
-0x2A36
-// 0.320584
-0x2909
-// 0.219050
-0x1C0A
-// 0.190578
-0x1865
-// 0.165900
-0x153C
-// 0.281091
-0x23FB
-// -1.020124
-0x8000
-// 0.675056
-0x5668
-// -0.283130
-0xDBC2
-// 0.773159
-0x62F7
-// -0.722326
-0xA38B
-// -0.322220
-0xD6C1
-// -0.348974
-0xD355
-// 0.595221
-0x4C30
-// -0.069654
-0xF716
-// 0.136401
-0x1176
-// 0.367788
-0x2F14
-// -0.275101
-0xDCC9
-// 0.652923
-0x5393
-// -0.172436
-0xE9EE
-// 0.114230
-0x0E9F
-// 0.203455
-0x1A0B
-// 0.118325
-0x0F25
-// 0.299473
-0x2655
-// -0.096281
-0xF3AD
-// 0.853706
-0x6D46
-// -1.017484
-0x8000
-// 0.130138
-0x10A8
-// 0.245529
-0x1F6D
-// 0.148787
-0x130B
-// 0.544863
-0x45BE
-// 0.112934
-0x0E75
-// 0.946172
-0x791C
-// -0.132993
-0xEEFA
-// 0.065405
-0x085F
-// -0.186642
-0xE81C
-// -0.756814
-0x9F21
-// 0.105861
-0x0D8D
-// -0.437403
-0xC803
-// -0.081627
-0xF58D
-// -0.006338
-0xFF30
-// 0.268326
-0x2259
-// -0.092221
-0xF432
-// 0.106395
-0x0D9E
-// 0.081742
-0x0A77
-// -0.034894
-0xFB89
-// -0.772030
-0x9D2E
-// 0.195714
-0x190D
-// 0.113011
-0x0E77
-// 0.320860
-0x2912
-// -0.040862
-0xFAC5
-// 0.227119
-0x1D12
-// 0.316674
-0x2889
-// 0.097933
-0x0C89
-// 0.199199
-0x197F
-// -0.079258
-0xF5DB
-// -0.626025
-0xAFDE
-// -0.755253
-0x9F54
-// -0.360077
-0xD1E9
-// -0.534840
-0xBB8A
-// -0.126088
-0xEFDC
-// 0.165333
-0x152A
-// -0.157822
-0xEBCC
-// 0.426616
-0x369B
-// -0.057844
-0xF899
-// 0.240266
-0x1EC1
-// -0.438159
-0xC7EA
-// -0.373584
-0xD02E
-// -0.402123
-0xCC87
-// 0.360179
-0x2E1A
-// 0.505158
-0x40A9
-// -0.095831
-0xF3BC
-// -0.046939
-0xF9FE
-// -0.746193
-0xA07D
-// 0.042432
-0x056E
-// -0.768082
-0x9DAF
-// -0.218351
-0xE40D
-// -0.271949
-0xDD31
-// 0.689579
-0x5844
-// -0.324210
-0xD680
-// -0.938547
-0x87DE
-// 0.417882
-0x357D
-// -0.179682
-0xE900
-// -0.075396
-0xF659
-// 0.411513
-0x34AC
-// 0.079135
-0x0A21
-// -0.149243
-0xECE6
-// 0.411160
-0x34A1
-// 0.131389
-0x10D1
-// -0.037460
-0xFB35
-// -0.068980
-0xF72C
-// -0.217882
-0xE41C
-// 0.361686
-0x2E4C
-// -0.396804
-0xCD36
+// -0.391039
+0xCDF2
+// -0.132494
+0xEF0A
+// -0.324339
+0xD67C
+// 0.239965
+0x1EB7
+// 0.287413
+0x24CA
+// -0.307525
+0xD8A3
+// -0.082443
+0xF573
+// -0.235917
+0xE1CD
+// 0.449457
+0x3988
+// -0.413851
+0xCB07
+// 0.281545
+0x240A
+// -0.393602
+0xCD9E
+// 0.635543
+0x5159
+// -0.028199
+0xFC64
+// -0.247774
+0xE049
+// -0.426651
+0xC963
+// 0.094929
+0x0C27
+// -0.147548
+0xED1D
+// 0.151437
+0x1362
+// -0.103162
+0xF2CC
 // 1.000000
 0x7FFF
-// 0.861870
-0x6E52
-// -0.492371
-0xC0FA
-// 0.475058
-0x3CCF
-// 0.326745
-0x29D3
-// -0.022422
-0xFD21
-// -0.723679
-0xA35E
-// 0.198195
-0x195E
-// -0.215361
-0xE46F
-// -0.379118
-0xCF79
-// 0.118425
-0x0F29
-// 0.216039
-0x1BA7
-// -0.216784
-0xE440
-// -0.658123
-0xABC3
-// -0.922551
-0x89EA
-// -0.171079
-0xEA1A
-// 0.971339
-0x7C55
-// -0.004590
-0xFF6A
-// -0.124396
-0xF014
-// -0.043263
-0xFA76
-// -0.143471
-0xEDA3
-// -0.329250
-0xD5DB
-// -0.686717
-0xA81A
-// -0.028428
-0xFC5C
-// -0.681094
-0xA8D2
-// 0.489830
-0x3EB3
-// 0.259075
-0x2129
-// -0.352294
-0xD2E8
-// 0.129524
-0x1094
-// -0.197127
-0xE6C5
-// 0.269581
-0x2282
-// -0.543085
-0xBA7C
-// -0.203516
-0xE5F3
-// 0.292197
-0x2567
-// -0.363223
-0xD182
-// -0.247482
-0xE052
-// -0.337804
-0xD4C3
-// 0.653685
-0x53AC
-// 0.313478
-0x2820
-// -0.225233
-0xE32C
-// -0.055920
-0xF8D8
-// -0.284999
-0xDB85
-// -0.016551
-0xFDE2
-// 0.351903
-0x2D0B
-// -0.489580
-0xC155
-// -0.074839
-0xF66C
-// -0.447269
-0xC6C0
-// -0.025272
-0xFCC4
-// -0.417648
-0xCA8B
-// 0.255674
-0x20BA
-// -0.256246
-0xDF33
-// -0.390200
-0xCE0E
-// -0.319831
-0xD710
-// 0.027698
-0x038C
-// 0.233688
-0x1DEA
-// 0.893321
-0x7258
-// -0.296030
-0xDA1C
-// 0.186033
-0x17D0
-// -0.291623
-0xDAAC
-// -0.472528
-0xC384
-// -0.380391
-0xCF4F
-// 0.299344
-0x2651
-// -0.043065
-0xFA7D
-// -0.214653
-0xE486
-// 0.484534
-0x3E05
-// -0.718725
-0xA401
-// 0.071545
-0x0928
-// -0.067909
-0xF74F
-// 0.403341
-0x33A1
-// -0.428537
-0xC926
-// 0.307753
-0x2764
-// -0.287282
-0xDB3A
-// -0.182047
-0xE8B3
-// -0.560512
-0xB841
-// 0.147036
-0x12D2
-// 0.543678
-0x4597
-// 0.726262
-0x5CF6
-// -0.123755
-0xF029
-// -0.236564
-0xE1B8
-// 0.711449
-0x5B11
-// 0.086785
-0x0B1C
-// -0.444971
-0xC70B
-// -0.224133
-0xE350
-// -0.021716
-0xFD38
-// 0.443658
-0x38CA
-// -0.250084
-0xDFFD
-// -0.364422
-0xD15B
-// 0.204438
-0x1A2B
-// 0.488969
-0x3E97
-// -0.622727
-0xB04A
-// -0.596908
-0xB399
-// -0.829206
-0x95DD
-// 0.284500
-0x246A
-// -0.051519
-0xF968
-// -0.296029
-0xDA1C
-// -0.276982
-0xDC8C
-// -0.535533
-0xBB74
-// -0.398493
-0xCCFE
-// 0.046804
-0x05FE
-// -0.083330
-0xF555
-// -0.041901
-0xFAA3
-// 0.071995
-0x0937
-// -0.121075
-0xF081
-// 0.699388
-0x5986
-// -0.484348
-0xC201
-// 0.027504
-0x0385
-// -0.488884
-0xC16C
-// 0.338561
-0x2B56
-// 0.317218
-0x289B
-// 0.533173
-0x443F
-// -0.161179
-0xEB5E
-// 0.110650
-0x0E2A
-// -0.576178
-0xB640
-// -0.426651
-0xC964
-// -0.150455
-0xECBE
-// -0.333766
-0xD547
-// 0.362308
-0x2E60
-// 0.590622
-0x4B99
-// -0.694183
-0xA725
-// 0.245185
-0x1F62
-// 0.014160
-0x01D0
-// 0.159924
-0x1478
-// 0.307676
-0x2762
-// -0.361295
-0xD1C1
-// -0.427751
-0xC93F
-// 0.299083
-0x2648
-// 0.319458
-0x28E4
-// -0.049485
-0xF9AA
-// 0.598299
-0x4C95
-// -0.464446
-0xC48D
-// -0.179628
-0xE902
-// 0.204011
-0x1A1D
-// 0.515296
-0x41F5
-// -0.070968
-0xF6EB
-// 0.163492
-0x14ED
-// 0.141388
-0x1219
-// 0.042870
-0x057D
-// -0.501338
-0xBFD4
-// 0.497520
-0x3FAF
-// 0.403774
-0x33AF
-// -0.520140
-0xBD6C
-// -0.070466
-0xF6FB
-// -0.358134
-0xD229
-// 0.284262
-0x2463
-// -0.997219
-0x805B
-// -0.836779
-0x94E4
-// 0.008837
-0x0122
-// -0.211862
-0xE4E2
-// 0.090126
-0x0B89
-// 0.052889
-0x06C5
-// 0.157819
-0x1433
-// 0.073654
-0x096E
-// 0.016595
-0x0220
-// 0.240174
-0x1EBE
+// -0.127316
+0xEFB4
+// 0.223084
+0x1C8E
+// -0.197370
+0xE6BD
+// -0.023579
+0xFCFB
+// 0.164779
+0x1517
+// 0.054862
+0x0706
+// 0.116807
+0x0EF4
+// 0.724476
+0x5CBC
+// 0.324554
+0x298B
+// 0.637242
+0x5191
+// -0.994701
+0x80AE
+// -0.153605
+0xEC57
+// 0.275814
+0x234E
+// -0.084495
+0xF52F
+// -0.652355
+0xAC80
+// -0.365086
+0xD145
+// -0.341305
+0xD450
+// 0.609822
+0x4E0F
+// 0.261556
+0x217B
+// -0.040176
+0xFADC
+// 0.013211
+0x01B1
+// -0.630985
+0xAF3C
+// 0.257101
+0x20E9
+// 0.263646
+0x21BF
+// -0.707048
+0xA57F
+// 0.007630
+0x00FA
+// 0.372092
+0x2FA1
+// 0.200446
+0x19A8
+// -0.691038
+0xA78C
+// 0.020442
+0x029E
+// 0.741753
+0x5EF2
+// -0.270967
+0xDD51
+// 0.149906
+0x1330
+// 0.155500
+0x13E7
+// 0.069104
+0x08D8
+// 0.046970
+0x0603
+// 0.050831
+0x0682
+// -0.523837
+0xBCF3
+// -0.453239
+0xC5FC
+// -0.108311
+0xF223
+// -0.271445
+0xDD41
+// -0.196582
+0xE6D6
+// 0.317899
+0x28B1
+// 0.296574
+0x25F6
+// -0.773282
+0x9D05
+// 0.098481
+0x0C9B
+// 0.577823
+0x49F6
+// -0.239237
+0xE161
+// -0.111604
+0xF1B7
+// 0.350488
+0x2CDD
+// -0.974917
+0x8336
+// -0.474137
+0xC34F
+// 0.233892
+0x1DF0
+// -0.660819
+0xAB6A
+// -0.336884
+0xD4E1
+// -0.328735
+0xD5EC
+// 0.602986
+0x4D2F
+// -0.076045
+0xF644
+// -0.299000
+0xD9BA
+// -0.020428
+0xFD63
+// -0.179805
+0xE8FC
+// 0.386969
+0x3188
+// 0.113119
+0x0E7B
+// 0.009004
+0x0127
+// 0.839391
+0x6B71
+// 0.136101
+0x116C
+// -0.379279
+0xCF74
+// -0.578833
+0xB5E9
+// -0.264163
+0xDE30
+// 0.533847
+0x4455
+// 0.409433
+0x3468
+// 0.334975
+0x2AE0
+// -0.151882
+0xEC8F
+// -0.132220
+0xEF13
+// -0.179417
+0xE909
+// -0.188481
+0xE7E0
+// 0.506994
+0x40E5
+// 0.471158
+0x3C4F
+// 0.150447
+0x1342
+// -0.568105
+0xB748
+// 0.206037
+0x1A5F
+// 0.336932
+0x2B21
+// 0.128105
+0x1066
+// -0.608755
+0xB214
+// -0.216292
+0xE451
+// -0.327339
+0xD61A
+// 0.074259
+0x0981
+// -0.192190
+0xE766
+// -0.550959
+0xB97A
+// -0.034023
+0xFBA5
+// -0.384915
+0xCEBB
+// 0.415263
+0x3527
+// -0.513936
+0xBE37
+// 0.409222
+0x3461
+// 0.235739
+0x1E2D
+// 0.513779
+0x41C4
+// 0.080366
+0x0A49
+// 0.008089
+0x0109
+// -0.665939
+0xAAC2
+// -0.553521
+0xB926
+// -0.118488
+0xF0D5
+// -0.452754
+0xC60C
+// 0.189352
+0x183D
+// -0.236447
+0xE1BC
+// 0.029425
+0x03C4
+// -0.532288
+0xBBDE
+// -0.158685
+0xEBB0
+// 0.207125
+0x1A83
+// -0.256558
+0xDF29
+// 0.279340
+0x23C1
+// 0.175831
+0x1682
+// 0.342134
+0x2BCB
+// -0.333585
+0xD54D
+// -0.790520
+0x9AD0
+// -0.604685
+0xB29A
+// 0.433929
+0x378B
+// 0.211268
+0x1B0B
+// -0.536812
+0xBB4A
+// -0.248849
+0xE026
+// -0.525246
+0xBCC5
+// -0.362304
+0xD1A0
+// -0.472568
+0xC383
+// 0.393772
+0x3267
+// -0.023451
+0xFD00
+// 0.706359
+0x5A6A
+// -0.369775
+0xD0AB
+// -0.527837
+0xBC70
+// -0.187832
+0xE7F5
+// 0.163702
+0x14F4
+// -0.743740
+0xA0CD
+// -0.268361
+0xDDA6
+// -0.107554
+0xF23C
+// 0.407995
+0x3439
+// 0.391583
+0x321F
+// 0.218611
+0x1BFB
+// -0.493020
+0xC0E5
+// 0.372303
+0x2FA8
+// 0.001229
+0x0028
+// 0.416385
+0x354C
+// 0.104454
+0x0D5F
+// 0.294703
+0x25B9
+// -0.000552
+0xFFEE
+// 0.163755
+0x14F6
+// -0.036916
+0xFB46
+// -0.272303
+0xDD25
+// -0.185096
+0xE84F
+// 0.184122
+0x1791
+// -0.556027
+0xB8D4
+// -0.713326
+0xA4B2
+// 0.076186
+0x09C0
+// 0.159486
+0x146A
+// 0.006846
+0x00E0
+// -0.048756
+0xF9C2
+// 0.445768
+0x390F
+// 0.025109
+0x0337
+// -0.557602
+0xB8A0
+// 0.089997
+0x0B85
+// -0.287693
+0xDB2D
+// 0.156651
+0x140D
+// 0.229572
+0x1D63
+// 0.409576
+0x346D
+// -0.232089
+0xE24B
+// 0.857708
+0x6DC9
+// 0.508076
+0x4109
+// -0.457783
+0xC567
+// 0.537929
+0x44DB
+// 0.078232
+0x0A04
+// 0.102995
+0x0D2F
+// 0.363774
+0x2E90
+// -0.340417
+0xD46D
+// 0.988812
+0x7E91
+// 0.727331
+0x5D19
+// -0.042403
+0xFA93
+// -1.248493
+0x8000
+// 0.018439
+0x025C
+// -0.080956
+0xF5A3
+// 0.498395
+0x3FCB
+// 0.242706
+0x1F11
+// -0.448147
+0xC6A3
+// -0.558205
+0xB88D
+// 0.168927
+0x159F
+// -0.365310
+0xD13E
+// 0.399500
+0x3323
+// -0.567251
+0xB764
+// 0.113547
+0x0E89
+// -0.566178
+0xB787
+// -0.675753
+0xA981
+// -0.082284
+0xF578
+// 0.263793
+0x21C4
+// 0.139256
+0x11D3
+// 0.563582
+0x4823
+// 0.170762
+0x15DC
+// 0.145771
+0x12A9
+// -0.224769
+0xE33B
+// 0.822337
+0x6942
+// 0.505253
+0x40AC
+// -0.150475
+0xECBD
+// 0.852788
+0x6D28
+// 0.229226
+0x1D57
+// 0.020920
+0x02AE
+// 0.717030
+0x5BC8
+// 0.420662
+0x35D8
+// -0.181715
+0xE8BE
+// -0.136679
+0xEE81
+// 0.198719
+0x1970
+// -0.780927
+0x9C0B
+// 0.316314
+0x287D
+// 0.337074
+0x2B25
+// 0.449962
+0x3998
+// -0.365087
+0xD145
+// -0.515723
+0xBDFD
+// 0.255542
+0x20B6
+// -0.464113
+0xC498
+// 0.136815
+0x1183
+// -0.483973
+0xC20D
+// 0.303115
+0x26CC
+// -0.516164
+0xBDEE
+// 0.063928
+0x082F
+// 0.477272
+0x3D17
+// -0.298325
+0xD9D0
+// -0.461789
+0xC4E4
+// 0.473654
+0x3CA1
+// -0.434329
+0xC868
+// -0.181605
+0xE8C1
+// -0.032139
+0xFBE3
+// -0.140397
+0xEE07
+// 0.286762
+0x24B5
+// -0.135101
+0xEEB5
+// -0.156372
+0xEBFC
+// -0.417922
+0xCA82
+// 0.128029
+0x1063
+// 0.290168
+0x2524
+// 0.230520
+0x1D82
+// -0.015709
+0xFDFD
+// -0.495071
+0xC0A2

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Input2_q15.txt

@@ -1,514 +1,514 @@
 H
 256
-// -0.093423
-0xF40B
-// 0.036147
-0x04A0
-// 0.076348
-0x09C6
-// 0.012466
-0x0198
-// 0.094539
-0x0C1A
-// -0.034515
-0xFB95
-// 0.246601
-0x1F91
-// 0.026957
-0x0373
-// 0.105738
-0x0D89
-// 0.102790
-0x0D28
-// 0.070235
-0x08FD
-// 0.061106
-0x07D2
-// 0.053193
-0x06CF
-// 0.090127
-0x0B89
-// -0.327085
-0xD622
-// 0.216445
-0x1BB4
-// -0.090781
-0xF461
-// 0.247900
-0x1FBB
-// -0.231601
-0xE25B
-// -0.103314
-0xF2C7
-// -0.111892
-0xF1AE
-// 0.190847
-0x186E
-// -0.022333
-0xFD24
-// 0.043735
-0x0599
-// 0.117925
-0x0F18
-// -0.088206
-0xF4B6
-// 0.209348
-0x1ACC
-// -0.055288
-0xF8EC
-// 0.036626
-0x04B0
-// 0.065234
-0x085A
-// 0.037939
-0x04DB
-// 0.096021
-0x0C4A
-// -0.030871
-0xFC0C
-// 0.273726
-0x2309
-// -0.326239
-0xD63E
-// 0.041727
-0x0557
-// 0.078724
-0x0A14
-// 0.047706
-0x061B
-// 0.174701
-0x165D
-// 0.036210
-0x04A3
-// 0.303374
-0x26D5
-// -0.042642
-0xFA8B
-// 0.020971
-0x02AF
-// -0.059844
-0xF857
-// -0.242659
-0xE0F1
-// 0.033942
-0x0458
-// -0.140246
-0xEE0C
-// -0.026172
-0xFCA6
-// -0.002032
-0xFFBD
-// 0.086034
-0x0B03
-// -0.029569
-0xFC37
-// 0.034114
-0x045E
-// 0.026209
-0x035B
-// -0.011188
-0xFE91
-// -0.247538
-0xE051
-// 0.062752
-0x0808
-// 0.036235
-0x04A3
-// 0.102878
-0x0D2B
-// -0.013102
-0xFE53
-// 0.072822
-0x0952
-// 0.101536
-0x0CFF
-// 0.031400
-0x0405
-// 0.063870
-0x082D
-// -0.025413
-0xFCBF
-// -0.200724
-0xE64F
-// -0.242159
-0xE101
-// -0.115452
-0xF139
-// -0.171487
-0xEA0D
-// -0.040428
-0xFAD3
-// 0.053011
-0x06C9
-// -0.050603
-0xF986
-// 0.136787
-0x1182
-// -0.018547
-0xFDA0
-// 0.077037
-0x09DC
-// -0.140488
-0xEE04
-// -0.119783
-0xF0AB
-// -0.128934
-0xEF7F
-// 0.115485
-0x0EC8
-// 0.161970
-0x14BB
-// -0.030726
-0xFC11
-// -0.015050
-0xFE13
-// -0.239254
-0xE160
-// 0.013605
-0x01BE
-// -0.246272
-0xE07A
-// -0.070010
-0xF70A
-// -0.087196
-0xF4D7
-// 0.221101
-0x1C4D
-// -0.103952
-0xF2B2
-// -0.300929
-0xD97B
-// 0.133987
+// -0.128398
+0xEF91
+// -0.043505
+0xFA6E
+// -0.106497
+0xF25E
+// 0.078793
+0x0A16
+// 0.094373
+0x0C14
+// -0.100976
+0xF313
+// -0.027070
+0xFC89
+// -0.077464
+0xF616
+// 0.147580
+0x12E4
+// -0.135889
+0xEE9B
+// 0.092446
+0x0BD5
+// -0.129240
+0xEF75
+// 0.208682
+0x1AB6
+// -0.009259
+0xFED1
+// -0.081357
+0xF596
+// -0.140092
+0xEE11
+// 0.031170
+0x03FD
+// -0.048448
+0xF9CC
+// 0.049725
+0x065D
+// -0.033874
+0xFBAA
+// 0.328352
+0x2A07
+// -0.041805
+0xFAA6
+// 0.073250
+0x0960
+// -0.064807
+0xF7B4
+// -0.007742
+0xFF02
+// 0.054106
+0x06ED
+// 0.018014
+0x024E
+// 0.038354
+0x04E9
+// 0.237883
+0x1E73
+// 0.106568
+0x0DA4
+// 0.209240
+0x1AC8
+// -0.326612
+0xD632
+// -0.050437
+0xF98B
+// 0.090564
+0x0B98
+// -0.027744
+0xFC73
+// -0.214202
+0xE495
+// -0.119877
+0xF0A8
+// -0.112068
+0xF1A8
+// 0.200237
+0x19A1
+// 0.085882
+0x0AFE
+// -0.013192
+0xFE50
+// 0.004338
+0x008E
+// -0.207185
+0xE57B
+// 0.084420
+0x0ACE
+// 0.086569
+0x0B15
+// -0.232161
+0xE249
+// 0.002505
+0x0052
+// 0.122177
+0x0FA4
+// 0.065817
+0x086D
+// -0.226904
+0xE2F5
+// 0.006712
+0x00DC
+// 0.243556
+0x1F2D
+// -0.088972
+0xF49D
+// 0.049222
+0x064D
+// 0.051059
+0x0689
+// 0.022691
+0x02E8
+// 0.015423
+0x01F9
+// 0.016690
+0x0223
+// -0.172003
+0xE9FC
+// -0.148822
+0xECF3
+// -0.035564
+0xFB73
+// -0.089129
+0xF497
+// -0.064548
+0xF7BD
+// 0.104383
+0x0D5C
+// 0.097381
+0x0C77
+// -0.253909
+0xDF80
+// 0.032337
+0x0424
+// 0.189729
+0x1849
+// -0.078554
+0xF5F2
+// -0.036645
+0xFB4F
+// 0.115083
+0x0EBB
+// -0.320116
+0xD706
+// -0.155684
+0xEC13
+// 0.076799
+0x09D5
+// -0.216981
+0xE43A
+// -0.110617
+0xF1D7
+// -0.107941
+0xF22F
+// 0.197992
+0x1958
+// -0.024970
+0xFCCE
+// -0.098177
+0xF36F
+// -0.006708
+0xFF24
+// -0.059039
+0xF871
+// 0.127062
+0x1044
+// 0.037143
+0x04C1
+// 0.002956
+0x0061
+// 0.275616
+0x2347
+// 0.044689
+0x05B8
+// -0.124537
+0xF00F
+// -0.190061
+0xE7AC
+// -0.086738
+0xF4E6
+// 0.175290
+0x1670
+// 0.134438
+0x1135
+// 0.109990
+0x0E14
+// -0.049871
+0xF99E
+// -0.043415
+0xFA71
+// -0.058912
+0xF876
+// -0.061888
+0xF814
+// 0.166472
+0x154F
+// 0.154706
+0x13CD
+// 0.049399
+0x0653
+// -0.186538
+0xE820
+// 0.067653
+0x08A9
+// 0.110632
+0x0E29
+// 0.042063
+0x0562
+// -0.199886
+0xE66A
+// -0.071020
+0xF6E9
+// -0.107483
+0xF23E
+// 0.024383
+0x031F
+// -0.063106
+0xF7EC
+// -0.180908
+0xE8D8
+// -0.011171
+0xFE92
+// -0.126388
+0xEFD3
+// 0.136352
+0x1174
+// -0.168752
+0xEA66
+// 0.134369
+0x1133
+// 0.077405
+0x09E8
+// 0.168701
+0x1598
+// 0.026388
+0x0361
+// 0.002656
+0x0057
+// -0.218663
+0xE403
+// -0.181750
+0xE8BC
+// -0.038906
+0xFB05
+// -0.148663
+0xECF9
+// 0.062174
+0x07F5
+// -0.077638
+0xF610
+// 0.009662
+0x013D
+// -0.174778
+0xE9A1
+// -0.052105
+0xF955
+// 0.068010
+0x08B5
+// -0.084241
+0xF538
+// 0.091722
+0x0BBE
+// 0.057735
+0x0764
+// 0.112341
+0x0E61
+// -0.109533
+0xF1FB
+// -0.259569
+0xDEC6
+// -0.198550
+0xE696
+// 0.142482
+0x123D
+// 0.069370
+0x08E1
+// -0.176263
+0xE970
+// -0.081710
+0xF58B
+// -0.172466
+0xE9ED
+// -0.118963
+0xF0C6
+// -0.155169
+0xEC23
+// 0.129296
+0x108D
+// -0.007700
+0xFF04
+// 0.231935
+0x1DB0
+// -0.121416
+0xF075
+// -0.173317
+0xE9D1
+// -0.061675
+0xF81B
+// 0.053752
+0x06E1
+// -0.244209
+0xE0BE
+// -0.088117
+0xF4B9
+// -0.035316
+0xFB7B
+// 0.133966
 0x1126
-// -0.057612
-0xF8A0
-// -0.024174
-0xFCE8
-// 0.131945
-0x10E4
-// 0.025373
-0x033F
-// -0.047852
-0xF9E0
-// 0.131831
-0x10E0
-// 0.042128
-0x0564
-// -0.012011
-0xFE76
-// -0.022117
-0xFD2B
-// -0.069860
-0xF70F
-// 0.115968
-0x0ED8
-// -0.127228
-0xEFB7
-// 0.320633
-0x290A
-// 0.276343
-0x235F
-// -0.157870
-0xEBCB
-// 0.152319
-0x137F
-// 0.104765
-0x0D69
-// -0.007189
-0xFF14
-// -0.232035
-0xE24D
-// 0.063548
-0x0822
-// -0.069052
-0xF729
-// -0.121558
-0xF071
-// 0.037971
-0x04DC
-// 0.069269
-0x08DE
-// -0.069508
-0xF71A
-// -0.211016
-0xE4FD
-// -0.295800
-0xDA23
-// -0.054854
-0xF8FB
-// 0.311443
-0x27DD
-// -0.001472
-0xFFD0
-// -0.039885
-0xFAE5
-// -0.013871
-0xFE39
-// -0.046001
-0xFA1D
-// -0.105568
-0xF27D
-// -0.220184
-0xE3D1
-// -0.009115
-0xFED5
-// -0.218381
-0xE40C
-// 0.157055
-0x141A
-// 0.083068
-0x0AA2
-// -0.112957
-0xF18B
-// 0.041529
-0x0551
-// -0.063205
-0xF7E9
-// 0.086436
-0x0B10
-// -0.174131
-0xE9B6
-// -0.065254
-0xF7A6
-// 0.093688
-0x0BFE
-// -0.116461
-0xF118
-// -0.079351
-0xF5D8
-// -0.108311
-0xF223
-// 0.209593
-0x1AD4
-// 0.100511
-0x0CDE
-// -0.072217
-0xF6C2
-// -0.017930
-0xFDB4
-// -0.091380
-0xF44E
-// -0.005307
-0xFF52
-// 0.112832
-0x0E71
-// -0.156975
-0xEBE8
-// -0.023996
-0xFCEE
-// -0.143409
-0xEDA5
-// -0.008103
-0xFEF6
-// -0.133911
-0xEEDC
-// 0.081977
-0x0A7E
-// -0.082161
-0xF57C
-// -0.125111
-0xEFFC
-// -0.102548
-0xF2E0
-// 0.008881
-0x0123
-// 0.074928
-0x0997
-// 0.286428
-0x24AA
-// -0.094917
-0xF3DA
-// 0.059648
-0x07A3
-// -0.093504
-0xF408
-// -0.151508
-0xEC9B
-// -0.121966
-0xF063
-// 0.095979
-0x0C49
-// -0.013808
-0xFE3C
-// -0.068825
-0xF731
-// 0.155357
-0x13E3
-// -0.230447
-0xE281
-// 0.022940
-0x02F0
-// -0.021774
-0xFD37
-// 0.129324
-0x108E
-// -0.137403
-0xEE6A
-// 0.098676
-0x0CA1
-// -0.092112
-0xF436
-// -0.058370
-0xF887
-// -0.179718
-0xE8FF
-// 0.047144
-0x0609
-// 0.174321
-0x1650
-// 0.232863
-0x1DCE
-// -0.039680
-0xFAEC
-// -0.075850
-0xF64B
-// 0.228114
-0x1D33
-// 0.027826
-0x0390
-// -0.142672
-0xEDBD
-// -0.071864
-0xF6CD
-// -0.006963
-0xFF1C
-// 0.142251
-0x1235
-// -0.080185
-0xF5BC
-// -0.116845
-0xF10B
-// 0.065550
-0x0864
-// 0.156779
-0x1411
-// -0.199667
-0xE671
-// -0.191388
-0xE781
-// -0.265870
-0xDDF8
-// 0.091220
-0x0BAD
-// -0.016519
-0xFDE3
-// -0.094917
-0xF3DA
-// -0.088810
-0xF4A2
-// -0.171709
-0xEA05
-// -0.127770
-0xEFA5
-// 0.015007
-0x01EC
-// -0.026718
-0xFC94
-// -0.013435
-0xFE48
-// 0.023084
-0x02F4
-// -0.038821
-0xFB08
-// 0.224246
-0x1CB4
-// -0.155298
-0xEC1F
-// 0.008819
-0x0121
-// -0.156752
-0xEBF0
-// 0.108554
-0x0DE5
-// 0.101710
-0x0D05
-// 0.170953
-0x15E2
-// -0.051679
-0xF963
-// 0.035478
-0x048B
-// -0.184742
-0xE85A
-// -0.136798
-0xEE7D
-// -0.048241
-0xF9D3
-// -0.107016
-0xF24D
-// 0.116168
-0x0EDF
-// 0.189373
-0x183D
-// -0.222578
-0xE383
-// 0.078614
-0x0A10
-// 0.004540
-0x0095
-// 0.051277
-0x0690
-// 0.098651
-0x0CA1
-// -0.115843
-0xF12C
-// -0.137151
-0xEE72
-// 0.095896
-0x0C46
-// 0.102429
-0x0D1C
-// -0.015866
-0xFDF8
-// 0.191834
-0x188E
-// -0.148916
-0xECF0
-// -0.057595
-0xF8A1
-// 0.065413
-0x085F
-// 0.165221
-0x1526
-// -0.022755
-0xFD16
-// 0.052421
-0x06B6
-// 0.045334
-0x05CD
-// 0.013745
-0x01C2
-// -0.160745
-0xEB6D
-// 0.159521
-0x146B
-// 0.129463
-0x1092
-// -0.166774
-0xEAA7
-// -0.022594
-0xFD1C
-// -0.114830
-0xF14D
-// 0.091144
-0x0BAB
-// -0.319741
-0xD713
-// -0.268299
-0xDDA8
-// 0.002833
-0x005D
-// -0.067930
-0xF74E
-// 0.028897
-0x03B3
-// 0.016958
-0x022C
-// 0.050602
-0x067A
-// 0.023616
-0x0306
-// 0.005321
-0x00AE
-// 0.077008
-0x09DB
+// 0.128577
+0x1075
+// 0.071781
+0x0930
+// -0.161884
+0xEB47
+// 0.122247
+0x0FA6
+// 0.000404
+0x000D
+// 0.136721
+0x1180
+// 0.034298
+0x0464
+// 0.096766
+0x0C63
+// -0.000181
+0xFFFA
+// 0.053769
+0x06E2
+// -0.012121
+0xFE73
+// -0.089411
+0xF48E
+// -0.060777
+0xF838
+// 0.060457
+0x07BD
+// -0.182573
+0xE8A1
+// -0.234222
+0xE205
+// 0.025016
+0x0334
+// 0.052368
+0x06B4
+// 0.002248
+0x004A
+// -0.016009
+0xFDF3
+// 0.146369
+0x12BC
+// 0.008245
+0x010E
+// -0.183090
+0xE891
+// 0.029551
+0x03C8
+// -0.094465
+0xF3E9
+// 0.051437
+0x0695
+// 0.075380
+0x09A6
+// 0.134485
+0x1137
+// -0.076207
+0xF63F
+// 0.281630
+0x240C
+// 0.166828
+0x155B
+// -0.150314
+0xECC3
+// 0.176630
+0x169C
+// 0.025688
+0x034A
+// 0.033819
+0x0454
+// 0.119446
+0x0F4A
+// -0.111777
+0xF1B1
+// 0.324678
+0x298F
+// 0.238821
+0x1E92
+// -0.013923
+0xFE38
+// -0.409945
+0xCB87
+// 0.006055
+0x00C6
+// -0.026582
+0xFC99
+// 0.163649
+0x14F2
+// 0.079693
+0x0A33
+// -0.147150
+0xED2A
+// -0.183288
+0xE88A
+// 0.055468
+0x071A
+// -0.119950
+0xF0A5
+// 0.131177
+0x10CA
+// -0.186258
+0xE829
+// 0.037284
+0x04C6
+// -0.185906
+0xE834
+// -0.221885
+0xE399
+// -0.027018
+0xFC8B
+// 0.086617
+0x0B16
+// 0.045725
+0x05DA
+// 0.185053
+0x17B0
+// 0.056070
+0x072D
+// 0.047864
+0x0620
+// -0.073803
+0xF68E
+// 0.270016
+0x2290
+// 0.165901
+0x153C
+// -0.049409
+0xF9AD
+// 0.280015
+0x23D8
+// 0.075267
+0x09A2
+// 0.006869
+0x00E1
+// 0.235438
+0x1E23
+// 0.138125
+0x11AE
+// -0.059666
+0xF85D
+// -0.044879
+0xFA41
+// 0.065250
+0x085A
+// -0.256419
+0xDF2E
+// 0.103862
+0x0D4B
+// 0.110679
+0x0E2B
+// 0.147746
+0x12E9
+// -0.119877
+0xF0A8
+// -0.169339
+0xEA53
+// 0.083908
+0x0ABD
+// -0.152393
+0xEC7E
+// 0.044923
+0x05C0
+// -0.158914
+0xEBA9
+// 0.099528
+0x0CBD
+// -0.169484
+0xEA4E
+// 0.020991
+0x02B0
+// 0.156713
+0x140F
+// -0.097956
+0xF376
+// -0.151629
+0xEC97
+// 0.155525
+0x13E8
+// -0.142613
+0xEDBF
+// -0.059631
+0xF85E
+// -0.010553
+0xFEA6
+// -0.046100
+0xFA19
+// 0.094159
+0x0C0D
+// -0.044361
+0xFA52
+// -0.051345
+0xF96E
+// -0.137226
+0xEE6F
+// 0.042039
+0x0562
+// 0.095277
+0x0C32
+// 0.075692
+0x09B0
+// -0.005158
+0xFF57
+// -0.162558
+0xEB31

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/MaxNeg2Input12_s16.txt

@@ -0,0 +1,36 @@
+H
+17
+// -32768
+0x8000
+// -2
+0xFFFE
+// -32768
+0x8000
+// -2
+0xFFFE
+// -32768
+0x8000
+// -2
+0xFFFE
+// -32768
+0x8000
+// -2
+0xFFFE
+// -32768
+0x8000
+// -2
+0xFFFE
+// -32768
+0x8000
+// -2
+0xFFFE
+// -32768
+0x8000
+// -2
+0xFFFE
+// -32768
+0x8000
+// -2
+0xFFFE
+// -32768
+0x8000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/MaxNegInput12_s16.txt

@@ -0,0 +1,36 @@
+H
+17
+// -32767
+0x8001
+// -1
+0xFFFF
+// -32767
+0x8001
+// -1
+0xFFFF
+// -32767
+0x8001
+// -1
+0xFFFF
+// -32767
+0x8001
+// -1
+0xFFFF
+// -32767
+0x8001
+// -1
+0xFFFF
+// -32767
+0x8001
+// -1
+0xFFFF
+// -32767
+0x8001
+// -1
+0xFFFF
+// -32767
+0x8001
+// -1
+0xFFFF
+// -32767
+0x8001

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/MaxPosInput12_s16.txt

@@ -0,0 +1,36 @@
+H
+17
+// 32766
+0x7FFE
+// 1
+0x0001
+// 32766
+0x7FFE
+// 1
+0x0001
+// 32766
+0x7FFE
+// 1
+0x0001
+// 32766
+0x7FFE
+// 1
+0x0001
+// 32766
+0x7FFE
+// 1
+0x0001
+// 32766
+0x7FFE
+// 1
+0x0001
+// 32766
+0x7FFE
+// 1
+0x0001
+// 32766
+0x7FFE
+// 1
+0x0001
+// 32766
+0x7FFE

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/NegSat13_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/NegSat15_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// -1.999908
+0x8000
+// -0.000061
+0xFFFE
+// -1.999908
+0x8000
+// -0.000061
+0xFFFE
+// -1.999908
+0x8000
+// -0.000061
+0xFFFE
+// -1.999908
+0x8000
+// -0.000061
+0xFFFE
+// -1.999908
+0x8000
+// -0.000061
+0xFFFE
+// -1.999908
+0x8000
+// -0.000061
+0xFFFE
+// -1.999908
+0x8000
+// -0.000061
+0xFFFE
+// -1.999908
+0x8000
+// -0.000061
+0xFFFE
+// -1.999908
+0x8000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/NegSat17_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/NegSat19_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// -1.899969
+0x8000
+// -0.900031
+0x8CCC
+// -1.899969
+0x8000
+// -0.900031
+0x8CCC
+// -1.899969
+0x8000
+// -0.900031
+0x8CCC
+// -1.899969
+0x8000
+// -0.900031
+0x8CCC
+// -1.899969
+0x8000
+// -0.900031
+0x8CCC
+// -1.899969
+0x8000
+// -0.900031
+0x8CCC
+// -1.899969
+0x8000
+// -0.900031
+0x8CCC
+// -1.899969
+0x8000
+// -0.900031
+0x8CCC
+// -1.899969
+0x8000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/NegSat20_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// -1.900000
+0x8000
+// -0.900061
+0x8CCB
+// -1.900000
+0x8000
+// -0.900061
+0x8CCB
+// -1.900000
+0x8000
+// -0.900061
+0x8CCB
+// -1.900000
+0x8000
+// -0.900061
+0x8CCB
+// -1.900000
+0x8000
+// -0.900061
+0x8CCB
+// -1.900000
+0x8000
+// -0.900061
+0x8CCB
+// -1.900000
+0x8000
+// -0.900061
+0x8CCB
+// -1.900000
+0x8000
+// -0.900061
+0x8CCB
+// -1.900000
+0x8000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/PosSat12_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/PosSat14_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// 1.999908
+0x7FFF
+// 0.000061
+0x0002
+// 1.999908
+0x7FFF
+// 0.000061
+0x0002
+// 1.999908
+0x7FFF
+// 0.000061
+0x0002
+// 1.999908
+0x7FFF
+// 0.000061
+0x0002
+// 1.999908
+0x7FFF
+// 0.000061
+0x0002
+// 1.999908
+0x7FFF
+// 0.000061
+0x0002
+// 1.999908
+0x7FFF
+// 0.000061
+0x0002
+// 1.999908
+0x7FFF
+// 0.000061
+0x0002
+// 1.999908
+0x7FFF

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/PosSat16_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// 1.000000
+0x7FFF
+// 0.000000
+0x0000
+// 1.000000
+0x7FFF
+// 0.000000
+0x0000
+// 1.000000
+0x7FFF
+// 0.000000
+0x0000
+// 1.000000
+0x7FFF
+// 0.000000
+0x0000
+// 1.000000
+0x7FFF
+// 0.000000
+0x0000
+// 1.000000
+0x7FFF
+// 0.000000
+0x0000
+// 1.000000
+0x7FFF
+// 0.000000
+0x0000
+// 1.000000
+0x7FFF
+// 0.000000
+0x0000
+// 1.000000
+0x7FFF

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/PosSat17_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/PosSat18_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/PosSat19_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF
+// 0.900031
+0x7334
+// 1.899939
+0x7FFF

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/PosSat20_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF
+// 0.000061
+0x0002
+// 1.000000
+0x7FFF

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference10_q15.txt

@@ -1,514 +1,514 @@
 H
 256
-// 0.291372
-0x254C
-// 0.112738
-0x0E6E
-// 0.238117
-0x1E7B
-// 0.038878
-0x04FA
-// 0.294852
-0x25BE
-// 0.107647
-0x0DC7
-// 0.769109
-0x6272
-// 0.084075
-0x0AC3
-// 0.329781
-0x2A36
-// 0.320584
-0x2909
-// 0.219050
-0x1C0A
-// 0.190578
-0x1865
-// 0.165900
-0x153C
-// 0.281091
-0x23FB
-// 1.020124
-0x7FFF
-// 0.675056
-0x5668
-// 0.283130
-0x243E
-// 0.773159
-0x62F7
-// 0.722326
-0x5C75
-// 0.322220
-0x293F
-// 0.348974
-0x2CAB
-// 0.595221
-0x4C30
-// 0.069654
-0x08EA
-// 0.136401
-0x1176
-// 0.367788
-0x2F14
-// 0.275101
-0x2337
-// 0.652923
-0x5393
-// 0.172436
-0x1612
-// 0.114230
-0x0E9F
-// 0.203455
-0x1A0B
-// 0.118325
-0x0F25
-// 0.299473
-0x2655
-// 0.096281
-0x0C53
-// 0.853706
-0x6D46
-// 1.017484
-0x7FFF
-// 0.130138
-0x10A8
-// 0.245529
-0x1F6D
-// 0.148787
-0x130B
-// 0.544863
-0x45BE
-// 0.112934
-0x0E75
-// 0.946172
-0x791C
-// 0.132993
-0x1106
-// 0.065405
-0x085F
-// 0.186642
-0x17E4
-// 0.756814
-0x60DF
-// 0.105861
-0x0D8D
-// 0.437403
-0x37FD
-// 0.081627
-0x0A73
-// 0.006338
-0x00D0
-// 0.268326
-0x2259
-// 0.092221
-0x0BCE
-// 0.106395
-0x0D9E
-// 0.081742
-0x0A77
-// 0.034894
-0x0477
-// 0.772030
-0x62D2
-// 0.195714
-0x190D
-// 0.113011
-0x0E77
-// 0.320860
-0x2912
-// 0.040862
-0x053B
-// 0.227119
-0x1D12
-// 0.316674
-0x2889
-// 0.097933
-0x0C89
-// 0.199199
-0x197F
-// 0.079258
-0x0A25
-// 0.626025
-0x5022
-// 0.755253
-0x60AC
-// 0.360077
-0x2E17
-// 0.534840
-0x4476
-// 0.126088
-0x1024
-// 0.165333
-0x152A
-// 0.157822
-0x1434
-// 0.426616
-0x369B
-// 0.057844
-0x0767
-// 0.240266
-0x1EC1
-// 0.438159
-0x3816
-// 0.373584
-0x2FD2
-// 0.402123
-0x3379
-// 0.360179
-0x2E1A
-// 0.505158
-0x40A9
-// 0.095831
-0x0C44
-// 0.046939
-0x0602
-// 0.746193
-0x5F83
-// 0.042432
-0x056E
-// 0.768082
-0x6251
-// 0.218351
-0x1BF3
-// 0.271949
-0x22CF
-// 0.689579
-0x5844
-// 0.324210
-0x2980
-// 0.938547
-0x7822
-// 0.417882
-0x357D
-// 0.179682
-0x1700
-// 0.075396
-0x09A7
-// 0.411513
-0x34AC
-// 0.079135
-0x0A21
-// 0.149243
-0x131A
-// 0.411160
-0x34A1
-// 0.131389
-0x10D1
-// 0.037460
-0x04CB
-// 0.068980
-0x08D4
-// 0.217882
-0x1BE4
-// 0.361686
-0x2E4C
-// 0.396804
-0x32CA
+// 0.391039
+0x320E
+// 0.132494
+0x10F6
+// 0.324339
+0x2984
+// 0.239965
+0x1EB7
+// 0.287413
+0x24CA
+// 0.307525
+0x275D
+// 0.082443
+0x0A8D
+// 0.235917
+0x1E33
+// 0.449457
+0x3988
+// 0.413851
+0x34F9
+// 0.281545
+0x240A
+// 0.393602
+0x3262
+// 0.635543
+0x5159
+// 0.028199
+0x039C
+// 0.247774
+0x1FB7
+// 0.426651
+0x369D
+// 0.094929
+0x0C27
+// 0.147548
+0x12E3
+// 0.151437
+0x1362
+// 0.103162
+0x0D34
 // 1.000000
 0x7FFF
-// 0.861870
-0x6E52
-// 0.492371
-0x3F06
-// 0.475058
-0x3CCF
-// 0.326745
-0x29D3
-// 0.022422
-0x02DF
-// 0.723679
-0x5CA2
-// 0.198195
-0x195E
-// 0.215361
-0x1B91
-// 0.379118
-0x3087
-// 0.118425
-0x0F29
-// 0.216039
-0x1BA7
-// 0.216784
-0x1BC0
-// 0.658123
-0x543D
-// 0.922551
-0x7616
-// 0.171079
-0x15E6
-// 0.971339
-0x7C55
-// 0.004590
-0x0096
-// 0.124396
-0x0FEC
-// 0.043263
-0x058A
-// 0.143471
-0x125D
-// 0.329250
-0x2A25
-// 0.686717
-0x57E6
-// 0.028428
-0x03A4
-// 0.681094
-0x572E
-// 0.489830
-0x3EB3
-// 0.259075
-0x2129
-// 0.352294
-0x2D18
-// 0.129524
-0x1094
-// 0.197127
-0x193B
-// 0.269581
-0x2282
-// 0.543085
-0x4584
-// 0.203516
-0x1A0D
-// 0.292197
-0x2567
-// 0.363223
-0x2E7E
-// 0.247482
-0x1FAE
-// 0.337804
-0x2B3D
-// 0.653685
-0x53AC
-// 0.313478
-0x2820
-// 0.225233
-0x1CD4
-// 0.055920
-0x0728
-// 0.284999
-0x247B
-// 0.016551
-0x021E
-// 0.351903
-0x2D0B
-// 0.489580
-0x3EAB
-// 0.074839
-0x0994
-// 0.447269
-0x3940
-// 0.025272
-0x033C
-// 0.417648
-0x3575
-// 0.255674
-0x20BA
-// 0.256246
-0x20CD
-// 0.390200
-0x31F2
-// 0.319831
-0x28F0
-// 0.027698
-0x038C
-// 0.233688
-0x1DEA
-// 0.893321
-0x7258
-// 0.296030
-0x25E4
-// 0.186033
-0x17D0
-// 0.291623
-0x2554
-// 0.472528
-0x3C7C
-// 0.380391
-0x30B1
-// 0.299344
-0x2651
-// 0.043065
-0x0583
-// 0.214653
-0x1B7A
-// 0.484534
-0x3E05
-// 0.718725
-0x5BFF
-// 0.071545
-0x0928
-// 0.067909
-0x08B1
-// 0.403341
-0x33A1
-// 0.428537
-0x36DA
-// 0.307753
-0x2764
-// 0.287282
-0x24C6
-// 0.182047
-0x174D
-// 0.560512
-0x47BF
-// 0.147036
-0x12D2
-// 0.543678
-0x4597
-// 0.726262
-0x5CF6
-// 0.123755
-0x0FD7
-// 0.236564
-0x1E48
-// 0.711449
-0x5B11
-// 0.086785
-0x0B1C
-// 0.444971
-0x38F5
-// 0.224133
-0x1CB0
-// 0.021716
-0x02C8
-// 0.443658
-0x38CA
-// 0.250084
-0x2003
-// 0.364422
-0x2EA5
-// 0.204438
-0x1A2B
-// 0.488969
-0x3E97
-// 0.622727
-0x4FB6
-// 0.596908
-0x4C67
-// 0.829206
-0x6A23
-// 0.284500
-0x246A
-// 0.051519
-0x0698
-// 0.296029
-0x25E4
-// 0.276982
-0x2374
-// 0.535533
-0x448C
-// 0.398493
-0x3302
-// 0.046804
-0x05FE
-// 0.083330
-0x0AAB
-// 0.041901
-0x055D
-// 0.071995
-0x0937
-// 0.121075
-0x0F7F
-// 0.699388
-0x5986
-// 0.484348
-0x3DFF
-// 0.027504
-0x0385
-// 0.488884
-0x3E94
-// 0.338561
-0x2B56
-// 0.317218
-0x289B
-// 0.533173
-0x443F
-// 0.161179
-0x14A2
-// 0.110650
-0x0E2A
-// 0.576178
-0x49C0
-// 0.426651
-0x369C
-// 0.150455
+// 0.127316
+0x104C
+// 0.223084
+0x1C8E
+// 0.197370
+0x1943
+// 0.023579
+0x0305
+// 0.164779
+0x1517
+// 0.054862
+0x0706
+// 0.116807
+0x0EF4
+// 0.724476
+0x5CBC
+// 0.324554
+0x298B
+// 0.637242
+0x5191
+// 0.994701
+0x7F52
+// 0.153605
+0x13A9
+// 0.275814
+0x234E
+// 0.084495
+0x0AD1
+// 0.652355
+0x5380
+// 0.365086
+0x2EBB
+// 0.341305
+0x2BB0
+// 0.609822
+0x4E0F
+// 0.261556
+0x217B
+// 0.040176
+0x0524
+// 0.013211
+0x01B1
+// 0.630985
+0x50C4
+// 0.257101
+0x20E9
+// 0.263646
+0x21BF
+// 0.707048
+0x5A81
+// 0.007630
+0x00FA
+// 0.372092
+0x2FA1
+// 0.200446
+0x19A8
+// 0.691038
+0x5874
+// 0.020442
+0x029E
+// 0.741753
+0x5EF2
+// 0.270967
+0x22AF
+// 0.149906
+0x1330
+// 0.155500
+0x13E7
+// 0.069104
+0x08D8
+// 0.046970
+0x0603
+// 0.050831
+0x0682
+// 0.523837
+0x430D
+// 0.453239
+0x3A04
+// 0.108311
+0x0DDD
+// 0.271445
+0x22BF
+// 0.196582
+0x192A
+// 0.317899
+0x28B1
+// 0.296574
+0x25F6
+// 0.773282
+0x62FB
+// 0.098481
+0x0C9B
+// 0.577823
+0x49F6
+// 0.239237
+0x1E9F
+// 0.111604
+0x0E49
+// 0.350488
+0x2CDD
+// 0.974917
+0x7CCA
+// 0.474137
+0x3CB1
+// 0.233892
+0x1DF0
+// 0.660819
+0x5496
+// 0.336884
+0x2B1F
+// 0.328735
+0x2A14
+// 0.602986
+0x4D2F
+// 0.076045
+0x09BC
+// 0.299000
+0x2646
+// 0.020428
+0x029D
+// 0.179805
+0x1704
+// 0.386969
+0x3188
+// 0.113119
+0x0E7B
+// 0.009004
+0x0127
+// 0.839391
+0x6B71
+// 0.136101
+0x116C
+// 0.379279
+0x308C
+// 0.578833
+0x4A17
+// 0.264163
+0x21D0
+// 0.533847
+0x4455
+// 0.409433
+0x3468
+// 0.334975
+0x2AE0
+// 0.151882
+0x1371
+// 0.132220
+0x10ED
+// 0.179417
+0x16F7
+// 0.188481
+0x1820
+// 0.506994
+0x40E5
+// 0.471158
+0x3C4F
+// 0.150447
 0x1342
-// 0.333766
-0x2AB9
-// 0.362308
+// 0.568105
+0x48B8
+// 0.206037
+0x1A5F
+// 0.336932
+0x2B21
+// 0.128105
+0x1066
+// 0.608755
+0x4DEC
+// 0.216292
+0x1BAF
+// 0.327339
+0x29E6
+// 0.074259
+0x0981
+// 0.192190
+0x189A
+// 0.550959
+0x4686
+// 0.034023
+0x045B
+// 0.384915
+0x3145
+// 0.415263
+0x3527
+// 0.513936
+0x41C9
+// 0.409222
+0x3461
+// 0.235739
+0x1E2D
+// 0.513779
+0x41C4
+// 0.080366
+0x0A49
+// 0.008089
+0x0109
+// 0.665939
+0x553E
+// 0.553521
+0x46DA
+// 0.118488
+0x0F2B
+// 0.452754
+0x39F4
+// 0.189352
+0x183D
+// 0.236447
+0x1E44
+// 0.029425
+0x03C4
+// 0.532288
+0x4422
+// 0.158685
+0x1450
+// 0.207125
+0x1A83
+// 0.256558
+0x20D7
+// 0.279340
+0x23C1
+// 0.175831
+0x1682
+// 0.342134
+0x2BCB
+// 0.333585
+0x2AB3
+// 0.790520
+0x6530
+// 0.604685
+0x4D66
+// 0.433929
+0x378B
+// 0.211268
+0x1B0B
+// 0.536812
+0x44B6
+// 0.248849
+0x1FDA
+// 0.525246
+0x433B
+// 0.362304
 0x2E60
-// 0.590622
-0x4B99
-// 0.694183
-0x58DB
-// 0.245185
-0x1F62
-// 0.014160
-0x01D0
-// 0.159924
-0x1478
-// 0.307676
-0x2762
-// 0.361295
-0x2E3F
-// 0.427751
-0x36C1
-// 0.299083
-0x2648
-// 0.319458
-0x28E4
-// 0.049485
-0x0656
-// 0.598299
-0x4C95
-// 0.464446
-0x3B73
-// 0.179628
-0x16FE
-// 0.204011
-0x1A1D
-// 0.515296
-0x41F5
-// 0.070968
-0x0915
-// 0.163492
-0x14ED
-// 0.141388
-0x1219
-// 0.042870
-0x057D
-// 0.501338
-0x402C
-// 0.497520
-0x3FAF
-// 0.403774
-0x33AF
-// 0.520140
-0x4294
-// 0.070466
-0x0905
-// 0.358134
-0x2DD7
-// 0.284262
-0x2463
-// 0.997219
-0x7FA5
-// 0.836779
-0x6B1C
-// 0.008837
-0x0122
-// 0.211862
-0x1B1E
-// 0.090126
-0x0B89
-// 0.052889
-0x06C5
-// 0.157819
-0x1433
-// 0.073654
-0x096E
-// 0.016595
-0x0220
-// 0.240174
-0x1EBE
+// 0.472568
+0x3C7D
+// 0.393772
+0x3267
+// 0.023451
+0x0300
+// 0.706359
+0x5A6A
+// 0.369775
+0x2F55
+// 0.527837
+0x4390
+// 0.187832
+0x180B
+// 0.163702
+0x14F4
+// 0.743740
+0x5F33
+// 0.268361
+0x225A
+// 0.107554
+0x0DC4
+// 0.407995
+0x3439
+// 0.391583
+0x321F
+// 0.218611
+0x1BFB
+// 0.493020
+0x3F1B
+// 0.372303
+0x2FA8
+// 0.001229
+0x0028
+// 0.416385
+0x354C
+// 0.104454
+0x0D5F
+// 0.294703
+0x25B9
+// 0.000552
+0x0012
+// 0.163755
+0x14F6
+// 0.036916
+0x04BA
+// 0.272303
+0x22DB
+// 0.185096
+0x17B1
+// 0.184122
+0x1791
+// 0.556027
+0x472C
+// 0.713326
+0x5B4E
+// 0.076186
+0x09C0
+// 0.159486
+0x146A
+// 0.006846
+0x00E0
+// 0.048756
+0x063E
+// 0.445768
+0x390F
+// 0.025109
+0x0337
+// 0.557602
+0x4760
+// 0.089997
+0x0B85
+// 0.287693
+0x24D3
+// 0.156651
+0x140D
+// 0.229572
+0x1D63
+// 0.409576
+0x346D
+// 0.232089
+0x1DB5
+// 0.857708
+0x6DC9
+// 0.508076
+0x4109
+// 0.457783
+0x3A99
+// 0.537929
+0x44DB
+// 0.078232
+0x0A04
+// 0.102995
+0x0D2F
+// 0.363774
+0x2E90
+// 0.340417
+0x2B93
+// 0.988812
+0x7E91
+// 0.727331
+0x5D19
+// 0.042403
+0x056D
+// 1.248493
+0x7FFF
+// 0.018439
+0x025C
+// 0.080956
+0x0A5D
+// 0.498395
+0x3FCB
+// 0.242706
+0x1F11
+// 0.448147
+0x395D
+// 0.558205
+0x4773
+// 0.168927
+0x159F
+// 0.365310
+0x2EC2
+// 0.399500
+0x3323
+// 0.567251
+0x489C
+// 0.113547
+0x0E89
+// 0.566178
+0x4879
+// 0.675753
+0x567F
+// 0.082284
+0x0A88
+// 0.263793
+0x21C4
+// 0.139256
+0x11D3
+// 0.563582
+0x4823
+// 0.170762
+0x15DC
+// 0.145771
+0x12A9
+// 0.224769
+0x1CC5
+// 0.822337
+0x6942
+// 0.505253
+0x40AC
+// 0.150475
+0x1343
+// 0.852788
+0x6D28
+// 0.229226
+0x1D57
+// 0.020920
+0x02AE
+// 0.717030
+0x5BC8
+// 0.420662
+0x35D8
+// 0.181715
+0x1742
+// 0.136679
+0x117F
+// 0.198719
+0x1970
+// 0.780927
+0x63F5
+// 0.316314
+0x287D
+// 0.337074
+0x2B25
+// 0.449962
+0x3998
+// 0.365087
+0x2EBB
+// 0.515723
+0x4203
+// 0.255542
+0x20B6
+// 0.464113
+0x3B68
+// 0.136815
+0x1183
+// 0.483973
+0x3DF3
+// 0.303115
+0x26CC
+// 0.516164
+0x4212
+// 0.063928
+0x082F
+// 0.477272
+0x3D17
+// 0.298325
+0x2630
+// 0.461789
+0x3B1C
+// 0.473654
+0x3CA1
+// 0.434329
+0x3798
+// 0.181605
+0x173F
+// 0.032139
+0x041D
+// 0.140397
+0x11F9
+// 0.286762
+0x24B5
+// 0.135101
+0x114B
+// 0.156372
+0x1404
+// 0.417922
+0x357E
+// 0.128029
+0x1063
+// 0.290168
+0x2524
+// 0.230520
+0x1D82
+// 0.015709
+0x0203
+// 0.495071
+0x3F5E

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference11_q15.txt

@@ -0,0 +1,4 @@
+H
+1
+// 13.425417
+0x7FFF

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference1_q15.txt

@@ -1,514 +1,514 @@
 H
 256
-// -0.384795
-0xCEBF
-// 0.148886
-0x130F
-// 0.314466
-0x2840
-// 0.051344
-0x0692
-// 0.389391
-0x31D8
-// -0.142162
-0xEDCE
-// 1.015710
+// -0.519437
+0xBD83
+// -0.175999
+0xE979
+// -0.430836
+0xC8DA
+// 0.318758
+0x28CD
+// 0.381785
+0x30DE
+// -0.408501
+0xCBB6
+// -0.109514
+0xF1FB
+// -0.313381
+0xD7E3
+// 0.597037
+0x4C6C
+// -0.549740
+0xB9A2
+// 0.373991
+0x2FDF
+// -0.522842
+0xBD14
+// 0.844225
+0x6C10
+// -0.037458
+0xFB35
+// -0.329131
+0xD5DF
+// -0.566743
+0xB775
+// 0.126099
+0x1024
+// -0.195995
+0xE6EA
+// 0.201162
+0x19C0
+// -0.137036
+0xEE76
+// 1.328352
 0x7FFF
-// 0.111033
-0x0E36
-// 0.435519
-0x37BF
-// 0.423373
-0x3631
-// 0.289284
-0x2507
-// 0.251684
-0x2037
-// 0.219092
-0x1C0B
-// 0.371219
-0x2F84
-// -1.347209
+// -0.169121
+0xEA5A
+// 0.296334
+0x25EE
+// -0.262176
+0xDE71
+// -0.031322
+0xFBFE
+// 0.218885
+0x1C04
+// 0.072877
+0x0954
+// 0.155161
+0x13DC
+// 0.962359
+0x7B2F
+// 0.431122
+0x372F
+// 0.846481
+0x6C59
+// -1.321314
 0x8000
-// 0.891501
-0x721D
-// -0.373911
-0xD024
-// 1.021059
-0x7FFF
-// -0.953927
-0x85E6
-// -0.425535
-0xC988
-// -0.460867
-0xC502
-// 0.786069
-0x649E
-// -0.091988
-0xF43A
-// 0.180135
-0x170F
-// 0.485713
-0x3E2C
-// -0.363307
-0xD17F
-// 0.862271
-0x6E5F
-// -0.227724
-0xE2DA
-// 0.150856
-0x134F
-// 0.268689
-0x2264
-// 0.156264
-0x1400
-// 0.395494
-0x32A0
-// -0.127152
-0xEFB9
-// 1.127431
-0x7FFF
-// -1.343723
+// -0.204042
+0xE5E2
+// 0.366378
+0x2EE5
+// -0.112239
+0xF1A2
+// -0.866557
+0x9115
+// -0.484962
+0xC1ED
+// -0.453374
+0xC5F8
+// 0.810059
+0x67B0
+// 0.347438
+0x2C79
+// -0.053368
+0xF92B
+// 0.017549
+0x023F
+// -0.838171
+0x94B7
+// 0.341521
+0x2BB7
+// 0.350215
+0x2CD4
+// -0.939208
+0x87C8
+// 0.010135
+0x014C
+// 0.494270
+0x3F44
+// 0.266263
+0x2215
+// -0.917942
+0x8A81
+// 0.027155
+0x037A
+// 0.985309
+0x7E1F
+// -0.359939
+0xD1EE
+// 0.199128
+0x197D
+// 0.206558
+0x1A70
+// 0.091795
+0x0BC0
+// 0.062392
+0x07FC
+// 0.067522
+0x08A5
+// -0.695840
+0xA6EF
+// -0.602060
+0xB2F0
+// -0.143876
+0xED95
+// -0.360574
+0xD1D9
+// -0.261130
+0xDE93
+// 0.422282
+0x360D
+// 0.393954
+0x326D
+// -1.027191
 0x8000
-// 0.171865
-0x1600
-// 0.324253
-0x2981
-// 0.196492
-0x1927
-// 0.719563
-0x5C1B
-// 0.149144
-0x1317
-// 1.249546
+// 0.130818
+0x10BF
+// 0.767552
+0x623F
+// -0.317791
+0xD753
+// -0.148249
+0xED06
+// 0.465572
+0x3B98
+// -1.295032
+0x8000
+// -0.629821
+0xAF62
+// 0.310690
+0x27C5
+// -0.877800
+0x8FA4
+// -0.447501
+0xC6B8
+// -0.436676
+0xC81B
+// 0.800977
+0x6686
+// -0.101015
+0xF312
+// -0.397177
+0xCD29
+// -0.027135
+0xFC87
+// -0.238845
+0xE16E
+// 0.514032
+0x41CC
+// 0.150262
+0x133C
+// 0.011960
+0x0188
+// 1.115007
 0x7FFF
+// 0.180790
+0x1724
+// -0.503816
+0xBF83
+// -0.768894
+0x9D95
+// -0.350901
+0xD316
+// 0.709136
+0x5AC5
+// 0.543872
+0x459E
+// 0.444965
+0x38F5
+// -0.201753
+0xE62D
 // -0.175634
 0xE985
-// 0.086376
-0x0B0E
-// -0.246486
-0xE073
-// -0.999473
-0x8011
-// 0.139803
-0x11E5
-// -0.577649
-0xB610
-// -0.107799
-0xF234
-// -0.008370
-0xFEEE
-// 0.354360
-0x2D5C
-// -0.121791
-0xF069
-// 0.140509
-0x11FC
-// 0.107951
-0x0DD1
-// -0.046083
-0xFA1A
-// -1.019568
-0x8000
-// 0.258466
-0x2115
-// 0.149246
-0x131A
-// 0.423739
-0x363D
-// -0.053964
-0xF918
-// 0.299941
-0x2664
-// 0.418210
-0x3588
-// 0.129333
-0x108E
-// 0.263068
-0x21AC
-// -0.104671
-0xF29A
-// -0.826749
-0x962D
-// -0.997412
-0x8055
-// -0.475530
-0xC322
-// -0.706327
-0xA597
-// -0.166516
-0xEAB0
-// 0.218344
-0x1BF3
-// -0.208425
-0xE552
-// 0.563403
-0x481E
-// -0.076390
-0xF639
-// 0.317303
-0x289D
-// -0.578647
-0xB5EF
-// -0.493368
-0xC0D9
-// -0.531057
-0xBC06
-// 0.475664
-0x3CE3
-// 0.667127
-0x5564
-// -0.126557
-0xEFCD
-// -0.061990
-0xF811
-// -0.985447
-0x81DD
-// 0.056037
-0x072C
-// -1.014354
-0x8000
-// -0.288361
-0xDB17
-// -0.359144
-0xD208
-// 0.910680
-0x7491
-// -0.428162
-0xC932
-// -1.239476
+// -0.238328
+0xE17E
+// -0.250369
+0xDFF4
+// 0.673466
+0x5634
+// 0.625864
+0x501C
+// 0.199846
+0x1995
+// -0.754643
+0x9F68
+// 0.273689
+0x2308
+// 0.447564
+0x394A
+// 0.170168
+0x15C8
+// -0.808641
+0x987E
+// -0.287312
+0xDB39
+// -0.434822
+0xC858
+// 0.098642
+0x0CA0
+// -0.255296
+0xDF52
+// -0.731867
+0xA252
+// -0.045194
+0xFA37
+// -0.511303
+0xBE8E
+// 0.551615
+0x469B
+// -0.682688
+0xA89E
+// 0.543591
+0x4594
+// 0.313145
+0x2815
+// 0.682480
+0x575B
+// 0.106755
+0x0DAA
+// 0.010745
+0x0160
+// -0.884602
+0x8EC5
+// -0.735271
+0xA1E3
+// -0.157394
+0xEBDB
+// -0.601417
+0xB305
+// 0.251526
+0x2032
+// -0.314084
+0xD7CC
+// 0.039087
+0x0501
+// -0.707066
+0xA57F
+// -0.210790
+0xE505
+// 0.275135
+0x2338
+// -0.340799
+0xD461
+// 0.371061
+0x2F7F
+// 0.233566
+0x1DE5
+// 0.454475
+0x3A2C
+// -0.443119
+0xC748
+// -1.050089
 0x8000
-// 0.551868
-0x46A4
-// -0.237294
-0xE1A0
-// -0.099570
-0xF341
-// 0.543458
-0x4590
-// 0.104508
-0x0D61
-// -0.197096
-0xE6C6
-// 0.542991
-0x4581
-// 0.173517
-0x1636
-// -0.049471
-0xF9AB
-// -0.091098
-0xF457
-// -0.287742
-0xDB2B
-// 0.477655
-0x3D24
-// -0.524032
-0xBCED
-// 1.320633
+// -0.803234
+0x9930
+// 0.576411
+0x49C8
+// 0.280638
+0x23EC
+// -0.713076
+0xA4BA
+// -0.330559
+0xD5B0
+// -0.697712
+0xA6B1
+// -0.481267
+0xC266
+// -0.627736
+0xAFA6
+// 0.523068
+0x42F4
+// -0.031151
+0xFC03
+// 0.938294
+0x781A
+// -0.491191
+0xC121
+// -0.701154
+0xA641
+// -0.249507
+0xE010
+// 0.217454
+0x1BD6
+// -0.987948
+0x818B
+// -0.356478
+0xD25F
+// -0.142870
+0xEDB6
+// 0.541962
+0x455F
+// 0.520161
+0x4295
+// 0.290392
+0x252C
+// -0.654905
+0xAC2C
+// 0.494550
+0x3F4D
+// 0.001633
+0x0036
+// 0.553106
+0x46CC
+// 0.138752
+0x11C3
+// 0.391469
+0x321C
+// -0.000733
+0xFFE8
+// 0.217524
+0x1BD8
+// -0.049038
+0xF9B9
+// -0.361715
+0xD1B3
+// -0.245873
+0xE087
+// 0.244579
+0x1F4E
+// -0.738600
+0xA176
+// -0.947549
+0x86B7
+// 0.101202
+0x0CF4
+// 0.211854
+0x1B1E
+// 0.009094
+0x012A
+// -0.064766
+0xF7B6
+// 0.592137
+0x4BCB
+// 0.033354
+0x0445
+// -0.740692
+0xA131
+// 0.119547
+0x0F4D
+// -0.382158
+0xCF15
+// 0.208087
+0x1AA3
+// 0.304952
+0x2709
+// 0.544061
+0x45A4
+// -0.308296
+0xD88A
+// 1.139338
 0x7FFF
-// 1.138213
+// 0.674904
+0x5663
+// -0.608097
+0xB22A
+// 0.714559
+0x5B77
+// 0.103920
+0x0D4D
+// 0.136813
+0x1183
+// 0.483220
+0x3DDA
+// -0.452193
+0xC61F
+// 1.313490
 0x7FFF
-// -0.650242
-0xACC5
-// 0.627377
-0x504E
-// 0.431510
-0x373C
-// -0.029612
-0xFC36
-// -0.955714
-0x85AB
-// 0.261743
-0x2181
-// -0.284413
-0xDB98
-// -0.500675
-0xBFEA
-// 0.156396
-0x1405
-// 0.285308
-0x2485
-// -0.286292
-0xDB5B
-// -0.869138
-0x90C0
-// -1.218350
+// 0.966151
+0x7BAB
+// -0.056326
+0xF8CA
+// -1.658438
 0x8000
-// -0.225933
-0xE315
-// 1.282782
+// 0.024494
+0x0323
+// -0.107538
+0xF23C
+// 0.662044
+0x54BE
+// 0.322399
+0x2944
+// -0.595297
+0xB3CD
+// -0.741493
+0xA117
+// 0.224395
+0x1CB9
+// -0.485260
+0xC1E3
+// 0.530676
+0x43ED
+// -0.753510
+0x9F8D
+// 0.150831
+0x134E
+// -0.752083
+0x9FBC
+// -0.897638
+0x8D1A
+// -0.109303
+0xF202
+// 0.350410
+0x2CDA
+// 0.184981
+0x17AD
+// 0.748635
+0x5FD3
+// 0.226832
+0x1D09
+// 0.193635
+0x18C9
+// -0.298572
+0xD9C8
+// 1.092353
 0x7FFF
-// -0.006062
-0xFF39
-// -0.164282
-0xEAF9
-// -0.057134
-0xF8B0
-// -0.189472
-0xE7BF
-// -0.434819
-0xC858
-// -0.906901
-0x8BEB
-// -0.037542
-0xFB32
-// -0.899475
-0x8CDE
-// 0.646886
-0x52CD
-// 0.342143
-0x2BCB
-// -0.465251
-0xC473
-// 0.171053
-0x15E5
-// -0.260332
-0xDEAD
-// 0.356018
-0x2D92
-// -0.717215
-0xA432
-// -0.268769
-0xDD99
-// 0.385885
-0x3165
-// -0.479684
-0xC29A
-// -0.326833
-0xD62A
-// -0.446115
-0xC6E6
-// 0.863277
-0x6E80
-// 0.413989
-0x34FE
-// -0.297450
-0xD9ED
-// -0.073850
-0xF68C
-// -0.376379
-0xCFD3
-// -0.021858
-0xFD34
-// 0.464734
-0x3B7C
-// -0.646555
-0xAD3E
-// -0.098835
-0xF359
-// -0.590678
-0xB465
-// -0.033375
-0xFBBA
-// -0.551559
-0xB967
-// 0.337652
-0x2B38
-// -0.338407
-0xD4AF
-// -0.515310
-0xBE0A
-// -0.422379
-0xC9EF
-// 0.036579
-0x04AF
-// 0.308617
-0x2781
-// 1.179749
+// 0.671154
+0x55E8
+// -0.199884
+0xE66A
+// 1.132803
 0x7FFF
-// -0.390947
-0xCDF5
-// 0.245681
-0x1F72
-// -0.385127
-0xCEB4
-// -0.624036
-0xB020
-// -0.502357
-0xBFB3
-// 0.395323
-0x329A
-// -0.056874
-0xF8B8
-// -0.283478
-0xDBB7
-// 0.639892
-0x51E8
-// -0.949171
-0x8682
-// 0.094485
-0x0C18
-// -0.089683
-0xF485
-// 0.532665
-0x442E
-// -0.565939
-0xB78F
-// 0.406429
-0x3406
-// -0.379394
-0xCF70
-// -0.240417
-0xE13A
-// -0.740230
-0xA140
-// 0.194180
-0x18DB
-// 0.717999
-0x5BE7
-// 0.959125
-0x7AC5
-// -0.163434
-0xEB15
-// -0.312414
-0xD803
-// 0.939563
-0x7844
-// 0.114611
-0x0EAC
-// -0.587643
-0xB4C8
-// -0.295997
-0xDA1D
-// -0.028679
-0xFC54
-// 0.585909
-0x4AFF
-// -0.330270
-0xD5BA
-// -0.481267
-0xC266
-// 0.269988
-0x228F
-// 0.645748
-0x52A8
-// -0.822393
-0x96BC
-// -0.788296
-0x9B19
-// -1.095076
-0x8000
-// 0.375720
-0x3018
-// -0.068037
-0xF74B
-// -0.390946
-0xCDF5
-// -0.365792
-0xD12E
-// -0.707243
-0xA579
-// -0.526263
-0xBCA3
-// 0.061811
-0x07E9
-// -0.110048
-0xF1EA
-// -0.055336
-0xF8EB
-// 0.095079
-0x0C2C
-// -0.159896
-0xEB89
-// 0.923634
-0x763A
-// -0.639646
-0xAE20
-// 0.036323
-0x04A6
-// -0.645636
-0xAD5C
-// 0.447115
-0x393B
-// 0.418928
-0x359F
-// 0.704126
-0x5A21
-// -0.212858
-0xE4C1
-// 0.146128
-0x12B4
-// -0.760920
-0x9E9A
-// -0.563449
-0xB7E1
-// -0.198696
-0xE691
-// -0.440783
-0xC794
-// 0.478475
-0x3D3F
-// 0.779994
-0x63D7
-// -0.916761
-0x8AA8
-// 0.323799
-0x2972
-// 0.018701
-0x0265
-// 0.211200
-0x1B09
-// 0.406327
-0x3403
-// -0.477138
-0xC2ED
-// -0.564902
-0xB7B1
-// 0.394979
-0x328F
-// 0.421887
-0x3600
-// -0.065351
-0xF7A3
-// 0.790133
-0x6523
-// -0.613362
-0xB17D
-// -0.237223
-0xE1A3
-// 0.269423
-0x227C
-// 0.680517
-0x571B
-// -0.093723
-0xF401
-// 0.215914
-0x1BA3
-// 0.186722
-0x17E6
-// 0.056615
-0x073F
-// -0.662083
-0xAB41
-// 0.657041
-0x541A
-// 0.533237
-0x4441
-// -0.686913
-0xA813
-// -0.093059
-0xF417
-// -0.472964
-0xC376
-// 0.375406
-0x300D
-// -1.316960
-0x8000
-// -1.105078
+// 0.304492
+0x26FA
+// 0.027790
+0x038F
+// 0.952468
+0x79EA
+// 0.558787
+0x4786
+// -0.241381
+0xE11A
+// -0.181557
+0xE8C3
+// 0.263969
+0x21CA
+// -1.037346
 0x8000
-// 0.011670
-0x017E
-// -0.279792
-0xDC30
-// 0.119024
-0x0F3C
-// 0.069847
-0x08F1
-// 0.208421
-0x1AAE
-// 0.097270
-0x0C73
-// 0.021917
-0x02CE
-// 0.317182
-0x2899
+// 0.420177
+0x35C8
+// 0.447752
+0x3950
+// 0.597708
+0x4C82
+// -0.484965
+0xC1ED
+// -0.685062
+0xA850
+// 0.339450
+0x2B73
+// -0.616506
+0xB116
+// 0.181738
+0x1743
+// -0.642887
+0xADB6
+// 0.402643
+0x338A
+// -0.685648
+0xA83D
+// 0.084919
+0x0ADF
+// 0.633986
+0x5126
+// -0.396280
+0xCD47
+// -0.613419
+0xB17C
+// 0.629179
+0x5089
+// -0.576942
+0xB627
+// -0.241236
+0xE11F
+// -0.042692
+0xFA89
+// -0.186497
+0xE821
+// 0.380921
+0x30C2
+// -0.179461
+0xE907
+// -0.207718
+0xE56A
+// -0.555147
+0xB8F1
+// 0.170067
+0x15C5
+// 0.385445
+0x3156
+// 0.306211
+0x2732
+// -0.020867
+0xFD54
+// -0.657629
+0xABD3

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference2_q15.txt

@@ -1,514 +1,514 @@
 H
 256
-// -0.197948
-0xE6AA
-// 0.076591
-0x09CE
-// 0.161769
-0x14B5
-// 0.026413
-0x0361
-// 0.200313
-0x19A4
-// -0.073132
-0xF6A4
-// 0.522507
-0x42E2
-// 0.057118
-0x0750
-// 0.224042
-0x1CAD
-// 0.217794
-0x1BE1
-// 0.148815
-0x130C
-// 0.129473
-0x1093
-// 0.112707
-0x0E6D
-// 0.190964
-0x1872
-// -0.693039
-0xA74A
-// 0.458611
-0x3AB4
-// -0.192349
-0xE761
-// 0.525259
-0x433C
-// -0.490725
-0xC130
-// -0.218906
-0xE3FB
-// -0.237082
-0xE1A7
-// 0.404374
-0x33C3
-// -0.047321
-0xF9F1
-// 0.092666
-0x0BDC
-// 0.249863
-0x1FFC
-// -0.186895
-0xE814
-// 0.443575
-0x38C7
-// -0.117147
-0xF101
-// 0.077604
-0x09EF
-// 0.138221
-0x11B1
-// 0.080386
-0x0A4A
-// 0.203452
-0x1A0B
-// -0.065410
-0xF7A1
-// 0.579980
-0x4A3D
-// -0.691246
-0xA785
-// 0.088412
-0x0B51
-// 0.166804
-0x155A
-// 0.101081
-0x0CF0
-// 0.370162
-0x2F61
-// 0.076724
-0x09D2
-// 0.642799
-0x5247
-// -0.090351
-0xF46F
-// 0.044434
-0x05B0
-// -0.126799
-0xEFC5
-// -0.514155
-0xBE30
-// 0.071918
-0x0935
-// -0.297157
-0xD9F7
-// -0.055455
-0xF8E7
-// -0.004306
-0xFF73
-// 0.182292
-0x1755
-// -0.062652
-0xF7FB
-// 0.072281
-0x0941
-// 0.055533
-0x071C
-// -0.023706
-0xFCF7
-// -0.524492
-0xBCDD
-// 0.132961
-0x1105
-// 0.076776
-0x09D4
-// 0.217982
+// -0.262640
+0xDE62
+// -0.088990
+0xF49C
+// -0.217842
+0xE41E
+// 0.161172
+0x14A1
+// 0.193040
+0x18B6
+// -0.206548
+0xE590
+// -0.055373
+0xF8EA
+// -0.158453
+0xEBB8
+// 0.301877
+0x26A4
+// -0.277962
+0xDC6C
+// 0.189099
+0x1834
+// -0.264362
+0xDE29
+// 0.426861
+0x36A3
+// -0.018940
+0xFD93
+// -0.166417
+0xEAB3
+// -0.286560
+0xDB52
+// 0.063759
+0x0829
+// -0.099100
+0xF351
+// 0.101712
+0x0D05
+// -0.069289
+0xF722
+// 0.671648
+0x55F9
+// -0.085512
+0xF50E
+// 0.149834
+0x132E
+// -0.132563
+0xEF08
+// -0.015837
+0xFDF9
+// 0.110674
+0x0E2B
+// 0.036848
+0x04B7
+// 0.078453
+0x0A0B
+// 0.486593
+0x3E49
+// 0.217986
 0x1BE7
-// -0.027760
-0xFC72
-// 0.154298
-0x13C0
-// 0.215138
-0x1B8A
-// 0.066532
-0x0884
-// 0.135329
-0x1152
-// -0.053845
-0xF91C
-// -0.425301
-0xC990
-// -0.513095
-0xBE53
-// -0.244625
-0xE0B0
-// -0.363353
-0xD17E
-// -0.085660
-0xF509
-// 0.112322
-0x0E61
-// -0.107219
-0xF247
-// 0.289829
-0x2519
-// -0.039297
-0xFAF8
-// 0.163229
-0x14E5
-// -0.297671
-0xD9E6
-// -0.253801
-0xDF83
-// -0.273189
-0xDD08
-// 0.244694
-0x1F52
-// 0.343188
-0x2BEE
-// -0.065104
-0xF7AB
-// -0.031889
-0xFBEB
-// -0.506939
-0xBF1D
-// 0.028827
-0x03B1
-// -0.521810
-0xBD35
-// -0.148340
-0xED03
-// -0.184753
-0xE85A
-// 0.468478
-0x3BF7
-// -0.220258
-0xE3CF
-// -0.637619
-0xAE63
-// 0.283895
-0x2457
-// -0.122070
-0xF060
-// -0.051222
-0xF972
-// 0.279569
-0x23C9
-// 0.053761
-0x06E2
-// -0.101391
-0xF306
-// 0.279329
-0x23C1
-// 0.089261
-0x0B6D
-// -0.025449
-0xFCBE
-// -0.046863
-0xFA00
-// -0.148022
-0xED0E
-// 0.245718
-0x1F74
-// -0.269575
-0xDD7F
-// 0.679367
-0x56F6
-// 0.585526
-0x4AF3
-// -0.334501
-0xD52F
-// 0.322739
-0x2950
-// 0.221980
-0x1C6A
-// -0.015233
-0xFE0D
-// -0.491644
-0xC112
-// 0.134647
+// 0.428002
+0x36C9
+// -0.668089
+0xAA7C
+// -0.103169
+0xF2CB
+// 0.185250
+0x17B6
+// -0.056751
+0xF8BC
+// -0.438153
+0xC7EB
+// -0.245209
+0xE09D
+// -0.229237
+0xE2A8
+// 0.409586
+0x346D
+// 0.175673
+0x167C
+// -0.026984
+0xFC8C
+// 0.008873
+0x0123
+// -0.423800
+0xC9C1
+// 0.172681
+0x161A
+// 0.177077
+0x16AA
+// -0.474887
+0xC337
+// 0.005125
+0x00A8
+// 0.249915
+0x1FFD
+// 0.134629
 0x113C
-// -0.146309
-0xED46
-// -0.257560
-0xDF08
-// 0.080454
-0x0A4C
-// 0.146770
-0x12C9
-// -0.147276
-0xED26
-// -0.447107
-0xC6C5
-// -0.626751
-0xAFC7
-// -0.116226
-0xF120
-// 0.659896
-0x5477
-// -0.003119
-0xFF9A
-// -0.084511
-0xF52F
-// -0.029391
-0xFC3D
-// -0.097470
-0xF386
-// -0.223682
-0xE35E
-// -0.466534
-0xC449
-// -0.019313
-0xFD87
-// -0.462713
-0xC4C6
-// 0.332775
-0x2A98
-// 0.176007
-0x1687
-// -0.239337
-0xE15D
-// 0.087994
-0x0B43
-// -0.133921
-0xEEDC
-// 0.183145
-0x1771
-// -0.368954
-0xD0C6
-// -0.138262
-0xEE4D
-// 0.198509
-0x1969
-// -0.246762
-0xE06A
-// -0.168132
-0xEA7B
-// -0.229493
-0xE2A0
-// 0.444092
-0x38D8
-// 0.212966
-0x1B42
-// -0.153016
-0xEC6A
-// -0.037990
-0xFB23
-// -0.193619
-0xE737
-// -0.011244
-0xFE90
-// 0.239071
-0x1E9A
-// -0.332605
-0xD56D
-// -0.050843
-0xF97E
-// -0.303860
-0xD91B
-// -0.017169
-0xFDCD
-// -0.283736
-0xDBAF
-// 0.173697
-0x163C
-// -0.174085
-0xE9B8
-// -0.265089
-0xDE12
-// -0.217283
-0xE430
-// 0.018817
-0x0269
-// 0.158760
-0x1452
-// 0.606893
-0x4DAF
-// -0.201113
-0xE642
-// 0.126385
-0x102D
-// -0.198119
-0xE6A4
-// -0.321020
-0xD6E9
-// -0.258425
-0xDEEC
-// 0.203364
-0x1A08
-// -0.029257
-0xFC41
-// -0.145828
-0xED55
-// 0.329177
-0x2A22
-// -0.488278
-0xC180
-// 0.048605
-0x0639
-// -0.046135
-0xFA18
-// 0.274017
+// -0.464134
+0xC497
+// 0.013730
+0x01C2
+// 0.498197
+0x3FC5
+// -0.181994
+0xE8B4
+// 0.100684
+0x0CE3
+// 0.104441
+0x0D5E
+// 0.046414
+0x05F1
+// 0.031547
+0x040A
+// 0.034141
+0x045F
+// -0.351834
+0xD2F7
+// -0.304417
+0xD909
+// -0.072747
+0xF6B0
+// -0.182315
+0xE8AA
+// -0.132034
+0xEF1A
+// 0.213516
+0x1B54
+// 0.199193
+0x197F
+// -0.519373
+0xBD85
+// 0.066145
+0x0877
+// 0.388094
+0x31AD
+// -0.160683
+0xEB6F
+// -0.074958
+0xF668
+// 0.235405
+0x1E22
+// -0.654801
+0xAC2F
+// -0.318453
+0xD73D
+// 0.157093
+0x141C
+// -0.443838
+0xC730
+// -0.226267
+0xE30A
+// -0.220794
+0xE3BD
+// 0.404994
+0x33D7
+// -0.051076
+0xF976
+// -0.200823
+0xE64B
+// -0.013720
+0xFE3E
+// -0.120766
+0xF08B
+// 0.259907
+0x2145
+// 0.075976
+0x09BA
+// 0.006047
+0x00C6
+// 0.563775
+0x482A
+// 0.091412
+0x0BB3
+// -0.254742
+0xDF65
+// -0.388772
+0xCE3D
+// -0.177424
+0xE94A
+// 0.358557
+0x2DE5
+// 0.274995
+0x2333
+// 0.224985
+0x1CCC
+// -0.102011
+0xF2F1
+// -0.088805
+0xF4A2
+// -0.120505
+0xF093
+// -0.126593
+0xEFCC
+// 0.340521
+0x2B96
+// 0.316452
+0x2882
+// 0.101047
+0x0CEF
+// -0.381566
+0xCF29
+// 0.138384
+0x11B7
+// 0.226299
+0x1CF7
+// 0.086041
+0x0B03
+// -0.408869
+0xCBAA
+// -0.145272
+0xED68
+// -0.219857
+0xE3DC
+// 0.049876
+0x0662
+// -0.129084
+0xEF7A
+// -0.370050
+0xD0A2
+// -0.022851
+0xFD13
+// -0.258527
+0xDEE9
+// 0.278910
+0x23B3
+// -0.345184
+0xD3D1
+// 0.274853
+0x232E
+// 0.158334
+0x1444
+// 0.345079
+0x2C2C
+// 0.053978
+0x06E9
+// 0.005433
+0x00B2
+// -0.447277
+0xC6C0
+// -0.371771
+0xD06A
+// -0.079582
+0xF5D0
+// -0.304091
+0xD914
+// 0.127178
+0x1047
+// -0.158809
+0xEBAC
+// 0.019763
+0x0288
+// -0.357510
+0xD23D
+// -0.106581
+0xF25C
+// 0.139115
+0x11CF
+// -0.172316
+0xE9F2
+// 0.187618
+0x1804
+// 0.118097
+0x0F1E
+// 0.229794
+0x1D6A
+// -0.224052
+0xE352
+// -0.530951
+0xBC0A
+// -0.406135
+0xCC04
+// 0.291448
+0x254E
+// 0.141897
+0x122A
+// -0.360549
+0xD1DA
+// -0.167139
+0xEA9B
+// -0.352780
+0xD2D8
+// -0.243341
+0xE0DA
+// -0.317399
+0xD75F
+// 0.264476
+0x21DA
+// -0.015751
+0xFDFC
+// 0.474425
+0x3CBA
+// -0.248358
+0xE036
+// -0.354521
+0xD29F
+// -0.126157
+0xEFDA
+// 0.109950
+0x0E13
+// -0.499531
+0xC00F
+// -0.180244
+0xE8EE
+// -0.072239
+0xF6C1
+// 0.274029
 0x2313
-// -0.291134
-0xDABC
-// 0.209078
-0x1AC3
-// -0.195170
-0xE705
-// -0.123677
-0xF02B
-// -0.380794
-0xCF42
-// 0.099891
-0x0CC9
-// 0.369357
-0x2F47
-// 0.493399
-0x3F28
-// -0.084075
-0xF53D
-// -0.160714
-0xEB6E
-// 0.483336
-0x3DDE
-// 0.058959
-0x078C
-// -0.302299
-0xD94E
-// -0.152269
-0xEC82
-// -0.014753
-0xFE1D
-// 0.301407
-0x2695
-// -0.169899
-0xEA41
-// -0.247576
-0xE04F
-// 0.138889
-0x11C7
-// 0.332189
-0x2A85
-// -0.423060
-0xC9D9
-// -0.405520
-0xCC18
-// -0.563335
-0xB7E5
-// 0.193280
-0x18BD
-// -0.035000
-0xFB85
-// -0.201113
-0xE642
-// -0.188173
-0xE7EA
-// -0.363824
-0xD16E
-// -0.270723
-0xDD59
-// 0.031797
-0x0412
-// -0.056612
-0xF8C1
-// -0.028466
+// 0.263006
+0x21AA
+// 0.146829
+0x12CB
+// -0.331136
+0xD59D
+// 0.250057
+0x2002
+// 0.000826
+0x001B
+// 0.279664
+0x23CC
+// 0.070157
+0x08FB
+// 0.197936
+0x1956
+// -0.000371
+0xFFF4
+// 0.109986
+0x0E14
+// -0.024795
+0xFCD4
+// -0.182892
+0xE897
+// -0.124319
+0xF016
+// 0.123665
+0x0FD4
+// -0.373455
+0xD033
+// -0.479104
+0xC2AD
+// 0.051170
+0x068D
+// 0.107119
+0x0DB6
+// 0.004598
+0x0097
+// -0.032747
+0xFBCF
+// 0.299399
+0x2653
+// 0.016864
+0x0229
+// -0.374512
+0xD010
+// 0.060446
+0x07BD
+// -0.193229
+0xE744
+// 0.105214
+0x0D78
+// 0.154191
+0x13BD
+// 0.275091
+0x2336
+// -0.155882
+0xEC0C
+// 0.576078
+0x49BD
+// 0.341248
+0x2BAE
+// -0.307469
+0xD8A5
+// 0.361299
+0x2E3F
+// 0.052545
+0x06BA
+// 0.069176
+0x08DB
+// 0.244328
+0x1F46
+// -0.228640
+0xE2BC
+// 0.664133
+0x5502
+// 0.488510
+0x3E87
+// -0.028480
 0xFC5B
-// 0.048911
-0x0643
-// -0.082254
-0xF579
-// 0.475141
-0x3CD1
-// -0.329051
-0xD5E2
-// 0.018685
-0x0264
-// -0.332132
-0xD57D
-// 0.230007
-0x1D71
-// 0.215507
-0x1B96
-// 0.362221
-0x2E5D
-// -0.109500
-0xF1FC
-// 0.075172
-0x099F
-// -0.391437
-0xCDE5
-// -0.289853
-0xDAE6
-// -0.102214
-0xF2EB
-// -0.226750
-0xE2FA
-// 0.246140
-0x1F82
-// 0.401249
-0x335C
-// -0.471605
-0xC3A2
-// 0.166570
-0x1552
-// 0.009620
-0x013B
-// 0.108647
-0x0DE8
-// 0.209025
-0x1AC1
-// -0.245452
-0xE095
-// -0.290600
-0xDACE
-// 0.203187
-0x1A02
-// 0.217030
-0x1BC8
-// -0.033618
-0xFBB2
-// 0.406465
-0x3407
-// -0.315529
-0xD79D
-// -0.122034
+// -0.838548
+0x94AA
+// 0.012385
+0x0196
+// -0.054374
+0xF90A
+// 0.334746
+0x2AD9
+// 0.163013
+0x14DE
+// -0.300997
+0xD979
+// -0.374917
+0xD003
+// 0.113460
+0x0E86
+// -0.245360
+0xE098
+// 0.268323
+0x2258
+// -0.380993
+0xCF3C
+// 0.076264
+0x09C3
+// -0.380272
+0xCF53
+// -0.453868
+0xC5E8
+// -0.055266
+0xF8ED
+// 0.177176
+0x16AE
+// 0.093531
+0x0BF9
+// 0.378528
+0x3074
+// 0.114692
+0x0EAE
+// 0.097907
+0x0C88
+// -0.150966
+0xECAD
+// 0.552321
+0x46B2
+// 0.339352
+0x2B70
+// -0.101066
+0xF310
+// 0.572773
+0x4951
+// 0.153959
+0x13B5
+// 0.014051
+0x01CC
+// 0.481592
+0x3DA5
+// 0.282537
+0x242A
+// -0.122048
 0xF061
-// 0.138598
-0x11BE
-// 0.350075
-0x2CCF
-// -0.048214
-0xF9D4
-// 0.111071
-0x0E38
-// 0.096054
-0x0C4C
-// 0.029124
-0x03BA
-// -0.340593
-0xD467
-// 0.337999
-0x2B44
-// 0.274311
-0x231D
-// -0.353366
-0xD2C5
-// -0.047872
-0xF9DF
-// -0.243305
-0xE0DB
-// 0.193119
-0x18B8
-// -0.677478
-0xA948
-// -0.568480
-0xB73C
-// 0.006003
-0x00C5
-// -0.143932
-0xED94
-// 0.061229
-0x07D6
-// 0.035931
-0x0499
-// 0.107217
-0x0DB9
-// 0.050038
-0x0668
-// 0.011274
-0x0171
-// 0.163167
-0x14E3
+// -0.091800
+0xF440
+// 0.133469
+0x1116
+// -0.524508
+0xBCDD
+// 0.212452
+0x1B32
+// 0.226395
+0x1CFB
+// 0.302216
+0x26AF
+// -0.245210
+0xE09D
+// -0.346385
+0xD3AA
+// 0.171634
+0x15F8
+// -0.311721
+0xD81A
+// 0.091891
+0x0BC3
+// -0.325059
+0xD664
+// 0.203587
+0x1A0F
+// -0.346681
+0xD3A0
+// 0.042937
+0x057F
+// 0.320559
+0x2908
+// -0.200369
+0xE65A
+// -0.310160
+0xD84D
+// 0.318128
+0x28B8
+// -0.291716
+0xDAA9
+// -0.121975
+0xF063
+// -0.021586
+0xFD3D
+// -0.094298
+0xF3EE
+// 0.192603
+0x18A7
+// -0.090740
+0xF463
+// -0.105027
+0xF28E
+// -0.280696
+0xDC12
+// 0.085990
+0x0B02
+// 0.194891
+0x18F2
+// 0.154828
+0x13D1
+// -0.010551
+0xFEA6
+// -0.332513
+0xD570

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference3_q15.txt

@@ -1,514 +1,514 @@
 H
 256
-// 0.027221
-0x037C
-// 0.004075
-0x0086
-// 0.018180
-0x0254
-// 0.000485
-0x0010
-// 0.027875
-0x0391
-// 0.003715
-0x007A
-// 0.189663
-0x1847
-// 0.002266
-0x004A
-// 0.034870
-0x0477
-// 0.032953
-0x0438
-// 0.015385
-0x01F8
-// 0.011645
-0x017E
-// 0.008825
-0x0121
-// 0.025334
-0x033E
-// 0.333667
-0x2AB6
-// 0.146112
-0x12B4
-// 0.025703
-0x034A
-// 0.191666
-0x1889
-// 0.167292
-0x156A
-// 0.033290
-0x0443
-// 0.039048
-0x0500
-// 0.113596
-0x0E8A
-// 0.001556
-0x0033
-// 0.005965
-0x00C3
-// 0.043371
-0x058D
-// 0.024266
-0x031B
-// 0.136688
-0x117F
-// 0.009534
-0x0138
-// 0.004184
-0x0089
-// 0.013272
-0x01B3
-// 0.004489
-0x0093
-// 0.028756
-0x03AE
-// 0.002972
+// 0.050209
+0x066D
+// 0.005764
+0x00BD
+// 0.034541
+0x046C
+// 0.018908
+0x026C
+// 0.027124
+0x0379
+// 0.031053
+0x03FA
+// 0.002232
+0x0049
+// 0.018275
+0x0257
+// 0.066331
+0x087E
+// 0.056238
+0x0733
+// 0.026028
+0x0355
+// 0.050869
+0x0683
+// 0.132626
+0x10FA
+// 0.000261
+0x0009
+// 0.020158
+0x0295
+// 0.059770
+0x07A7
+// 0.002959
 0x0061
-// 0.233681
-0x1DE9
-// 0.331943
-0x2A7D
-// 0.005430
-0x00B2
-// 0.019329
-0x0279
-// 0.007098
-0x00E9
-// 0.095188
-0x0C2F
-// 0.004089
-0x0086
-// 0.287044
-0x24BE
-// 0.005671
-0x00BA
-// 0.001372
-0x002D
-// 0.011169
-0x016E
-// 0.183648
-0x1782
-// 0.003593
-0x0076
-// 0.061344
-0x07DA
-// 0.002136
-0x0046
-// 0.000013
-0x0000
-// 0.023085
-0x02F4
-// 0.002727
-0x0059
-// 0.003630
-0x0077
-// 0.002142
-0x0046
-// 0.000390
-0x000D
-// 0.191107
-0x1876
-// 0.012281
-0x0192
-// 0.004095
-0x0086
-// 0.033010
-0x043A
-// 0.000535
-0x0012
-// 0.016539
-0x021E
-// 0.032154
-0x041E
-// 0.003075
-0x0065
-// 0.012723
-0x01A1
-// 0.002014
-0x0042
-// 0.125658
-0x1016
-// 0.182891
-0x1769
-// 0.041572
-0x0552
-// 0.091718
-0x0BBD
-// 0.005097
-0x00A7
-// 0.008764
-0x011F
-// 0.007986
-0x0106
-// 0.058355
-0x0778
-// 0.001073
-0x0023
-// 0.018509
-0x025F
-// 0.061556
-0x07E1
-// 0.044749
-0x05BA
-// 0.051847
-0x06A3
-// 0.041595
-0x0553
-// 0.081820
-0x0A79
-// 0.002945
-0x0060
-// 0.000706
-0x0017
-// 0.178530
-0x16DA
-// 0.000577
-0x0013
-// 0.189157
-0x1836
-// 0.015287
-0x01F5
-// 0.023713
-0x0309
-// 0.152467
-0x1384
-// 0.033702
-0x0450
-// 0.282436
-0x2427
-// 0.055991
-0x072B
-// 0.010352
-0x0153
-// 0.001823
-0x003C
-// 0.054297
-0x06F3
-// 0.002008
-0x0042
-// 0.007142
+// 0.007148
 0x00EA
-// 0.054204
-0x06F0
-// 0.005535
-0x00B5
-// 0.000450
-0x000F
-// 0.001526
-0x0032
-// 0.015221
-0x01F3
-// 0.041944
-0x055E
-// 0.050485
-0x0676
-// 0.320633
-0x290A
-// 0.238172
-0x1E7C
-// 0.077731
-0x09F3
-// 0.072360
-0x0943
-// 0.034232
-0x0462
-// 0.000161
-0x0005
-// 0.167919
-0x157E
-// 0.012595
-0x019D
-// 0.014871
-0x01E7
-// 0.046085
-0x05E6
-// 0.004497
+// 0.007530
+0x00F7
+// 0.003494
+0x0073
+// 0.328352
+0x2A07
+// 0.005322
+0x00AE
+// 0.016341
+0x0217
+// 0.012791
+0x01A3
+// 0.000183
+0x0006
+// 0.008915
+0x0124
+// 0.000988
+0x0020
+// 0.004480
 0x0093
-// 0.014965
-0x01EA
-// 0.015068
-0x01EE
-// 0.138874
-0x11C7
-// 0.272890
-0x22EE
-// 0.009384
-0x0134
-// 0.302516
-0x26B9
-// 0.000007
-0x0000
-// 0.004962
-0x00A3
-// 0.000600
-0x0014
-// 0.006600
-0x00D8
-// 0.034758
-0x0473
-// 0.151204
-0x135B
-// 0.000259
-0x0008
-// 0.148738
-0x130A
-// 0.076930
-0x09D9
-// 0.021521
-0x02C1
-// 0.039794
-0x0518
-// 0.005379
-0x00B0
-// 0.012459
-0x0198
-// 0.023302
-0x02FC
-// 0.094568
-0x0C1B
-// 0.013280
-0x01B3
-// 0.027375
-0x0381
-// 0.042301
-0x056A
-// 0.019638
-0x0283
-// 0.036588
-0x04AF
-// 0.137007
-0x1189
-// 0.031508
-0x0408
-// 0.016266
-0x0215
-// 0.001003
-0x0021
-// 0.026043
-0x0355
-// 0.000088
-0x0003
-// 0.039706
-0x0515
-// 0.076852
-0x09D6
-// 0.001796
-0x003B
-// 0.064142
-0x0836
-// 0.000205
-0x0007
-// 0.055928
-0x0729
-// 0.020960
-0x02AF
-// 0.021053
-0x02B2
-// 0.048818
-0x0640
-// 0.032798
-0x0433
-// 0.000246
-0x0008
-// 0.017510
-0x023E
-// 0.255872
-0x20C0
-// 0.028098
-0x0399
-// 0.011097
-0x016C
-// 0.027268
-0x037E
-// 0.071592
-0x092A
-// 0.046395
-0x05F0
-// 0.028731
-0x03AD
-// 0.000595
-0x0013
-// 0.014773
-0x01E4
-// 0.075276
-0x09A3
-// 0.165628
-0x1533
-// 0.001641
-0x0036
-// 0.001479
-0x0030
-// 0.052162
-0x06AD
-// 0.058882
-0x0789
-// 0.030368
-0x03E3
-// 0.026462
-0x0363
-// 0.010626
-0x015C
-// 0.100734
-0x0CE5
-// 0.006932
-0x00E3
-// 0.094774
-0x0C22
-// 0.169120
-0x15A6
-// 0.004911
-0x00A1
-// 0.017943
-0x024C
-// 0.162291
-0x14C6
-// 0.002415
-0x004F
-// 0.063485
-0x0820
-// 0.016107
-0x0210
-// 0.000151
-0x0005
-// 0.063111
-0x0814
-// 0.020053
-0x0291
-// 0.042581
-0x0573
-// 0.013401
-0x01B7
-// 0.076660
-0x09D0
-// 0.124338
-0x0FEA
-// 0.114241
-0x0E9F
-// 0.220461
-0x1C38
-// 0.025952
-0x0352
-// 0.000851
+// 0.172341
+0x160F
+// 0.034587
+0x046D
+// 0.133336
+0x1111
+// 0.324882
+0x2996
+// 0.007747
+0x00FE
+// 0.024979
+0x0333
+// 0.002344
+0x004D
+// 0.139736
+0x11E3
+// 0.043765
+0x059A
+// 0.038250
+0x04E5
+// 0.122109
+0x0FA1
+// 0.022463
+0x02E0
+// 0.000530
+0x0011
+// 0.000057
+0x0002
+// 0.130731
+0x10BC
+// 0.021704
+0x02C7
+// 0.022824
+0x02EC
+// 0.164149
+0x1503
+// 0.000019
+0x0001
+// 0.045461
+0x05D2
+// 0.013193
+0x01B0
+// 0.156799
+0x1412
+// 0.000137
+0x0004
+// 0.180658
+0x1720
+// 0.024109
+0x0316
+// 0.007379
+0x00F2
+// 0.007940
+0x0104
+// 0.001568
+0x0033
+// 0.000724
+0x0018
+// 0.000848
 0x001C
-// 0.028098
-0x0399
-// 0.024599
-0x0326
-// 0.091956
-0x0BC5
-// 0.050915
+// 0.090101
+0x0B88
+// 0.067452
+0x08A2
+// 0.003852
+0x007E
+// 0.024194
+0x0319
+// 0.012689
+0x01A0
+// 0.033183
+0x043F
+// 0.028881
+0x03B2
+// 0.196343
+0x1922
+// 0.003185
+0x0068
+// 0.109630
+0x0E08
+// 0.018793
+0x0268
+// 0.004090
+0x0086
+// 0.040335
+0x052A
+// 0.312086
+0x27F2
+// 0.073815
+0x0973
+// 0.017963
+0x024D
+// 0.143385
+0x125A
+// 0.037265
+0x04C5
+// 0.035484
+0x048B
+// 0.119386
+0x0F48
+// 0.001899
+0x003E
+// 0.029355
+0x03C2
+// 0.000137
+0x0004
+// 0.010616
+0x015C
+// 0.049169
+0x064B
+// 0.004202
+0x008A
+// 0.000027
+0x0001
+// 0.231349
+0x1D9D
+// 0.006082
+0x00C7
+// 0.047234
+0x060C
+// 0.110014
+0x0E15
+// 0.022913
+0x02EF
+// 0.093578
+0x0BFA
+// 0.055044
+0x070C
+// 0.036844
+0x04B7
+// 0.007574
+0x00F8
+// 0.005740
+0x00BC
+// 0.010570
+0x015A
+// 0.011665
+0x017E
+// 0.084401
+0x0ACE
+// 0.072891
+0x0954
+// 0.007432
+0x00F4
+// 0.105973
+0x0D91
+// 0.013939
+0x01C9
+// 0.037275
+0x04C5
+// 0.005389
+0x00B1
+// 0.121681
+0x0F93
+// 0.015361
+0x01F7
+// 0.035183
+0x0481
+// 0.001811
+0x003B
+// 0.012128
+0x018D
+// 0.099673
+0x0CC2
+// 0.000380
+0x000C
+// 0.048649
+0x063A
+// 0.056622
+0x073F
+// 0.086728
+0x0B1A
+// 0.054987
+0x070A
+// 0.018247
+0x0256
+// 0.086675
+0x0B18
+// 0.002121
+0x0045
+// 0.000021
+0x0001
+// 0.145616
+0x12A4
+// 0.100602
+0x0CE1
+// 0.004610
+0x0097
+// 0.067308
+0x089E
+// 0.011773
+0x0182
+// 0.018357
+0x025A
+// 0.000284
+0x0009
+// 0.093032
+0x0BE8
+// 0.008268
+0x010F
+// 0.014087
+0x01CE
+// 0.021613
+0x02C4
+// 0.025622
+0x0348
+// 0.010152
+0x014D
+// 0.038436
+0x04EB
+// 0.036539
+0x04AD
+// 0.205195
+0x1A44
+// 0.120060
+0x0F5E
+// 0.061827
+0x07EA
+// 0.014656
+0x01E0
+// 0.094620
+0x0C1D
+// 0.020333
+0x029A
+// 0.090587
+0x0B98
+// 0.043101
+0x0584
+// 0.073328
+0x0963
+// 0.050913
 0x0684
-// 0.000702
-0x0017
-// 0.002226
-0x0049
-// 0.000563
-0x0012
-// 0.001662
-0x0036
-// 0.004700
-0x009A
-// 0.156835
-0x1413
-// 0.075218
-0x09A1
-// 0.000243
-0x0008
-// 0.076634
-0x09CF
-// 0.036752
-0x04B4
-// 0.032264
-0x0421
-// 0.091147
-0x0BAB
-// 0.008330
-0x0111
-// 0.003926
-0x0081
-// 0.106444
-0x0DA0
-// 0.058365
-0x0779
-// 0.007258
-0x00EE
-// 0.035718
-0x0492
-// 0.042088
-0x0563
-// 0.111848
-0x0E51
-// 0.154510
-0x13C7
-// 0.019275
-0x0278
-// 0.000064
-0x0002
-// 0.008200
-0x010D
-// 0.030353
-0x03E3
-// 0.041853
-0x055B
-// 0.058667
-0x0782
-// 0.028681
-0x03AC
-// 0.032722
-0x0430
-// 0.000785
+// 0.000181
+0x0006
+// 0.163829
+0x14F8
+// 0.044897
+0x05BF
+// 0.091483
+0x0BB6
+// 0.011585
+0x017C
+// 0.008799
+0x0120
+// 0.181628
+0x1740
+// 0.023647
+0x0307
+// 0.003798
+0x007C
+// 0.054658
+0x06FF
+// 0.050349
+0x0672
+// 0.015692
+0x0202
+// 0.079812
+0x0A37
+// 0.045513
+0x05D3
+// 0.000000
+0x0000
+// 0.056929
+0x0749
+// 0.003583
+0x0075
+// 0.028517
+0x03A6
+// 0.000000
+0x0000
+// 0.008805
+0x0121
+// 0.000447
+0x000F
+// 0.024347
+0x031E
+// 0.011250
+0x0171
+// 0.011131
+0x016D
+// 0.101515
+0x0CFE
+// 0.167077
+0x1563
+// 0.001906
+0x003E
+// 0.008352
+0x0112
+// 0.000015
+0x0001
+// 0.000781
 0x001A
-// 0.114774
-0x0EB1
-// 0.069164
-0x08DA
-// 0.010346
-0x0153
-// 0.013345
-0x01B5
-// 0.085138
-0x0AE6
-// 0.001615
-0x0035
-// 0.008570
-0x0119
-// 0.006410
-0x00D2
-// 0.000589
+// 0.065247
+0x085A
+// 0.000207
+0x0007
+// 0.102091
+0x0D11
+// 0.002659
+0x0057
+// 0.027177
+0x037B
+// 0.008058
+0x0108
+// 0.017305
+0x0237
+// 0.055082
+0x070D
+// 0.017687
+0x0244
+// 0.241556
+0x1EEB
+// 0.084761
+0x0AD9
+// 0.068811
+0x08CF
+// 0.095014
+0x0C29
+// 0.002010
+0x0042
+// 0.003483
+0x0072
+// 0.043451
+0x0590
+// 0.038051
+0x04DF
+// 0.321046
+0x2918
+// 0.173702
+0x163C
+// 0.000590
 0x0013
-// 0.080588
-0x0A51
-// 0.079365
-0x0A29
-// 0.052274
-0x06B1
-// 0.086746
-0x0B1A
-// 0.001592
-0x0034
-// 0.041124
-0x0544
-// 0.025909
-0x0351
-// 0.318852
-0x28D0
-// 0.224507
-0x1CBD
-// 0.000025
-0x0001
-// 0.014392
-0x01D8
-// 0.002604
-0x0055
-// 0.000897
-0x001D
-// 0.007986
-0x0106
-// 0.001739
-0x0039
-// 0.000088
+// 0.511814
+0x4183
+// 0.000112
+0x0004
+// 0.002152
+0x0047
+// 0.081562
+0x0A71
+// 0.019342
+0x027A
+// 0.065945
+0x0871
+// 0.102312
+0x0D19
+// 0.009370
+0x0133
+// 0.043819
+0x059C
+// 0.052405
+0x06B5
+// 0.105655
+0x0D86
+// 0.004233
+0x008B
+// 0.105256
+0x0D79
+// 0.149939
+0x1331
+// 0.002223
+0x0049
+// 0.022849
+0x02ED
+// 0.006367
+0x00D1
+// 0.104293
+0x0D59
+// 0.009575
+0x013A
+// 0.006977
+0x00E5
+// 0.016589
+0x0220
+// 0.222044
+0x1C6C
+// 0.083822
+0x0ABB
+// 0.007435
+0x00F4
+// 0.238793
+0x1E91
+// 0.017253
+0x0235
+// 0.000144
+0x0005
+// 0.168816
+0x159C
+// 0.058104
+0x0770
+// 0.010842
+0x0163
+// 0.006134
+0x00C9
+// 0.012966
+0x01A9
+// 0.200245
+0x19A2
+// 0.032853
+0x0435
+// 0.037307
+0x04C6
+// 0.066480
+0x0882
+// 0.043766
+0x059A
+// 0.087332
+0x0B2E
+// 0.021442
+0x02BF
+// 0.070727
+0x090E
+// 0.006146
+0x00C9
+// 0.076910
+0x09D8
+// 0.030169
+0x03DD
+// 0.087481
+0x0B33
+// 0.001342
+0x002C
+// 0.074795
+0x0993
+// 0.029223
+0x03BE
+// 0.070021
+0x08F6
+// 0.073665
+0x096E
+// 0.061941
+0x07EE
+// 0.010829
+0x0163
+// 0.000339
+0x000B
+// 0.006472
+0x00D4
+// 0.027001
+0x0375
+// 0.005993
+0x00C4
+// 0.008029
+0x0107
+// 0.057350
+0x0757
+// 0.005382
+0x00B0
+// 0.027646
+0x038A
+// 0.017448
+0x023C
+// 0.000081
 0x0003
-// 0.018495
-0x025E
+// 0.080478
+0x0A4D

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference4_q15.txt

@@ -1,514 +1,514 @@
 H
 256
-// 0.291372
-0x254C
-// -0.112738
-0xF192
-// -0.238117
-0xE185
-// -0.038878
-0xFB06
-// -0.294852
-0xDA42
-// 0.107647
-0x0DC7
-// -0.769109
-0x9D8E
-// -0.084075
-0xF53D
-// -0.329781
-0xD5CA
-// -0.320584
-0xD6F7
-// -0.219050
-0xE3F6
-// -0.190578
-0xE79B
-// -0.165900
-0xEAC4
-// -0.281091
-0xDC05
-// 1.020124
-0x7FFF
-// -0.675056
-0xA998
-// 0.283130
-0x243E
-// -0.773159
-0x9D09
-// 0.722326
-0x5C75
-// 0.322220
-0x293F
-// 0.348974
-0x2CAB
-// -0.595221
-0xB3D0
-// 0.069654
-0x08EA
-// -0.136401
-0xEE8A
-// -0.367788
-0xD0EC
-// 0.275101
-0x2337
-// -0.652923
-0xAC6D
-// 0.172436
-0x1612
-// -0.114230
-0xF161
-// -0.203455
-0xE5F5
-// -0.118325
-0xF0DB
-// -0.299473
-0xD9AB
-// 0.096281
-0x0C53
-// -0.853706
-0x92BA
-// 1.017484
-0x7FFF
-// -0.130138
-0xEF58
-// -0.245529
-0xE093
-// -0.148787
-0xECF5
-// -0.544863
-0xBA42
-// -0.112934
-0xF18B
-// -0.946172
-0x86E4
-// 0.132993
-0x1106
-// -0.065405
-0xF7A1
-// 0.186642
-0x17E4
-// 0.756814
-0x60DF
-// -0.105861
-0xF273
-// 0.437403
-0x37FD
-// 0.081627
-0x0A73
-// 0.006338
-0x00D0
-// -0.268326
-0xDDA7
-// 0.092221
-0x0BCE
-// -0.106395
-0xF262
-// -0.081742
-0xF589
-// 0.034894
-0x0477
-// 0.772030
-0x62D2
-// -0.195714
-0xE6F3
-// -0.113011
-0xF189
-// -0.320860
-0xD6EE
-// 0.040862
-0x053B
-// -0.227119
-0xE2EE
-// -0.316674
-0xD777
-// -0.097933
-0xF377
-// -0.199199
-0xE681
-// 0.079258
-0x0A25
-// 0.626025
-0x5022
-// 0.755253
-0x60AC
-// 0.360077
-0x2E17
-// 0.534840
-0x4476
-// 0.126088
-0x1024
-// -0.165333
-0xEAD6
-// 0.157822
-0x1434
-// -0.426616
-0xC965
-// 0.057844
-0x0767
-// -0.240266
-0xE13F
-// 0.438159
-0x3816
-// 0.373584
-0x2FD2
-// 0.402123
-0x3379
-// -0.360179
-0xD1E6
-// -0.505158
-0xBF57
-// 0.095831
-0x0C44
-// 0.046939
-0x0602
-// 0.746193
-0x5F83
-// -0.042432
-0xFA92
-// 0.768082
-0x6251
-// 0.218351
-0x1BF3
-// 0.271949
-0x22CF
-// -0.689579
-0xA7BC
-// 0.324210
-0x2980
-// 0.938547
-0x7822
-// -0.417882
-0xCA83
-// 0.179682
-0x1700
-// 0.075396
-0x09A7
-// -0.411513
-0xCB54
-// -0.079135
-0xF5DF
-// 0.149243
-0x131A
-// -0.411160
-0xCB5F
-// -0.131389
-0xEF2F
-// 0.037460
-0x04CB
-// 0.068980
-0x08D4
-// 0.217882
-0x1BE4
-// -0.361686
-0xD1B4
-// 0.396804
-0x32CA
+// 0.391039
+0x320E
+// 0.132494
+0x10F6
+// 0.324339
+0x2984
+// -0.239965
+0xE149
+// -0.287413
+0xDB36
+// 0.307525
+0x275D
+// 0.082443
+0x0A8D
+// 0.235917
+0x1E33
+// -0.449457
+0xC678
+// 0.413851
+0x34F9
+// -0.281545
+0xDBF6
+// 0.393602
+0x3262
+// -0.635543
+0xAEA7
+// 0.028199
+0x039C
+// 0.247774
+0x1FB7
+// 0.426651
+0x369D
+// -0.094929
+0xF3D9
+// 0.147548
+0x12E3
+// -0.151437
+0xEC9E
+// 0.103162
+0x0D34
 // -1.000000
 0x8000
-// -0.861870
-0x91AE
-// 0.492371
-0x3F06
-// -0.475058
-0xC331
-// -0.326745
-0xD62D
-// 0.022422
-0x02DF
-// 0.723679
-0x5CA2
-// -0.198195
-0xE6A2
-// 0.215361
-0x1B91
-// 0.379118
-0x3087
-// -0.118425
-0xF0D7
-// -0.216039
-0xE459
-// 0.216784
-0x1BC0
-// 0.658123
-0x543D
-// 0.922551
-0x7616
-// 0.171079
-0x15E6
-// -0.971339
-0x83AB
-// 0.004590
-0x0096
-// 0.124396
-0x0FEC
-// 0.043263
-0x058A
-// 0.143471
-0x125D
-// 0.329250
-0x2A25
-// 0.686717
-0x57E6
-// 0.028428
-0x03A4
-// 0.681094
-0x572E
-// -0.489830
-0xC14D
-// -0.259075
-0xDED7
-// 0.352294
-0x2D18
-// -0.129524
-0xEF6C
-// 0.197127
-0x193B
-// -0.269581
-0xDD7E
-// 0.543085
-0x4584
-// 0.203516
-0x1A0D
-// -0.292197
-0xDA99
-// 0.363223
-0x2E7E
-// 0.247482
-0x1FAE
-// 0.337804
-0x2B3D
-// -0.653685
-0xAC54
-// -0.313478
-0xD7E0
-// 0.225233
-0x1CD4
-// 0.055920
-0x0728
-// 0.284999
-0x247B
-// 0.016551
-0x021E
-// -0.351903
-0xD2F5
-// 0.489580
-0x3EAB
-// 0.074839
-0x0994
-// 0.447269
-0x3940
-// 0.025272
-0x033C
-// 0.417648
-0x3575
-// -0.255674
-0xDF46
-// 0.256246
-0x20CD
-// 0.390200
-0x31F2
-// 0.319831
-0x28F0
-// -0.027698
-0xFC74
-// -0.233688
-0xE216
-// -0.893321
-0x8DA8
-// 0.296030
-0x25E4
-// -0.186033
-0xE830
-// 0.291623
-0x2554
-// 0.472528
-0x3C7C
-// 0.380391
-0x30B1
-// -0.299344
-0xD9AF
-// 0.043065
-0x0583
-// 0.214653
-0x1B7A
-// -0.484534
-0xC1FB
-// 0.718725
-0x5BFF
-// -0.071545
-0xF6D8
-// 0.067909
-0x08B1
-// -0.403341
-0xCC5F
-// 0.428537
-0x36DA
-// -0.307753
-0xD89C
-// 0.287282
-0x24C6
-// 0.182047
-0x174D
-// 0.560512
-0x47BF
-// -0.147036
-0xED2E
-// -0.543678
-0xBA69
-// -0.726262
-0xA30A
-// 0.123755
-0x0FD7
-// 0.236564
-0x1E48
-// -0.711449
-0xA4EF
-// -0.086785
-0xF4E4
-// 0.444971
-0x38F5
-// 0.224133
-0x1CB0
-// 0.021716
-0x02C8
-// -0.443658
-0xC736
-// 0.250084
-0x2003
-// 0.364422
-0x2EA5
-// -0.204438
-0xE5D5
-// -0.488969
-0xC169
-// 0.622727
-0x4FB6
-// 0.596908
-0x4C67
-// 0.829206
-0x6A23
-// -0.284500
-0xDB96
-// 0.051519
-0x0698
-// 0.296029
-0x25E4
-// 0.276982
-0x2374
-// 0.535533
-0x448C
-// 0.398493
-0x3302
-// -0.046804
-0xFA02
-// 0.083330
-0x0AAB
-// 0.041901
-0x055D
-// -0.071995
-0xF6C9
-// 0.121075
-0x0F7F
-// -0.699388
-0xA67A
-// 0.484348
-0x3DFF
-// -0.027504
-0xFC7B
-// 0.488884
-0x3E94
-// -0.338561
-0xD4AA
-// -0.317218
-0xD765
-// -0.533173
-0xBBC1
-// 0.161179
-0x14A2
-// -0.110650
-0xF1D6
-// 0.576178
-0x49C0
-// 0.426651
-0x369C
-// 0.150455
-0x1342
-// 0.333766
-0x2AB9
-// -0.362308
-0xD1A0
-// -0.590622
-0xB467
-// 0.694183
-0x58DB
-// -0.245185
-0xE09E
-// -0.014160
-0xFE30
-// -0.159924
-0xEB88
-// -0.307676
-0xD89E
-// 0.361295
-0x2E3F
-// 0.427751
-0x36C1
-// -0.299083
-0xD9B8
-// -0.319458
-0xD71C
-// 0.049485
-0x0656
-// -0.598299
-0xB36B
-// 0.464446
-0x3B73
-// 0.179628
-0x16FE
-// -0.204011
-0xE5E3
-// -0.515296
-0xBE0B
-// 0.070968
-0x0915
-// -0.163492
-0xEB13
-// -0.141388
-0xEDE7
-// -0.042870
-0xFA83
-// 0.501338
-0x402C
-// -0.497520
-0xC051
-// -0.403774
-0xCC51
-// 0.520140
-0x4294
-// 0.070466
-0x0905
-// 0.358134
-0x2DD7
-// -0.284262
-0xDB9D
-// 0.997219
-0x7FA5
-// 0.836779
-0x6B1C
-// -0.008837
-0xFEDE
-// 0.211862
-0x1B1E
-// -0.090126
-0xF477
-// -0.052889
-0xF93B
-// -0.157819
-0xEBCD
-// -0.073654
-0xF692
-// -0.016595
-0xFDE0
-// -0.240174
-0xE142
+// 0.127316
+0x104C
+// -0.223084
+0xE372
+// 0.197370
+0x1943
+// 0.023579
+0x0305
+// -0.164779
+0xEAE9
+// -0.054862
+0xF8FA
+// -0.116807
+0xF10C
+// -0.724476
+0xA344
+// -0.324554
+0xD675
+// -0.637242
+0xAE6F
+// 0.994701
+0x7F52
+// 0.153605
+0x13A9
+// -0.275814
+0xDCB2
+// 0.084495
+0x0AD1
+// 0.652355
+0x5380
+// 0.365086
+0x2EBB
+// 0.341305
+0x2BB0
+// -0.609822
+0xB1F1
+// -0.261556
+0xDE85
+// 0.040176
+0x0524
+// -0.013211
+0xFE4F
+// 0.630985
+0x50C4
+// -0.257101
+0xDF17
+// -0.263646
+0xDE41
+// 0.707048
+0x5A81
+// -0.007630
+0xFF06
+// -0.372092
+0xD05F
+// -0.200446
+0xE658
+// 0.691038
+0x5874
+// -0.020442
+0xFD62
+// -0.741753
+0xA10E
+// 0.270967
+0x22AF
+// -0.149906
+0xECD0
+// -0.155500
+0xEC19
+// -0.069104
+0xF728
+// -0.046970
+0xF9FD
+// -0.050831
+0xF97E
+// 0.523837
+0x430D
+// 0.453239
+0x3A04
+// 0.108311
+0x0DDD
+// 0.271445
+0x22BF
+// 0.196582
+0x192A
+// -0.317899
+0xD74F
+// -0.296574
+0xDA0A
+// 0.773282
+0x62FB
+// -0.098481
+0xF365
+// -0.577823
+0xB60A
+// 0.239237
+0x1E9F
+// 0.111604
+0x0E49
+// -0.350488
+0xD323
+// 0.974917
+0x7CCA
+// 0.474137
+0x3CB1
+// -0.233892
+0xE210
+// 0.660819
+0x5496
+// 0.336884
+0x2B1F
+// 0.328735
+0x2A14
+// -0.602986
+0xB2D1
+// 0.076045
+0x09BC
+// 0.299000
+0x2646
+// 0.020428
+0x029D
+// 0.179805
+0x1704
+// -0.386969
+0xCE78
+// -0.113119
+0xF185
+// -0.009004
+0xFED9
+// -0.839391
+0x948F
+// -0.136101
+0xEE94
+// 0.379279
+0x308C
+// 0.578833
+0x4A17
+// 0.264163
+0x21D0
+// -0.533847
+0xBBAB
+// -0.409433
+0xCB98
+// -0.334975
+0xD520
+// 0.151882
+0x1371
+// 0.132220
+0x10ED
+// 0.179417
+0x16F7
+// 0.188481
+0x1820
+// -0.506994
+0xBF1B
+// -0.471158
+0xC3B1
+// -0.150447
+0xECBE
+// 0.568105
+0x48B8
+// -0.206037
+0xE5A1
+// -0.336932
+0xD4DF
+// -0.128105
+0xEF9A
+// 0.608755
+0x4DEC
+// 0.216292
+0x1BAF
+// 0.327339
+0x29E6
+// -0.074259
+0xF67F
+// 0.192190
+0x189A
+// 0.550959
+0x4686
+// 0.034023
+0x045B
+// 0.384915
+0x3145
+// -0.415263
+0xCAD9
+// 0.513936
+0x41C9
+// -0.409222
+0xCB9F
+// -0.235739
+0xE1D3
+// -0.513779
+0xBE3C
+// -0.080366
+0xF5B7
+// -0.008089
+0xFEF7
+// 0.665939
+0x553E
+// 0.553521
+0x46DA
+// 0.118488
+0x0F2B
+// 0.452754
+0x39F4
+// -0.189352
+0xE7C3
+// 0.236447
+0x1E44
+// -0.029425
+0xFC3C
+// 0.532288
+0x4422
+// 0.158685
+0x1450
+// -0.207125
+0xE57D
+// 0.256558
+0x20D7
+// -0.279340
+0xDC3F
+// -0.175831
+0xE97E
+// -0.342134
+0xD435
+// 0.333585
+0x2AB3
+// 0.790520
+0x6530
+// 0.604685
+0x4D66
+// -0.433929
+0xC875
+// -0.211268
+0xE4F5
+// 0.536812
+0x44B6
+// 0.248849
+0x1FDA
+// 0.525246
+0x433B
+// 0.362304
+0x2E60
+// 0.472568
+0x3C7D
+// -0.393772
+0xCD99
+// 0.023451
+0x0300
+// -0.706359
+0xA596
+// 0.369775
+0x2F55
+// 0.527837
+0x4390
+// 0.187832
+0x180B
+// -0.163702
+0xEB0C
+// 0.743740
+0x5F33
+// 0.268361
+0x225A
+// 0.107554
+0x0DC4
+// -0.407995
+0xCBC7
+// -0.391583
+0xCDE1
+// -0.218611
+0xE405
+// 0.493020
+0x3F1B
+// -0.372303
+0xD058
+// -0.001229
+0xFFD8
+// -0.416385
+0xCAB4
+// -0.104454
+0xF2A1
+// -0.294703
+0xDA47
+// 0.000552
+0x0012
+// -0.163755
+0xEB0A
+// 0.036916
+0x04BA
+// 0.272303
+0x22DB
+// 0.185096
+0x17B1
+// -0.184122
+0xE86F
+// 0.556027
+0x472C
+// 0.713326
+0x5B4E
+// -0.076186
+0xF640
+// -0.159486
+0xEB96
+// -0.006846
+0xFF20
+// 0.048756
+0x063E
+// -0.445768
+0xC6F1
+// -0.025109
+0xFCC9
+// 0.557602
+0x4760
+// -0.089997
+0xF47B
+// 0.287693
+0x24D3
+// -0.156651
+0xEBF3
+// -0.229572
+0xE29D
+// -0.409576
+0xCB93
+// 0.232089
+0x1DB5
+// -0.857708
+0x9237
+// -0.508076
+0xBEF7
+// 0.457783
+0x3A99
+// -0.537929
+0xBB25
+// -0.078232
+0xF5FC
+// -0.102995
+0xF2D1
+// -0.363774
+0xD170
+// 0.340417
+0x2B93
+// -0.988812
+0x816F
+// -0.727331
+0xA2E7
+// 0.042403
+0x056D
+// 1.248493
+0x7FFF
+// -0.018439
+0xFDA4
+// 0.080956
+0x0A5D
+// -0.498395
+0xC035
+// -0.242706
+0xE0EF
+// 0.448147
+0x395D
+// 0.558205
+0x4773
+// -0.168927
+0xEA61
+// 0.365310
+0x2EC2
+// -0.399500
+0xCCDD
+// 0.567251
+0x489C
+// -0.113547
+0xF177
+// 0.566178
+0x4879
+// 0.675753
+0x567F
+// 0.082284
+0x0A88
+// -0.263793
+0xDE3C
+// -0.139256
+0xEE2D
+// -0.563582
+0xB7DD
+// -0.170762
+0xEA24
+// -0.145771
+0xED57
+// 0.224769
+0x1CC5
+// -0.822337
+0x96BE
+// -0.505253
+0xBF54
+// 0.150475
+0x1343
+// -0.852788
+0x92D8
+// -0.229226
+0xE2A9
+// -0.020920
+0xFD52
+// -0.717030
+0xA438
+// -0.420662
+0xCA28
+// 0.181715
+0x1742
+// 0.136679
+0x117F
+// -0.198719
+0xE690
+// 0.780927
+0x63F5
+// -0.316314
+0xD783
+// -0.337074
+0xD4DB
+// -0.449962
+0xC668
+// 0.365087
+0x2EBB
+// 0.515723
+0x4203
+// -0.255542
+0xDF4A
+// 0.464113
+0x3B68
+// -0.136815
+0xEE7D
+// 0.483973
+0x3DF3
+// -0.303115
+0xD934
+// 0.516164
+0x4212
+// -0.063928
+0xF7D1
+// -0.477272
+0xC2E9
+// 0.298325
+0x2630
+// 0.461789
+0x3B1C
+// -0.473654
+0xC35F
+// 0.434329
+0x3798
+// 0.181605
+0x173F
+// 0.032139
+0x041D
+// 0.140397
+0x11F9
+// -0.286762
+0xDB4B
+// 0.135101
+0x114B
+// 0.156372
+0x1404
+// 0.417922
+0x357E
+// -0.128029
+0xEF9D
+// -0.290168
+0xDADC
+// -0.230520
+0xE27E
+// 0.015709
+0x0203
+// 0.495071
+0x3F5E

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference5_q15.txt

@@ -1,514 +1,514 @@
 H
 256
-// 0.208628
-0x1AB4
-// 0.612738
-0x4E6E
-// 0.738117
-0x5E7B
-// 0.538878
-0x44FA
-// 0.794852
-0x65BE
-// 0.392353
-0x3239
-// 1.269109
+// 0.108961
+0x0DF2
+// 0.367506
+0x2F0A
+// 0.175661
+0x167C
+// 0.739965
+0x5EB7
+// 0.787413
+0x64CA
+// 0.192475
+0x18A3
+// 0.417557
+0x3573
+// 0.264083
+0x21CD
+// 0.949457
+0x7988
+// 0.086149
+0x0B07
+// 0.781545
+0x640A
+// 0.106398
+0x0D9E
+// 1.135543
 0x7FFF
-// 0.584075
-0x4AC3
-// 0.829781
-0x6A36
-// 0.820584
-0x6909
-// 0.719050
-0x5C0A
-// 0.690578
-0x5865
-// 0.665900
-0x553C
-// 0.781091
-0x63FB
-// -0.520124
-0xBD6D
-// 1.175056
+// 0.471801
+0x3C64
+// 0.252226
+0x2049
+// 0.073349
+0x0963
+// 0.594929
+0x4C27
+// 0.352452
+0x2D1D
+// 0.651437
+0x5362
+// 0.396838
+0x32CC
+// 1.500000
 0x7FFF
-// 0.216870
-0x1BC2
-// 1.273159
+// 0.372684
+0x2FB4
+// 0.723084
+0x5C8E
+// 0.302630
+0x26BD
+// 0.476421
+0x3CFB
+// 0.664779
+0x5517
+// 0.554862
+0x4706
+// 0.616807
+0x4EF4
+// 1.224476
 0x7FFF
-// -0.222326
-0xE38B
-// 0.177780
-0x16C1
-// 0.151026
-0x1355
-// 1.095221
+// 0.824554
+0x698B
+// 1.137242
 0x7FFF
-// 0.430346
-0x3716
-// 0.636401
-0x5176
-// 0.867788
-0x6F14
-// 0.224899
-0x1CC9
-// 1.152923
+// -0.494701
+0xC0AE
+// 0.346395
+0x2C57
+// 0.775814
+0x634E
+// 0.415505
+0x352F
+// -0.152355
+0xEC80
+// 0.134914
+0x1145
+// 0.158695
+0x1450
+// 1.109822
 0x7FFF
-// 0.327564
-0x29EE
-// 0.614230
-0x4E9F
-// 0.703455
-0x5A0B
-// 0.618325
-0x4F25
-// 0.799473
-0x6655
-// 0.403719
-0x33AD
-// 1.353706
+// 0.761556
+0x617B
+// 0.459824
+0x3ADC
+// 0.513211
+0x41B1
+// -0.130985
+0xEF3C
+// 0.757101
+0x60E9
+// 0.763646
+0x61BF
+// -0.207048
+0xE57F
+// 0.507630
+0x40FA
+// 0.872092
+0x6FA1
+// 0.700446
+0x59A8
+// -0.191038
+0xE78C
+// 0.520442
+0x429E
+// 1.241753
 0x7FFF
-// -0.517484
-0xBDC3
-// 0.630138
-0x50A8
-// 0.745529
-0x5F6D
-// 0.648787
-0x530B
-// 1.044863
+// 0.229033
+0x1D51
+// 0.649906
+0x5330
+// 0.655500
+0x53E7
+// 0.569104
+0x48D8
+// 0.546970
+0x4603
+// 0.550831
+0x4682
+// -0.023837
+0xFCF3
+// 0.046761
+0x05FC
+// 0.391689
+0x3223
+// 0.228555
+0x1D41
+// 0.303418
+0x26D6
+// 0.817899
+0x68B1
+// 0.796574
+0x65F6
+// -0.273282
+0xDD05
+// 0.598481
+0x4C9B
+// 1.077823
 0x7FFF
-// 0.612934
-0x4E75
-// 1.446172
+// 0.260763
+0x2161
+// 0.388396
+0x31B7
+// 0.850488
+0x6CDD
+// -0.474917
+0xC336
+// 0.025863
+0x034F
+// 0.733892
+0x5DF0
+// -0.160819
+0xEB6A
+// 0.163116
+0x14E1
+// 0.171265
+0x15EC
+// 1.102986
 0x7FFF
-// 0.367007
-0x2EFA
-// 0.565405
-0x485F
-// 0.313358
-0x281C
-// -0.256814
-0xDF21
-// 0.605861
-0x4D8D
-// 0.062597
-0x0803
-// 0.418373
-0x358D
-// 0.493662
-0x3F30
-// 0.768326
-0x6259
-// 0.407779
-0x3432
-// 0.606395
-0x4D9E
-// 0.581742
-0x4A77
-// 0.465106
-0x3B89
-// -0.272030
-0xDD2E
-// 0.695714
-0x590D
-// 0.613011
-0x4E77
-// 0.820860
-0x6912
-// 0.459138
-0x3AC5
-// 0.727119
-0x5D12
-// 0.816674
-0x6889
-// 0.597933
-0x4C89
-// 0.699199
-0x597F
-// 0.420742
-0x35DB
-// -0.126025
-0xEFDE
-// -0.255253
-0xDF54
-// 0.139923
-0x11E9
-// -0.034840
-0xFB8A
-// 0.373912
-0x2FDC
-// 0.665333
-0x552A
-// 0.342178
-0x2BCC
-// 0.926616
-0x769B
-// 0.442156
-0x3899
-// 0.740266
-0x5EC1
-// 0.061841
-0x07EA
-// 0.126416
-0x102E
-// 0.097877
-0x0C87
-// 0.860179
-0x6E1A
-// 1.005158
+// 0.423955
+0x3644
+// 0.201000
+0x19BA
+// 0.479572
+0x3D63
+// 0.320195
+0x28FC
+// 0.886969
+0x7188
+// 0.613119
+0x4E7B
+// 0.509004
+0x4127
+// 1.339391
 0x7FFF
-// 0.404169
-0x33BC
-// 0.453061
-0x39FE
-// -0.246193
-0xE07D
-// 0.542432
-0x456E
-// -0.268082
-0xDDAF
-// 0.281649
-0x240D
-// 0.228051
-0x1D31
-// 1.189579
+// 0.636101
+0x516C
+// 0.120721
+0x0F74
+// -0.078833
+0xF5E9
+// 0.235837
+0x1E30
+// 1.033847
 0x7FFF
-// 0.175790
-0x1680
-// -0.438547
-0xC7DE
-// 0.917882
-0x757D
-// 0.320318
-0x2900
-// 0.424604
-0x3659
-// 0.911513
-0x74AC
-// 0.579135
-0x4A21
-// 0.350757
-0x2CE6
-// 0.911160
-0x74A1
-// 0.631389
-0x50D1
-// 0.462540
-0x3B35
-// 0.431020
-0x372C
-// 0.282118
-0x241C
-// 0.861686
-0x6E4C
-// 0.103196
-0x0D36
-// 1.500000
+// 0.909433
+0x7468
+// 0.834975
+0x6AE0
+// 0.348118
+0x2C8F
+// 0.367780
+0x2F13
+// 0.320583
+0x2909
+// 0.311519
+0x27E0
+// 1.006994
 0x7FFF
-// 1.361870
+// 0.971158
+0x7C4F
+// 0.650447
+0x5342
+// -0.068105
+0xF748
+// 0.706037
+0x5A5F
+// 0.836932
+0x6B21
+// 0.628105
+0x5066
+// -0.108755
+0xF214
+// 0.283708
+0x2451
+// 0.172661
+0x161A
+// 0.574259
+0x4981
+// 0.307810
+0x2766
+// -0.050959
+0xF97A
+// 0.465977
+0x3BA5
+// 0.115085
+0x0EBB
+// 0.915263
+0x7527
+// -0.013936
+0xFE37
+// 0.909222
+0x7461
+// 0.735739
+0x5E2D
+// 1.013779
 0x7FFF
-// 0.007629
-0x00FA
-// 0.975058
-0x7CCF
-// 0.826745
-0x69D3
-// 0.477578
-0x3D21
-// -0.223679
-0xE35E
-// 0.698195
-0x595E
-// 0.284639
-0x246F
-// 0.120882
-0x0F79
-// 0.618425
-0x4F29
-// 0.716039
-0x5BA7
-// 0.283216
-0x2440
-// -0.158123
-0xEBC3
-// -0.422551
-0xC9EA
-// 0.328921
-0x2A1A
-// 1.471339
+// 0.580366
+0x4A49
+// 0.508089
+0x4109
+// -0.165939
+0xEAC2
+// -0.053521
+0xF926
+// 0.381512
+0x30D5
+// 0.047246
+0x060C
+// 0.689352
+0x583D
+// 0.263553
+0x21BC
+// 0.529425
+0x43C4
+// -0.032288
+0xFBDE
+// 0.341315
+0x2BB0
+// 0.707125
+0x5A83
+// 0.243442
+0x1F29
+// 0.779340
+0x63C1
+// 0.675831
+0x5682
+// 0.842134
+0x6BCB
+// 0.166415
+0x154D
+// -0.290520
+0xDAD0
+// -0.104685
+0xF29A
+// 0.933929
+0x778B
+// 0.711268
+0x5B0B
+// -0.036812
+0xFB4A
+// 0.251151
+0x2026
+// -0.025246
+0xFCC5
+// 0.137696
+0x11A0
+// 0.027432
+0x0383
+// 0.893772
+0x7267
+// 0.476549
+0x3D00
+// 1.206359
 0x7FFF
-// 0.495410
-0x3F6A
-// 0.375604
-0x3014
-// 0.456737
-0x3A76
-// 0.356529
-0x2DA3
-// 0.170750
-0x15DB
-// -0.186717
-0xE81A
-// 0.471572
-0x3C5C
-// -0.181094
-0xE8D2
-// 0.989830
-0x7EB3
-// 0.759075
-0x6129
-// 0.147706
-0x12E8
-// 0.629524
-0x5094
-// 0.302873
-0x26C5
-// 0.769581
-0x6282
-// -0.043085
-0xFA7C
-// 0.296484
-0x25F3
-// 0.792197
-0x6567
-// 0.136777
-0x1182
-// 0.252518
-0x2052
-// 0.162196
-0x14C3
-// 1.153685
+// 0.130225
+0x10AB
+// -0.027837
+0xFC70
+// 0.312168
+0x27F5
+// 0.663702
+0x54F4
+// -0.243740
+0xE0CD
+// 0.231639
+0x1DA6
+// 0.392446
+0x323C
+// 0.907995
+0x7439
+// 0.891583
+0x721F
+// 0.718611
+0x5BFB
+// 0.006980
+0x00E5
+// 0.872303
+0x6FA8
+// 0.501229
+0x4028
+// 0.916385
+0x754C
+// 0.604454
+0x4D5F
+// 0.794703
+0x65B9
+// 0.499448
+0x3FEE
+// 0.663755
+0x54F6
+// 0.463084
+0x3B46
+// 0.227697
+0x1D25
+// 0.314904
+0x284F
+// 0.684122
+0x5791
+// -0.056027
+0xF8D4
+// -0.213326
+0xE4B2
+// 0.576186
+0x49C0
+// 0.659486
+0x546A
+// 0.506846
+0x40E0
+// 0.451244
+0x39C2
+// 0.945768
+0x790F
+// 0.525109
+0x4337
+// -0.057602
+0xF8A0
+// 0.589997
+0x4B85
+// 0.212307
+0x1B2D
+// 0.656651
+0x540D
+// 0.729572
+0x5D63
+// 0.909576
+0x746D
+// 0.267911
+0x224B
+// 1.357708
 0x7FFF
-// 0.813478
-0x6820
-// 0.274767
-0x232C
-// 0.444080
-0x38D8
-// 0.215001
-0x1B85
-// 0.483449
-0x3DE2
-// 0.851903
-0x6D0B
-// 0.010420
-0x0155
-// 0.425161
-0x366C
-// 0.052731
-0x06C0
-// 0.474728
-0x3CC4
-// 0.082352
-0x0A8B
-// 0.755674
-0x60BA
-// 0.243754
-0x1F33
-// 0.109800
-0x0E0E
-// 0.180169
-0x1710
-// 0.527698
-0x438C
-// 0.733688
-0x5DEA
-// 1.393321
+// 1.008076
 0x7FFF
-// 0.203970
-0x1A1C
-// 0.686033
-0x57D0
-// 0.208377
-0x1AAC
-// 0.027472
-0x0384
-// 0.119609
-0x0F4F
-// 0.799344
-0x6651
-// 0.456935
-0x3A7D
-// 0.285347
-0x2486
-// 0.984534
-0x7E05
-// -0.218725
-0xE401
-// 0.571545
-0x4928
-// 0.432091
-0x374F
-// 0.903341
-0x73A1
-// 0.071463
-0x0926
-// 0.807753
-0x6764
-// 0.212718
-0x1B3A
-// 0.317953
-0x28B3
-// -0.060512
-0xF841
-// 0.647036
-0x52D2
-// 1.043678
+// 0.042217
+0x0567
+// 1.037929
 0x7FFF
-// 1.226262
+// 0.578232
+0x4A04
+// 0.602995
+0x4D2F
+// 0.863774
+0x6E90
+// 0.159583
+0x146D
+// 1.488812
 0x7FFF
-// 0.376245
-0x3029
-// 0.263436
-0x21B8
-// 1.211449
+// 1.227331
 0x7FFF
-// 0.586785
-0x4B1C
-// 0.055029
-0x070B
-// 0.275867
-0x2350
-// 0.478284
-0x3D38
-// 0.943658
-0x78CA
-// 0.249916
-0x1FFD
-// 0.135578
-0x115B
-// 0.704438
-0x5A2B
-// 0.988969
-0x7E97
-// -0.122727
-0xF04A
-// -0.096908
-0xF399
-// -0.329206
-0xD5DD
-// 0.784500
-0x646A
-// 0.448481
-0x3968
-// 0.203971
-0x1A1C
-// 0.223018
-0x1C8C
-// -0.035533
-0xFB74
-// 0.101507
-0x0CFE
-// 0.546804
-0x45FE
-// 0.416670
-0x3555
-// 0.458099
-0x3AA3
-// 0.571995
-0x4937
-// 0.378925
-0x3081
-// 1.199388
+// 0.457597
+0x3A93
+// -0.748493
+0xA031
+// 0.518439
+0x425C
+// 0.419044
+0x35A3
+// 0.998395
+0x7FCB
+// 0.742706
+0x5F11
+// 0.051853
+0x06A3
+// -0.058205
+0xF88D
+// 0.668927
+0x559F
+// 0.134690
+0x113E
+// 0.899500
+0x7323
+// -0.067251
+0xF764
+// 0.613547
+0x4E89
+// -0.066178
+0xF787
+// -0.175753
+0xE981
+// 0.417716
+0x3578
+// 0.763793
+0x61C4
+// 0.639256
+0x51D3
+// 1.063582
 0x7FFF
-// 0.015652
-0x0201
-// 0.527504
-0x4385
-// 0.011116
-0x016C
-// 0.838561
-0x6B56
-// 0.817218
-0x689B
-// 1.033173
+// 0.670762
+0x55DC
+// 0.645771
+0x52A9
+// 0.275231
+0x233B
+// 1.322337
 0x7FFF
-// 0.338821
-0x2B5E
-// 0.610650
-0x4E2A
-// -0.076178
-0xF640
-// 0.073349
-0x0964
-// 0.349545
-0x2CBE
-// 0.166234
-0x1547
-// 0.862308
-0x6E60
-// 1.090622
+// 1.005253
 0x7FFF
-// -0.194183
-0xE725
-// 0.745185
-0x5F62
-// 0.514160
-0x41D0
-// 0.659924
-0x5478
-// 0.807676
-0x6762
-// 0.138705
-0x11C1
-// 0.072249
-0x093F
-// 0.799083
-0x6648
-// 0.819458
-0x68E4
-// 0.450515
-0x39AA
-// 1.098299
+// 0.349525
+0x2CBD
+// 1.352788
 0x7FFF
-// 0.035554
-0x048D
-// 0.320372
-0x2902
-// 0.704011
-0x5A1D
-// 1.015296
+// 0.729226
+0x5D57
+// 0.520920
+0x42AE
+// 1.217030
 0x7FFF
-// 0.429032
-0x36EB
-// 0.663492
-0x54ED
-// 0.641388
-0x5219
-// 0.542870
-0x457D
-// -0.001338
-0xFFD4
-// 0.997520
-0x7FAF
-// 0.903774
-0x73AF
-// -0.020140
-0xFD6C
-// 0.429534
-0x36FB
-// 0.141866
-0x1229
-// 0.784262
-0x6463
-// -0.497219
-0xC05B
-// -0.336779
-0xD4E4
-// 0.508837
-0x4122
-// 0.288138
-0x24E2
-// 0.590126
-0x4B89
-// 0.552889
-0x46C5
-// 0.657819
-0x5433
-// 0.573654
-0x496E
-// 0.516595
-0x4220
-// 0.740174
-0x5EBE
+// 0.920662
+0x75D8
+// 0.318285
+0x28BE
+// 0.363321
+0x2E81
+// 0.698719
+0x5970
+// -0.280927
+0xDC0B
+// 0.816314
+0x687D
+// 0.837074
+0x6B25
+// 0.949962
+0x7998
+// 0.134913
+0x1145
+// -0.015723
+0xFDFD
+// 0.755542
+0x60B6
+// 0.035887
+0x0498
+// 0.636815
+0x5183
+// 0.016027
+0x020D
+// 0.803115
+0x66CC
+// -0.016164
+0xFDEE
+// 0.563928
+0x482F
+// 0.977272
+0x7D17
+// 0.201675
+0x19D0
+// 0.038211
+0x04E4
+// 0.973654
+0x7CA1
+// 0.065671
+0x0868
+// 0.318395
+0x28C1
+// 0.467861
+0x3BE3
+// 0.359603
+0x2E07
+// 0.786762
+0x64B5
+// 0.364899
+0x2EB5
+// 0.343628
+0x2BFC
+// 0.082078
+0x0A82
+// 0.628029
+0x5063
+// 0.790168
+0x6524
+// 0.730520
+0x5D82
+// 0.484291
+0x3DFD
+// 0.004929
+0x00A2

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference6_q15.txt

@@ -1,514 +1,514 @@
 H
 256
-// -0.145686
-0xED5A
-// 0.056369
-0x0737
-// 0.119059
-0x0F3D
-// 0.019439
-0x027D
-// 0.147426
-0x12DF
-// -0.053823
-0xF91C
-// 0.384554
-0x3139
-// 0.042038
-0x0561
-// 0.164890
-0x151B
-// 0.160292
-0x1484
-// 0.109525
-0x0E05
-// 0.095289
-0x0C32
-// 0.082950
-0x0A9E
-// 0.140546
-0x11FD
-// -0.510062
-0xBEB6
-// 0.337528
-0x2B34
-// -0.141565
-0xEDE1
-// 0.386580
-0x317B
-// -0.361163
-0xD1C5
-// -0.161110
-0xEB61
-// -0.174487
-0xE9AA
-// 0.297611
-0x2618
-// -0.034827
-0xFB8B
-// 0.068200
-0x08BB
-// 0.183894
-0x178A
-// -0.137550
-0xEE65
-// 0.326462
-0x29C9
-// -0.086218
-0xF4F7
-// 0.057115
-0x0750
-// 0.101728
-0x0D05
-// 0.059163
-0x0793
-// 0.149737
-0x132B
-// -0.048141
-0xF9D7
-// 0.426853
-0x36A3
-// -0.508742
-0xBEE2
-// 0.065069
-0x0854
-// 0.122764
-0x0FB7
-// 0.074393
-0x0986
-// 0.272431
-0x22DF
-// 0.056467
-0x073A
-// 0.473086
-0x3C8E
-// -0.066496
-0xF77D
-// 0.032703
-0x0430
-// -0.093321
-0xF40E
-// -0.378407
-0xCF90
-// 0.052930
-0x06C6
-// -0.218702
-0xE402
-// -0.040814
-0xFAC7
-// -0.003169
-0xFF98
-// 0.134163
-0x112C
-// -0.046111
-0xFA19
-// 0.053197
-0x06CF
-// 0.040871
-0x053B
-// -0.017447
-0xFDC4
-// -0.386015
-0xCE97
-// 0.097857
-0x0C87
-// 0.056505
-0x073C
-// 0.160430
-0x1489
-// -0.020431
-0xFD63
-// 0.113560
-0x0E89
-// 0.158337
-0x1444
-// 0.048966
-0x0645
-// 0.099599
-0x0CC0
-// -0.039629
-0xFAED
-// -0.313013
-0xD7EF
-// -0.377627
-0xCFAA
-// -0.180039
-0xE8F4
-// -0.267420
-0xDDC5
-// -0.063044
-0xF7EE
-// 0.082666
-0x0A95
-// -0.078911
-0xF5E6
-// 0.213308
-0x1B4E
-// -0.028922
-0xFC4C
-// 0.120133
-0x0F61
-// -0.219080
-0xE3F5
-// -0.186792
-0xE817
-// -0.201062
-0xE644
-// 0.180090
-0x170D
-// 0.252579
-0x2055
-// -0.047915
-0xF9DE
-// -0.023470
-0xFCFF
-// -0.373097
-0xD03E
-// 0.021216
-0x02B7
-// -0.384041
-0xCED8
-// -0.109175
-0xF207
-// -0.135974
-0xEE98
-// 0.344789
-0x2C22
-// -0.162105
-0xEB40
-// -0.469274
-0xC3EF
-// 0.208941
-0x1ABF
-// -0.089841
-0xF480
-// -0.037698
-0xFB2D
-// 0.205757
-0x1A56
-// 0.039567
-0x0511
-// -0.074622
-0xF673
-// 0.205580
-0x1A50
-// 0.065695
-0x0869
-// -0.018730
-0xFD9A
-// -0.034490
-0xFB96
-// -0.108941
-0xF20E
-// 0.180843
-0x1726
-// -0.198402
-0xE69B
+// -0.195519
+0xE6F9
+// -0.066247
+0xF785
+// -0.162169
+0xEB3E
+// 0.119982
+0x0F5C
+// 0.143706
+0x1265
+// -0.153762
+0xEC52
+// -0.041222
+0xFAB9
+// -0.117959
+0xF0E7
+// 0.224728
+0x1CC4
+// -0.206925
+0xE583
+// 0.140773
+0x1205
+// -0.196801
+0xE6CF
+// 0.317771
+0x28AD
+// -0.014099
+0xFE32
+// -0.123887
+0xF024
+// -0.213326
+0xE4B2
+// 0.047465
+0x0613
+// -0.073774
+0xF68F
+// 0.075718
+0x09B1
+// -0.051581
+0xF966
 // 0.500000
 0x4000
-// 0.430935
-0x3729
-// -0.246186
-0xE07D
-// 0.237529
-0x1E67
-// 0.163373
-0x14E9
-// -0.011211
-0xFE91
-// -0.361839
-0xD1AF
-// 0.099098
-0x0CAF
-// -0.107680
-0xF238
-// -0.189559
-0xE7BD
-// 0.059213
-0x0794
-// 0.108019
-0x0DD4
-// -0.108392
-0xF220
-// -0.329061
-0xD5E1
-// -0.461275
-0xC4F5
-// -0.085540
-0xF50D
-// 0.485669
-0x3E2A
-// -0.002295
-0xFFB5
-// -0.062198
-0xF80A
-// -0.021631
-0xFD3B
-// -0.071735
-0xF6D1
-// -0.164625
-0xEAEE
-// -0.343359
-0xD40D
-// -0.014214
-0xFE2E
-// -0.340547
-0xD469
-// 0.244915
-0x1F59
-// 0.129538
-0x1095
-// -0.176147
-0xE974
-// 0.064762
-0x084A
-// -0.098563
-0xF362
-// 0.134791
-0x1141
-// -0.271542
-0xDD3E
-// -0.101758
-0xF2FA
-// 0.146098
-0x12B3
-// -0.181611
-0xE8C1
-// -0.123741
-0xF029
-// -0.168902
-0xEA61
-// 0.326842
-0x29D6
-// 0.156739
-0x1410
-// -0.112616
-0xF196
-// -0.027960
-0xFC6C
-// -0.142499
-0xEDC3
-// -0.008276
-0xFEF1
-// 0.175951
-0x1686
-// -0.244790
-0xE0AB
-// -0.037420
-0xFB36
-// -0.223634
-0xE360
-// -0.012636
-0xFE62
-// -0.208824
-0xE545
-// 0.127837
-0x105D
-// -0.128123
-0xEF9A
-// -0.195100
-0xE707
-// -0.159915
-0xEB88
-// 0.013849
-0x01C6
-// 0.116844
-0x0EF5
-// 0.446661
-0x392C
-// -0.148015
-0xED0E
-// 0.093016
-0x0BE8
-// -0.145812
-0xED56
-// -0.236264
-0xE1C2
-// -0.190196
-0xE7A8
-// 0.149672
-0x1328
-// -0.021533
-0xFD3E
-// -0.107327
-0xF243
-// 0.242267
-0x1F03
-// -0.359362
-0xD200
-// 0.035773
-0x0494
-// -0.033955
-0xFBA7
-// 0.201670
-0x19D0
-// -0.214268
-0xE493
-// 0.153877
-0x13B2
-// -0.143641
-0xED9D
-// -0.091023
-0xF459
-// -0.280256
-0xDC21
-// 0.073518
-0x0969
-// 0.271839
-0x22CC
-// 0.363131
-0x2E7B
-// -0.061877
-0xF814
-// -0.118282
-0xF0DC
-// 0.355725
-0x2D88
-// 0.043393
-0x058E
-// -0.222485
-0xE386
-// -0.112066
-0xF1A8
-// -0.010858
-0xFE9C
-// 0.221829
-0x1C65
-// -0.125042
-0xEFFF
-// -0.182211
-0xE8AD
-// 0.102219
-0x0D16
-// 0.244484
-0x1F4B
-// -0.311363
-0xD825
-// -0.298454
-0xD9CC
-// -0.414603
-0xCAEE
-// 0.142250
-0x1235
-// -0.025759
-0xFCB4
-// -0.148015
-0xED0E
-// -0.138491
-0xEE46
-// -0.267767
-0xDDBA
-// -0.199247
-0xE67F
-// 0.023402
-0x02FF
-// -0.041665
-0xFAAB
-// -0.020950
-0xFD51
-// 0.035998
-0x049C
-// -0.060537
-0xF840
-// 0.349694
-0x2CC3
-// -0.242174
-0xE100
-// 0.013752
-0x01C3
-// -0.244442
-0xE0B6
-// 0.169281
-0x15AB
-// 0.158609
-0x144D
-// 0.266587
-0x2220
-// -0.080589
-0xF5AF
-// 0.055325
-0x0715
-// -0.288089
-0xDB20
-// -0.213325
-0xE4B2
-// -0.075228
+// -0.063658
+0xF7DA
+// 0.111542
+0x0E47
+// -0.098685
+0xF35E
+// -0.011790
+0xFE7E
+// 0.082390
+0x0A8C
+// 0.027431
+0x0383
+// 0.058403
+0x077A
+// 0.362238
+0x2E5E
+// 0.162277
+0x14C5
+// 0.318621
+0x28C9
+// -0.497351
+0xC057
+// -0.076803
+0xF62B
+// 0.137907
+0x11A7
+// -0.042247
+0xFA98
+// -0.326177
+0xD640
+// -0.182543
+0xE8A2
+// -0.170653
+0xEA28
+// 0.304911
+0x2707
+// 0.130778
+0x10BD
+// -0.020088
+0xFD6E
+// 0.006606
+0x00D8
+// -0.315493
+0xD79E
+// 0.128551
+0x1074
+// 0.131823
+0x10E0
+// -0.353524
+0xD2C0
+// 0.003815
+0x007D
+// 0.186046
+0x17D0
+// 0.100223
+0x0CD4
+// -0.345519
+0xD3C6
+// 0.010221
+0x014F
+// 0.370876
+0x2F79
+// -0.135483
+0xEEA8
+// 0.074953
+0x0998
+// 0.077750
+0x09F4
+// 0.034552
+0x046C
+// 0.023485
+0x0302
+// 0.025416
+0x0341
+// -0.261918
+0xDE79
+// -0.226619
+0xE2FE
+// -0.054156
+0xF911
+// -0.135722
+0xEEA1
+// -0.098291
+0xF36B
+// 0.158949
+0x1458
+// 0.148287
+0x12FB
+// -0.386641
+0xCE83
+// 0.049241
+0x064E
+// 0.288912
+0x24FB
+// -0.119619
+0xF0B0
+// -0.055802
+0xF8DB
+// 0.175244
+0x166E
+// -0.487458
+0xC19B
+// -0.237068
+0xE1A8
+// 0.116946
+0x0EF8
+// -0.330410
+0xD5B5
+// -0.168442
+0xEA70
+// -0.164368
+0xEAF6
+// 0.301493
+0x2697
+// -0.038023
+0xFB22
+// -0.149500
+0xECDD
+// -0.010214
+0xFEB1
+// -0.089903
+0xF47E
+// 0.193485
+0x18C4
+// 0.056560
+0x073D
+// 0.004502
+0x0094
+// 0.419695
+0x35B9
+// 0.068050
+0x08B6
+// -0.189639
+0xE7BA
+// -0.289416
+0xDAF4
+// -0.132081
+0xEF18
+// 0.266923
+0x222B
+// 0.204717
+0x1A34
+// 0.167488
+0x1570
+// -0.075941
+0xF648
+// -0.066110
+0xF78A
+// -0.089708
+0xF484
+// -0.094240
+0xF3F0
+// 0.253497
+0x2073
+// 0.235579
+0x1E27
+// 0.075223
+0x09A1
+// -0.284052
+0xDBA4
+// 0.103018
+0x0D30
+// 0.168466
+0x1590
+// 0.064052
+0x0833
+// -0.304377
+0xD90A
+// -0.108146
+0xF228
+// -0.163670
+0xEB0D
+// 0.037130
+0x04C1
+// -0.096095
+0xF3B3
+// -0.275479
+0xDCBD
+// -0.017011
+0xFDD3
+// -0.192457
+0xE75E
+// 0.207631
+0x1A94
+// -0.256968
+0xDF1C
+// 0.204611
+0x1A31
+// 0.117870
+0x0F16
+// 0.256890
+0x20E2
+// 0.040183
+0x0525
+// 0.004045
+0x0085
+// -0.332970
+0xD561
+// -0.276761
+0xDC93
+// -0.059244
+0xF86B
+// -0.226377
+0xE306
+// 0.094676
+0x0C1E
+// -0.118223
+0xF0DE
+// 0.014713
+0x01E2
+// -0.266144
+0xDDEF
+// -0.079343
+0xF5D8
+// 0.103563
+0x0D42
+// -0.128279
+0xEF95
+// 0.139670
+0x11E1
+// 0.087916
+0x0B41
+// 0.171067
+0x15E6
+// -0.166793
+0xEAA7
+// -0.395260
+0xCD68
+// -0.302342
+0xD94D
+// 0.216965
+0x1BC5
+// 0.105634
+0x0D85
+// -0.268406
+0xDDA5
+// -0.124424
+0xF013
+// -0.262623
+0xDE62
+// -0.181152
+0xE8D0
+// -0.236284
+0xE1C1
+// 0.196886
+0x1934
+// -0.011725
+0xFE80
+// 0.353180
+0x2D35
+// -0.184887
+0xE856
+// -0.263919
+0xDE38
+// -0.093916
+0xF3FB
+// 0.081851
+0x0A7A
+// -0.371870
+0xD067
+// -0.134180
+0xEED3
+// -0.053777
+0xF91E
+// 0.203998
+0x1A1D
+// 0.195792
+0x1910
+// 0.109305
+0x0DFE
+// -0.246510
+0xE072
+// 0.186152
+0x17D4
+// 0.000615
+0x0014
+// 0.208193
+0x1AA6
+// 0.052227
+0x06AF
+// 0.147351
+0x12DC
+// -0.000276
+0xFFF7
+// 0.081878
+0x0A7B
+// -0.018458
+0xFDA3
+// -0.136152
+0xEE93
+// -0.092548
+0xF427
+// 0.092061
+0x0BC9
+// -0.278014
+0xDC6A
+// -0.356663
+0xD259
+// 0.038093
+0x04E0
+// 0.079743
+0x0A35
+// 0.003423
+0x0070
+// -0.024378
+0xFCE1
+// 0.222884
+0x1C87
+// 0.012555
+0x019B
+// -0.278801
+0xDC50
+// 0.044998
+0x05C3
+// -0.143847
+0xED96
+// 0.078325
+0x0A07
+// 0.114786
+0x0EB1
+// 0.204788
+0x1A36
+// -0.116045
+0xF125
+// 0.428854
+0x36E5
+// 0.254038
+0x2084
+// -0.228891
+0xE2B4
+// 0.268964
+0x226D
+// 0.039116
+0x0502
+// 0.051497
+0x0697
+// 0.181887
+0x1748
+// -0.170208
+0xEA37
+// 0.494406
+0x3F49
+// 0.363665
+0x2E8D
+// -0.021202
+0xFD49
+// -0.624247
+0xB019
+// 0.009220
+0x012E
+// -0.040478
+0xFAD2
+// 0.249197
+0x1FE6
+// 0.121353
+0x0F88
+// -0.224074
+0xE352
+// -0.279103
+0xDC46
+// 0.084464
+0x0AD0
+// -0.182655
+0xE89F
+// 0.199750
+0x1991
+// -0.283626
+0xDBB2
+// 0.056774
+0x0744
+// -0.283089
+0xDBC4
+// -0.337876
+0xD4C0
+// -0.041142
+0xFABC
+// 0.131896
+0x10E2
+// 0.069628
+0x08EA
+// 0.281791
+0x2412
+// 0.085381
+0x0AEE
+// 0.072885
+0x0954
+// -0.112385
+0xF19D
+// 0.411169
+0x34A1
+// 0.252627
+0x2056
+// -0.075238
 0xF65F
-// -0.166883
-0xEAA4
-// 0.181154
-0x1730
-// 0.295311
-0x25CD
-// -0.347092
-0xD393
-// 0.122592
-0x0FB1
-// 0.007080
-0x00E8
-// 0.079962
-0x0A3C
-// 0.153838
-0x13B1
-// -0.180648
-0xE8E1
-// -0.213876
-0xE4A0
-// 0.149542
-0x1324
-// 0.159729
-0x1472
-// -0.024742
-0xFCD5
-// 0.299150
-0x264B
-// -0.232223
-0xE247
-// -0.089814
-0xF481
-// 0.102005
-0x0D0F
-// 0.257648
-0x20FB
-// -0.035484
-0xFB75
-// 0.081746
-0x0A77
-// 0.070694
-0x090C
-// 0.021435
-0x02BE
-// -0.250669
-0xDFEA
-// 0.248760
-0x1FD7
-// 0.201887
-0x19D7
-// -0.260070
-0xDEB6
-// -0.035233
-0xFB7D
-// -0.179067
-0xE914
-// 0.142131
-0x1231
-// -0.498609
-0xC02E
-// -0.418390
-0xCA72
-// 0.004418
-0x0091
-// -0.105931
-0xF271
-// 0.045063
-0x05C5
-// 0.026444
-0x0363
-// 0.078910
-0x0A1A
-// 0.036827
-0x04B7
-// 0.008298
-0x0110
-// 0.120087
-0x0F5F
+// 0.426394
+0x3694
+// 0.114613
+0x0EAC
+// 0.010460
+0x0157
+// 0.358515
+0x2DE4
+// 0.210331
+0x1AEC
+// -0.090857
+0xF45F
+// -0.068339
+0xF741
+// 0.099360
+0x0CB8
+// -0.390463
+0xCE05
+// 0.158157
+0x143E
+// 0.168537
+0x1593
+// 0.224981
+0x1CCC
+// -0.182544
+0xE8A2
+// -0.257862
+0xDEFE
+// 0.127771
+0x105B
+// -0.232057
+0xE24C
+// 0.068407
+0x08C2
+// -0.241987
+0xE107
+// 0.151558
+0x1366
+// -0.258082
+0xDEF7
+// 0.031964
+0x0417
+// 0.238636
+0x1E8C
+// -0.149162
+0xECE8
+// -0.230895
+0xE272
+// 0.236827
+0x1E50
+// -0.217165
+0xE434
+// -0.090803
+0xF461
+// -0.016069
+0xFDF1
+// -0.070199
+0xF704
+// 0.143381
+0x125A
+// -0.067550
+0xF75B
+// -0.078186
+0xF5FE
+// -0.208961
+0xE541
+// 0.064014
+0x0832
+// 0.145084
+0x1292
+// 0.115260
+0x0EC1
+// -0.007855
+0xFEFF
+// -0.247535
+0xE051

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference7_q15.txt

@@ -1,4 +1,4 @@
 H
 1
-// 0.049476
-0x0655
+// 0.000003
+0x0000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference7_q63.txt

@@ -0,0 +1,4 @@
+D
+1
+// 0.000003
+0x0000172BEFBB2F71

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference8_q15.txt

@@ -1,4 +1,4 @@
 H
 1
-// 0.273481
-0x2301
+// 0.000008
+0x0000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference8_q63.txt

@@ -0,0 +1,4 @@
+D
+1
+// 0.000006
+0x00003027A897E616

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference9_q15.txt

@@ -1,4 +1,4 @@
 H
 1
-// 0.308351
-0x2778
+// 0.000016
+0x0001

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Reference9_q63.txt

@@ -0,0 +1,4 @@
+D
+1
+// 0.000008
+0x00004122B89F72C9

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Shift21_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// -0.254051
+0xDF7B
+// 0.271125
+0x22B4
+// -0.111913
+0xF1AD
+// 0.010024
+0x0148
+// 0.099078
+0x0CAF
+// 0.286423
+0x24AA
+// 0.082909
+0x0A9D
+// -0.109049
+0xF20B
+// 0.032135
+0x041D
+// -0.240805
+0xE12D
+// 0.195877
+0x1913
+// -0.221380
+0xE3AA
+// 0.666667
+0x5555
+// 0.009299
+0x0131
+// 0.180140
+0x170F
+// 0.055180
+0x0710
+// 0.117224
+0x0F01

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Shift22_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF
+// 0.000061
+0x0002
+// 1.999878
+0x7FFF

Testing/Patterns/DSP/BasicMaths/BasicMathsQ15/Shift23_q15.txt

@@ -0,0 +1,36 @@
+H
+17
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000
+// -0.000061
+0xFFFE
+// -1.999939
+0x8000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ31/Input12_q31.txt

@@ -0,0 +1,20 @@
+W
+9
+// -0.085318
+0xF5144ACE
+// -0.193783
+0xE7321E29
+// -0.014971
+0xFE156F8A
+// 0.209494
+0x1AD0AF9C
+// -0.112886
+0xF18CF0A8
+// 0.333333
+0x2AAAAAAB
+// 0.221288
+0x1C5327BE
+// 0.021019
+0x02B0BCF5
+// 0.158600
+0x144D0407

Testing/Patterns/DSP/BasicMaths/BasicMathsQ31/Input1_q31.txt

@@ -1,514 +1,514 @@
 W
 256
-// 0.537986
-0x44DCBC0F
-// 0.522285
-0x42DA393B
-// -0.120472
-0xF09460FB
-// 0.093682
-0x0BFDC812
-// -0.319905
-0xD70D5D57
-// 0.076607
-0x09CE4302
-// -0.066468
-0xF77DF6C8
-// 0.088545
-0x0B556F1B
-// 0.496399
-0x3F89FDA1
-// 0.822862
-0x69538AB2
-// -0.020135
-0xFD6C3919
-// -0.360547
-0xD1D99B76
-// 0.791437
-0x654DD205
-// -0.349692
-0xD33D48D0
-// 0.515454
-0x41FA6224
-// 0.632827
-0x51007C66
-// -0.420784
-0xCA23BF60
-// -0.102145
-0xF2ECE85E
-// -0.108888
-0xF20FF6B6
-// -0.071337
-0xF6DE6A0A
-// 0.222125
-0x1C6E95F3
-// 0.954381
-0x7A292931
-// -0.009537
-0xFEC77D32
-// 0.690290
-0x585B6909
-// -0.373862
-0xD0254A50
-// -0.401775
-0xCC929F0F
-// -0.526994
-0xBC8B764B
-// -0.108174
-0xF2275D71
-// -0.145750
-0xED58141F
-// -0.687438
-0xA8020C00
-// -0.138080
-0xEE5368B2
-// 0.299482
-0x26556E11
-// -0.335007
-0xD51E7C5E
-// 0.037999
-0x04DD22DF
-// -0.135805
-0xEE9DEE11
-// -0.059467
-0xF86363F3
-// -0.574834
-0xB66BD2ED
-// 0.670027
-0x55C372BE
-// 0.459860
-0x3ADCB2C0
-// -0.027026
-0xFC8A67CD
-// -0.232867
-0xE23166B4
-// 0.449278
-0x3981F180
-// -0.472344
-0xC38A37BE
-// -0.460632
-0xC50A0140
-// -0.020537
-0xFD5F0E67
-// 0.226100
-0x1CF0D8D8
-// -0.300239
-0xD991C7A4
-// -0.483106
-0xC2299331
-// 0.370064
-0x2F5E3F27
-// -0.447958
-0xC6A94EBB
-// -0.114977
-0xF1486CC6
-// 0.002673
-0x0057936E
-// 0.313435
-0x281EA3D5
-// 0.224268
-0x1CB4D141
-// 0.058595
-0x078006EE
-// 0.293105
-0x25847992
-// 0.534001
-0x445A2145
-// 0.115109
-0x0EBBE19F
-// 0.311036
-0x27D004C8
-// 0.101068
-0x0CEFCF6E
-// -0.296666
-0xDA06DA9E
-// 0.195551
-0x1907D15E
-// -0.165389
-0xEAD48C8F
-// -0.893092
-0x8DAF2696
-// 0.741478
-0x5EE8BFF5
-// -0.302549
-0xD946131C
-// -0.682302
-0xA8AA54D8
-// 0.167766
-0x1579584E
-// 0.626357
-0x502C73D8
-// -0.236993
-0xE1AA32F9
-// -0.114902
-0xF14AE84B
-// 0.192424
-0x18A15B07
-// 0.383732
-0x311E1FF1
-// 0.370809
-0x2F76AB22
-// -0.297444
-0xD9ED5EBD
-// 0.299017
-0x2646324E
-// 0.115933
-0x0ED6E826
-// 0.085232
-0x0AE8E5C4
-// -0.382533
-0xCF09263A
-// -0.270305
-0xDD66A7CE
-// -0.258910
-0xDEDC0AB3
-// 0.181298
-0x1734C415
-// 0.614301
-0x4EA16C1B
-// 0.598956
-0x4CAA9959
-// -0.170755
-0xEA24B25F
-// 0.255628
-0x20B86895
-// -0.677611
-0xA9440CE3
-// 0.167786
-0x157A0380
-// -0.616492
-0xB116C671
-// -0.399293
-0xCCE3F499
-// -0.298721
-0xD9C3847B
-// -0.020448
-0xFD61F398
-// 0.334721
-0x2AD82749
-// -0.497834
-0xC046F5D8
-// 0.379348
-0x308E7D14
-// 0.572822
-0x49523B43
-// 0.153518
-0x13A67D28
-// -0.338153
-0xD4B766EB
-// -0.417918
-0xCA81AB30
-// -0.090329
-0xF470178E
-// 0.348980
-0x2CAB6253
-// -0.021759
-0xFD37016D
-// -0.316715
-0xD775DF75
-// 0.209444
-0x1ACF0F11
-// 0.160261
-0x148371EB
-// 0.667704
-0x5577568F
-// -0.248489
-0xE031862C
-// -0.055007
-0xF8F58C04
-// 0.160996
-0x149B8502
-// 0.486511
-0x3E45FAE0
-// 0.297538
-0x2615B579
-// -0.214803
-0xE48151A8
-// -0.452145
-0xC62020F1
-// -0.241399
-0xE119D65A
-// 0.025185
-0x033946F5
-// -0.430657
-0xC8E03F41
-// 0.147914
-0x12EEDB02
-// -0.156480
-0xEBF87760
-// -0.142312
-0xEDC8B780
-// 0.198316
-0x19626EBB
-// -0.071480
-0xF6D9C0B3
-// 0.620962
-0x4F7BB269
-// -0.205635
-0xE5ADBDA7
-// -0.200116
-0xE6629A27
-// 0.012470
-0x01989CB8
-// 0.157481
-0x142853AF
-// 0.336862
-0x2B1E4CD6
-// -1.083394
+// -0.071197
+0xF6E302C3
+// -0.385476
+0xCEA8BC30
+// 0.067342
+0x089EA9FF
+// 0.119404
+0x0F48A52E
+// 0.745260
+0x5F64ADB0
+// -0.179524
+0xE9055DBE
+// 0.026169
+0x03597E89
+// -0.437671
+0xC7FA68F7
+// 0.682936
+0x576A6EB9
+// 0.280698
+0x23EDE564
+// -0.500366
+0xBFF40091
+// 0.671862
+0x55FF92B5
+// -0.108212
+0xF226199A
+// -0.478910
+0xC2B3128F
+// -0.379560
+0xCF6A9727
+// 0.188023
+0x1811239A
+// 0.504700
+0x409A047F
+// 0.141126
+0x12106BC3
+// 0.140643
+0x1200939D
+// 0.299112
+0x26494A7A
+// -0.197167
+0xE6C33AA8
+// 0.083393
+0x0AAC9C4D
+// 0.331400
+0x2A6B4E6D
+// 0.009038
+0x01282B4D
+// 0.636503
+0x5178F03D
+// 0.293432
+0x258F2F2C
+// -0.245488
+0xE093D893
+// 0.216703
+0x1BBCF05E
+// 0.524739
+0x432AA499
+// 0.193416
+0x18C1D98F
+// -0.102085
+0xF2EEE2EE
+// -0.151878
+0xEC8F42CD
+// 0.172126
+0x160837ED
+// -0.760014
+0x9EB7DB6B
+// -0.254463
+0xDF6DBE6B
+// 0.178646
+0x16DDE10C
+// -0.051516
+0xF967EDC1
+// -0.500234
+0xBFF85178
+// 0.090317
+0x0B8F8129
+// -0.260667
+0xDEA277DD
+// 0.085009
+0x0AE19114
+// -0.741216
+0xA11FD841
+// 0.629122
+0x50871033
+// 0.321173
+0x291C342D
+// 0.389879
+0x31E78E83
+// -0.341773
+0xD440CBE9
+// 0.234250
+0x1DFBE59C
+// -0.177254
+0xE94FBF17
+// 0.406378
+0x34043027
+// 0.079154
+0x0A21BA59
+// -0.205170
+0xE5BD0144
+// -0.358881
+0xD2103105
+// 0.077125
+0x09DF3ABA
+// 0.310800
+0x27C849BE
+// -0.713955
+0xA49D20DC
+// 0.071419
+0x09243E47
+// 0.514381
+0x41D73CF1
+// -0.180393
+0xE8E8E47F
+// -0.472845
+0xC379D0CE
+// 0.011329
+0x01733D87
+// -0.404595
+0xCC363D82
+// 0.321968
+0x2936413F
+// 0.350531
+0x2CDE2FD7
+// 0.328475
+0x2A0B74B7
+// 0.174497
+0x1655E9F0
+// 0.134645
+0x113C08DB
+// -0.008449
+0xFEEB2420
+// 0.457787
+0x3A98C79C
+// -0.799316
+0x99B005B0
+// -0.322492
+0xD6B89911
+// 0.457478
+0x3A8EA40B
+// 0.025263
+0x033BCFFD
+// 0.171850
+0x15FF2F95
+// -0.543697
+0xBA68202B
+// -0.010331
+0xFEAD7B4A
+// 0.262825
+0x21A4423B
+// 0.320363
+0x2901AB93
+// 0.772653
+0x62E6472E
+// -0.420216
+0xCA365D1D
+// -0.750616
+0x9FEBD0C4
+// -0.616820
+0xB10C09F8
+// 0.621164
+0x4F824930
+// 0.304817
+0x27044052
+// 0.009723
+0x013E9A03
+// 0.047709
+0x061B5625
+// -0.230026
+0xE28E846B
+// -0.274763
+0xDCD49058
+// -0.416788
+0xCAA6B244
+// 0.653928
+0x53B3E75E
+// -0.206776
+0xE5886040
+// 0.197719
+0x194EDCB9
+// -0.413086
+0xCB1FFE10
+// 0.208765
+0x1AB8D198
+// -0.113430
+0xF17B1C4B
+// 0.120644
+0x0F7144B0
+// -0.346073
+0xD3B3DEDE
+// 0.069860
+0x08F12966
+// 0.029502
+0x03C6B8A6
+// 0.232787
+0x1DCBFA3C
+// -0.264528
+0xDE23F2EB
+// 0.590641
+0x4B9A1E77
+// -1.167043
 0x80000000
-// -0.104795
-0xF29613BF
-// -0.276898
-0xDC8E9D7E
-// 0.267914
-0x224B03CF
-// 0.479540
-0x3D618D38
-// 0.043106
-0x05847BBF
-// 0.123032
-0x0FBF8190
-// -0.665994
-0xAAC0B6B9
-// -0.386173
-0xCE91DE19
-// -0.340509
-0xD46A316D
-// -0.435958
-0xC8328594
-// 0.251032
-0x2021CDCC
-// -0.050961
-0xF97A1CFF
-// -0.447282
-0xC6BF783E
-// -0.259829
-0xDEBDE90B
-// -0.090987
-0xF45A8CB7
-// 0.021898
-0x02CD8E10
-// 0.275603
-0x2346F87B
-// -0.221098
-0xE3B30DA9
-// 0.085943
-0x0B002F20
-// -0.383830
-0xCEDEA8A2
-// -0.583320
-0xB555C4DA
-// 0.033016
-0x0439E1CC
-// -0.301162
-0xD9738287
-// -0.088561
-0xF4AA07D5
-// -0.137155
-0xEE71B1F9
+// -0.002090
+0xFFBB8482
+// 0.303762
+0x26E1A9F4
+// -0.619835
+0xB0A93D01
+// -0.358614
+0xD218EFBB
+// 0.425247
+0x366E7C74
+// 0.182980
+0x176BE25B
+// 0.652212
+0x537BAB2A
+// 0.112016
+0x0E568713
+// -0.224768
+0xE33ACBFE
+// -0.582226
+0xB579A013
+// -0.388036
+0xCE54D2CF
+// -0.123624
+0xF02D18A6
+// -0.124090
+0xF01DD4D7
+// -0.093021
+0xF417E28B
+// 0.384173
+0x312C90EA
+// 0.007968
+0x010519F8
+// 0.212221
+0x1B2A0D11
+// -0.100378
+0xF326D185
+// 0.132103
+0x10E8C04C
+// 0.332089
+0x2A81E602
+// 0.062111
+0x07F344CC
+// 0.067057
+0x08955170
+// -0.046087
+0xFA19CE74
+// 0.064579
+0x08442007
+// -0.484354
+0xC200ACCF
+// 0.664290
+0x55077769
+// 0.046152
+0x05E84FE5
+// 0.111749
+0x0E4DCAF3
+// 0.138678
+0x11C03160
+// -0.286937
+0xDB45A411
+// -0.150792
+0xECB2D65E
+// 0.116351
+0x0EE49A97
+// -0.186286
+0xE827CB39
+// -0.614664
+0xB152AF2D
+// -0.239773
+0xE14F1D92
+// -0.173763
+0xE9C21FB8
+// -0.936476
+0x88218CD4
+// -0.301514
+0xD967FB81
+// -0.120599
+0xF09035B3
+// 0.214849
+0x1B802FE5
+// -0.184850
+0xE856D9F1
+// -0.133224
+0xEEF2865E
+// 0.909539
+0x746BC507
+// 0.646585
+0x52C34DB1
+// 0.108841
+0x0DEE7F49
+// -0.019321
+0xFD86E346
+// 0.692896
+0x58B0CD51
+// -0.175796
+0xE97F81CC
+// -0.086044
+0xF4FC845D
+// -0.734253
+0xA2040364
+// -0.278347
+0xDC5F234E
+// -0.020791
+0xFD56BC9E
+// -0.131341
+0xEF303BD6
+// -0.288219
+0xDB1BA757
+// 0.317068
+0x2895B21D
+// -0.543845
+0xBA63479F
+// -0.263410
+0xDE4895F7
+// 0.418143
+0x3585B799
+// 0.214328
+0x1B6F1625
+// -0.198243
+0xE69FFB07
+// -0.573599
+0xB6944DB2
+// -0.118493
+0xF0D5397D
+// 0.089070
+0x0B66A347
+// -0.147939
+0xED105691
+// -0.979712
+0x8298CA31
+// -0.420557
+0xCA2B2D71
+// -0.292715
+0xDA885497
+// -0.234946
+0xE1ED486E
 // 1.000000
 0x7FFFFFFF
-// -0.217879
-0xE41C8A24
-// 0.025938
-0x0351EC95
-// 0.011602
-0x017C28D5
-// -0.138664
-0xEE404596
-// -0.134049
-0xEED77C2D
-// -0.373408
-0xD03428D0
-// -0.242667
-0xE0F04D20
-// 0.228193
-0x1D35719D
-// -0.273874
-0xDCF1B2BB
-// -0.951035
-0x86447980
-// -0.166149
-0xEABB9FA9
-// 0.115490
-0x0EC86152
-// -0.061043
-0xF82FBD57
-// -0.534457
-0xBB96EC54
-// 0.087071
-0x0B25239E
-// 0.789342
-0x65092A4C
-// 0.060765
-0x07C728FE
-// -1.130708
-0x80000000
-// -0.054804
-0xF8FC3139
-// 0.138119
-0x11ADE454
-// -0.352852
-0xD2D5BF57
-// -0.550474
-0xB98A0E50
-// -0.006530
-0xFF2A047D
-// 0.326604
-0x29CE2975
-// 0.072525
-0x094880F0
-// 0.009314
-0x0131336E
-// 0.311803
-0x27E927A3
-// 0.032613
-0x042CAC83
-// 0.031215
-0x03FEDA34
-// -0.031586
-0xFBF5008E
-// -0.358277
-0xD223F854
-// 0.454718
-0x3A34373E
-// 0.304860
-0x2705A382
-// 0.148756
-0x130A71F4
-// 0.003548
-0x0074419F
-// 0.189184
-0x18372EA7
-// -0.280057
-0xDC271720
-// -0.210374
-0xE51279AB
-// 0.330860
-0x2A59A1B6
-// 0.674008
-0x5645E47E
-// -0.151508
-0xEC9B6291
-// 0.027349
-0x03802E04
-// 0.278968
-0x23B53992
-// -0.214924
-0xE47D61FF
-// -0.181063
-0xE8D2EABA
-// -0.641977
-0xADD3B1ED
-// -0.282667
-0xDBD1906A
-// 0.442232
-0x389B0D71
-// 0.411901
-0x34B92C25
-// 0.075038
-0x099AD856
-// 0.390567
-0x31FE1CE8
-// 0.137907
-0x11A6F0EB
-// -0.031852
-0xFBEC46D7
-// -0.610011
-0xB1EB2A7A
-// -0.663995
-0xAB0237F7
-// -0.444097
-0xC727D7DC
-// 0.520591
-0x42A2B79D
-// -0.751699
-0x9FC85691
-// 0.261251
-0x2170A820
-// -0.239431
-0xE15A54FE
-// 0.508622
-0x411A83F2
-// 0.181172
-0x1730A0FC
-// 0.034221
-0x04615B36
-// 0.511042
-0x4169D16D
-// 0.241075
-0x1EDB8EA2
-// 0.380551
-0x30B5E7A0
-// 0.780978
-0x63F714FC
-// -0.316204
-0xD786A39D
-// 0.101513
-0x0CFE5D94
-// -0.366571
-0xD11430EA
-// -0.022336
-0xFD241747
-// -0.138744
-0xEE3DA099
-// -0.279993
-0xDC2932EE
-// 0.641705
-0x52235FD4
-// 0.596518
-0x4C5AB44E
-// 0.448771
-0x39715215
-// 0.526161
-0x435941E9
-// -1.313914
-0x80000000
-// -0.554772
-0xB8FD3E1F
-// -0.501856
-0xBFC32C6B
-// -0.611578
-0xB1B7CC09
-// -0.064382
-0xF7C25445
-// -0.512487
-0xBE66D600
-// 0.304021
-0x26EA2822
-// -0.181700
-0xE8BE0ACD
-// -0.296030
-0xDA1BAEF5
-// 0.283549
-0x244B5635
-// -0.122271
-0xF05969C5
-// -0.058256
-0xF88B0D80
-// 0.082566
-0x0A9183C1
-// -0.084088
-0xF53C9C8B
-// -0.491656
-0xC1116994
-// -0.280043
-0xDC278C71
-// 0.135678
-0x115DE92E
-// 0.677701
-0x56BEE623
-// 0.279946
-0x23D544D0
-// 0.030215
-0x03DE17CB
-// -0.059591
-0xF85F5337
-// 0.832762
-0x6A97F2DB
-// -0.504904
-0xBF5F4D82
-// -0.113963
-0xF169AB73
-// 0.057926
-0x076A1B0D
+// -0.786481
+0x9B549A9D
+// -0.135607
+0xEEA46B82
+// 0.149779
+0x132BF29F
+// -0.426220
+0xC9719C06
+// 0.182801
+0x1766026F
+// -0.504850
+0xBF6112F5
+// 0.040677
+0x0534EA65
+// 0.333909
+0x2ABD8487
+// 0.255130
+0x20A819B4
+// -0.159059
+0xEBA3F2C8
+// 0.302987
+0x26C8485B
+// 0.695761
+0x590EB113
+// -0.571931
+0xB6CAF6BB
+// -0.442472
+0xC75D1520
+// 0.195152
+0x18FAB970
+// 0.530442
+0x43E58583
+// -0.184341
+0xE86786AD
+// -0.563652
+0xB7DA415E
+// 0.736574
+0x5E480D16
+// -0.315403
+0xD7A0DE41
+// 0.159283
+0x146361AC
+// -0.525530
+0xBCBB6BE4
+// 0.192262
+0x189C0C13
+// -0.067475
+0xF75CF882
+// 0.042000
+0x0560419E
+// 0.048550
+0x0636E427
+// 0.239203
+0x1E9E3358
+// 0.031063
+0x03F9DCB6
+// -0.573106
+0xB6A47A5D
+// -0.081699
+0xF58ADEF4
+// 0.520763
+0x42A85FF0
+// -0.120889
+0xF086B8B4
+// 0.011464
+0x0177A371
+// 0.141107
+0x120FC98E
+// -0.102650
+0xF2DC5E02
+// -0.277425
+0xDC7D534E
+// -0.262499
+0xDE666D94
+// 0.322503
+0x2947C899
+// 0.067273
+0x089C68E1
+// 0.122267
+0x0FA6748F
+// 0.123062
+0x0FC07B27
+// 0.407517
+0x34298197
+// -0.069090
+0xF7280B3A
+// -0.451078
+0xC64310E4
+// -0.168436
+0xEA70B3D3
+// 0.011667
+0x017E50B5
+// -0.604353
+0xB2A48CE0
+// 0.051138
+0x068BAFF4
+// -0.116911
+0xF1090DEE
+// -0.078841
+0xF5E88C65
+// -0.520434
+0xBD626D8E
+// -0.038423
+0xFB14F675
+// -0.459581
+0xC52C7735
+// -0.329268
+0xD5DA8E2B
+// 0.304915
+0x27077377
+// 0.498839
+0x3FD9F505
+// -0.266773
+0xDDDA5DC7
+// -0.007497
+0xFF0A5708
+// -0.166257
+0xEAB81886
+// -0.576583
+0xB63289BC
+// 0.196105
+0x1919F992
+// 0.318965
+0x28D3DAEC
+// 0.135923
+0x1165EE63
+// 0.064601
+0x0844D56C
+// 0.472799
+0x3C84A99A
+// 0.329747
+0x2A35266F
+// -0.096260
+0xF3ADC0C8
+// -0.173828
+0xE9C00092
+// 0.001860
+0x003CEEA7
+// -0.619334
+0xB0B9AB68
+// -0.111296
+0xF1C11037
+// -0.135879
+0xEE9B8838
+// -0.047173
+0xF9F639FA
+// -0.131147
+0xEF36946C
+// -0.750324
+0x9FF5629C
+// -0.077355
+0xF6193E12
+// -0.187138
+0xE80BDB54
+// 0.321475
+0x29261AFA
+// 0.163057
+0x14DF0C83
+// 0.011658
+0x017E01B8
+// 0.044806
+0x05BC34F6
+// 0.373222
+0x2FC5BF45
+// -0.024456
+0xFCDEA271
+// -0.005246
+0xFF541CF1
+// -0.116047
+0xF1255F9C

Testing/Patterns/DSP/BasicMaths/BasicMathsQ31/Input2_q31.txt

@@ -1,514 +1,514 @@
 W
 256
-// 0.197048
-0x1938DDFA
-// 0.191297
-0x187C6ADB
-// -0.044125
-0xFA5A1B60
-// 0.034313
-0x04645E02
-// -0.117171
-0xF10087E3
-// 0.028059
-0x03976EA5
-// -0.024345
-0xFCE2407E
-// 0.032431
-0x0426B4E8
-// 0.181816
-0x1745BC52
-// 0.301389
-0x2693EBFF
-// -0.007375
-0xFF0E5807
-// -0.132057
-0xEF18BFAF
-// 0.289879
-0x251AC431
-// -0.128082
-0xEF9B05BF
-// 0.188795
-0x182A6E7C
-// 0.231785
-0x1DAB2439
-// -0.154120
-0xEC45C8C4
-// -0.037413
-0xFB360FF3
-// -0.039882
-0xFAE52325
-// -0.026129
-0xFCA7D050
-// 0.081358
-0x0A69EC75
-// 0.349561
-0x2CBE675B
-// -0.003493
-0xFF8D896A
-// 0.252832
-0x205CCC97
-// -0.136934
-0xEE78F06E
-// -0.147158
-0xED29EC83
-// -0.193022
-0xE74B0FDC
-// -0.039621
-0xFAEDB55E
-// -0.053384
-0xF92AB9D1
-// -0.251787
-0xDFC56E6C
-// -0.050574
-0xF986C7CE
-// 0.109691
-0x0E0A5C14
-// -0.122703
-0xF04B4596
-// 0.013918
-0x01C80E2D
-// -0.049741
-0xF9A21344
-// -0.021781
-0xFD3648A9
-// -0.210544
-0xE50CE24C
-// 0.245410
-0x1F699C32
-// 0.168433
-0x158F3436
-// -0.009899
-0xFEBBA23F
-// -0.085292
-0xF515250B
-// 0.164557
-0x151032BF
-// -0.173005
-0xE9DAF608
-// -0.168715
-0xEA6787D3
-// -0.007522
-0xFF098571
-// 0.082814
-0x0A99A268
-// -0.109968
-0xF1EC8F78
-// -0.176947
-0xE959CC7D
-// 0.135543
-0x1159794C
-// -0.164073
-0xEAFFA4AC
-// -0.042113
-0xFA9C0D64
-// 0.000979
-0x0020138D
-// 0.114802
-0x0EB1D25E
-// 0.082143
-0x0A83A5BA
-// 0.021461
-0x02BF3F4D
-// 0.107356
-0x0DBDD369
-// 0.195588
-0x190907D5
-// 0.042161
-0x05658662
-// 0.113923
-0x0E950672
-// 0.037018
-0x04BD03D4
-// -0.108660
-0xF21770EC
-// 0.071624
-0x092AFCEC
-// -0.060577
-0xF83F0548
-// -0.327112
-0xD6212DF3
-// 0.271581
-0x22C3284D
-// -0.110814
-0xF1D0D4F9
-// -0.249906
-0xE003119E
-// 0.061447
-0x07DD8273
-// 0.229415
-0x1D5D7AE9
-// -0.086803
-0xF4E39FD3
-// -0.042085
-0xFA9CF629
-// 0.070479
-0x0905758C
-// 0.140549
-0x11FD8494
-// 0.135816
-0x11626B35
-// -0.108944
-0xF20E1B6D
-// 0.109521
-0x0E04C7B7
-// 0.042463
-0x056F6C6E
-// 0.031218
-0x03FEF3FC
-// -0.140110
-0xEE10DDF5
-// -0.099004
-0xF353D341
-// -0.094831
-0xF3DC95D1
-// 0.066404
-0x087FEBCF
-// 0.225000
-0x1CCCCAE9
-// 0.219379
-0x1C149FB2
-// -0.062542
-0xF7FE9C7F
-// 0.093629
-0x0BFC05CA
-// -0.248188
-0xE03B5F12
-// 0.061455
-0x07DDC126
-// -0.225802
-0xE318E886
-// -0.146249
-0xED47B6CE
-// -0.109412
-0xF1FEC71E
-// -0.007490
-0xFF0A94EB
-// 0.122598
-0x0FB14CB5
-// -0.182342
-0xE8A90823
-// 0.138944
-0x11C8E889
-// 0.209807
-0x1ADAF669
-// 0.056229
-0x073283B3
-// -0.123855
-0xF02583EF
-// -0.153071
-0xEC682F47
-// -0.033085
-0xFBC3E048
-// 0.127821
-0x105C6E94
-// -0.007970
-0xFEFADA17
-// -0.116003
-0xF126CF1A
-// 0.076713
-0x09D1BA96
-// 0.058699
-0x078371A4
-// 0.244560
-0x1F4DBBBC
-// -0.091014
-0xF459A8E6
-// -0.020147
-0xFD6BD105
-// 0.058968
-0x078C42FF
-// 0.178194
-0x16CF0F76
-// 0.108979
-0x0DF30546
-// -0.078676
-0xF5EDF234
-// -0.165607
-0xEACD6619
-// -0.088417
-0xF4AEBFBE
-// 0.009225
-0x012E4619
-// -0.157736
-0xEBCF4BBF
-// 0.054176
-0x06EF4151
-// -0.057314
-0xF8A9F0E6
-// -0.052125
-0xF953FB56
-// 0.072637
-0x094C2D68
-// -0.026181
-0xFCA61B3A
-// 0.227440
-0x1D1CBD6D
-// -0.075318
-0xF65BFB41
-// -0.073296
-0xF69E39B6
-// 0.004567
-0x0095A983
-// 0.057680
-0x076211F4
-// 0.123382
-0x0FCAFE02
-// -0.396814
-0xCD3530BC
-// -0.038383
-0xFB164249
-// -0.101419
-0xF304B23E
-// 0.098129
-0x0C8F7C2B
-// 0.175641
-0x167B64E1
-// 0.015788
-0x0205597B
-// 0.045063
-0x05C49E18
-// -0.243933
-0xE0C6CBF8
-// -0.141444
-0xEDE52D82
-// -0.124718
-0xF0093C70
-// -0.159678
-0xEB8FAA66
-// 0.091945
-0x0BC4DC5A
-// -0.018665
-0xFD9C5F1A
-// -0.163826
-0xEB07C2B5
-// -0.095168
-0xF3D18C8A
-// -0.033326
-0xFBBBFC5D
-// 0.008021
-0x0106D187
-// 0.100945
-0x0CEBC4CB
-// -0.080982
-0xF5A265B6
-// 0.031478
-0x04077B73
-// -0.140585
-0xEE014DD4
-// -0.213652
-0xE4A70A7A
-// 0.012093
-0x018C42A6
-// -0.110307
-0xF1E17935
-// -0.032437
-0xFBD918E4
-// -0.050236
-0xF991DF98
-// 0.366269
-0x2EE1EAEA
-// -0.079802
-0xF5C908A1
-// 0.009500
-0x01374D1F
-// 0.004249
-0x008B3DA6
-// -0.050788
-0xF97FC569
-// -0.049098
-0xF9B727EB
-// -0.136768
-0xEE7E62A2
-// -0.088881
-0xF49F891D
-// 0.083580
-0x0AB2C261
-// -0.100312
-0xF328FCC1
-// -0.348335
-0xD369C09E
-// -0.060855
-0xF835E427
-// 0.042301
-0x056A1A56
-// -0.022358
-0xFD235D9F
-// -0.195755
-0xE6F17EAC
-// 0.031891
-0x0415048A
-// 0.289112
-0x25019EBD
-// 0.022257
-0x02D94D18
-// -0.414144
-0xCAFD54CD
-// -0.020073
-0xFD6E401F
-// 0.050589
-0x0679B22C
-// -0.129239
-0xEF75199A
-// -0.201622
-0xE6314081
-// -0.002392
-0xFFB19FF0
-// 0.119625
-0x0F4FE004
-// 0.026564
-0x036670D2
-// 0.003411
-0x006FC928
-// 0.114204
-0x0E9E3B56
-// 0.011945
-0x01876C30
-// 0.011433
-0x0176A3BB
-// -0.011569
-0xFE84E973
-// -0.131226
-0xEF33FC4E
-// 0.166549
-0x15517E76
-// 0.111661
-0x0E4AE64A
-// 0.054485
-0x06F95C42
-// 0.001299
-0x002A94C6
-// 0.069292
-0x08DE9235
-// -0.102576
-0xF2DEC73C
-// -0.077053
-0xF6231CC8
-// 0.121184
-0x0F82F565
-// 0.246869
-0x1F99634F
-// -0.055493
-0xF8E59CF8
-// 0.010017
-0x01483E47
-// 0.102177
-0x0D1426C9
-// -0.078720
-0xF5EC8121
-// -0.066318
-0xF782E493
-// -0.235137
-0xE1E70B40
-// -0.103532
-0xF2BF73DF
-// 0.161976
-0x14BBA145
-// 0.150867
-0x134F9A20
-// 0.027484
-0x03849990
-// 0.143053
-0x124F8ED2
-// 0.050511
-0x0677266D
-// -0.011666
-0xFE81B74E
-// -0.223428
-0xE366B358
-// -0.243201
-0xE0DECA08
-// -0.162659
-0xEB2DFD49
-// 0.190676
-0x1868164F
-// -0.275324
-0xDCC22CAE
-// 0.095688
-0x0C3F81D2
-// -0.087696
-0xF4C65F16
-// 0.186293
-0x17D86F83
-// 0.066358
-0x087E67E5
-// 0.012534
-0x019AB7F4
-// 0.187179
-0x17F57B53
-// 0.088299
-0x0B4D5DD5
-// 0.139384
-0x11D75864
-// 0.286048
-0x249D3B54
-// -0.115816
-0xF12CF330
-// 0.037181
-0x04C2589A
-// -0.134264
-0xEED070F5
-// -0.008181
-0xFEF3EC8F
-// -0.050818
-0xF97ECD73
-// -0.102553
-0xF2DF8CF3
-// 0.235037
-0x1E15AF5E
-// 0.218486
-0x1BF75C5F
-// 0.164371
-0x150A1C1E
-// 0.192717
-0x18AAF230
-// -0.481246
-0xC2668445
-// -0.203196
-0xE5FDAD27
-// -0.183815
-0xE878C326
-// -0.224003
-0xE353E2BD
-// -0.023581
-0xFCFB4AC1
-// -0.187708
-0xE7F92D48
-// 0.111354
-0x0E40D572
-// -0.066551
-0xF77B3F42
-// -0.108427
-0xF21F11FF
-// 0.103855
-0x0D4B2205
-// -0.044784
-0xFA448276
-// -0.021338
-0xFD44CF98
-// 0.030241
-0x03DEF288
-// -0.030799
-0xFC0EC90C
-// -0.180079
-0xE8F32F0D
-// -0.102571
-0xF2DEF234
-// 0.049695
-0x065C66C0
-// 0.248221
-0x1FC5B579
-// 0.102536
-0x0D1FE361
-// 0.011067
-0x016AA40C
-// -0.021826
-0xFD34CB78
-// 0.305015
-0x270ABE01
-// -0.184931
-0xE8542EC5
-// -0.041741
-0xFAA83A97
-// 0.021216
-0x02B737D8
+// -0.028907
+0xFC4CC987
+// -0.156506
+0xEBF79A47
+// 0.027341
+0x037FEC7A
+// 0.048479
+0x063490ED
+// 0.302582
+0x26BAFF03
+// -0.072888
+0xF6AB9A32
+// 0.010625
+0x015C2654
+// -0.177698
+0xE9413255
+// 0.277277
+0x237DD3D7
+// 0.113965
+0x0E966BE0
+// -0.203153
+0xE5FF1715
+// 0.272781
+0x22EA80EB
+// -0.043935
+0xFA6055E1
+// -0.194441
+0xE71C8ADF
+// -0.154104
+0xEC464F3C
+// 0.076339
+0x09C5791D
+// 0.204912
+0x1A3A9230
+// 0.057298
+0x07558D8B
+// 0.057102
+0x074F1EB7
+// 0.121442
+0x0F8B6798
+// -0.080051
+0xF5C0DFBA
+// 0.033858
+0x0455765C
+// 0.134551
+0x1138F7B6
+// 0.003670
+0x00783F42
+// 0.258426
+0x211416A2
+// 0.119136
+0x0F3FD805
+// -0.099670
+0xF33E01E3
+// 0.087983
+0x0B430A21
+// 0.213048
+0x1B452A96
+// 0.078528
+0x0A0D3818
+// -0.041447
+0xFAB1DB3D
+// -0.061664
+0xF81B672E
+// 0.069884
+0x08F1F99D
+// -0.308572
+0xD880B69C
+// -0.103314
+0xF2C69977
+// 0.072532
+0x0948B918
+// -0.020916
+0xFD52A113
+// -0.203099
+0xE600D7AE
+// 0.036669
+0x04B1954A
+// -0.105833
+0xF2741162
+// 0.034514
+0x046AF686
+// -0.300940
+0xD97ACF33
+// 0.255429
+0x20B1E296
+// 0.130399
+0x10B0E9CA
+// 0.158294
+0x1442FB23
+// -0.138762
+0xEE3D0807
+// 0.095107
+0x0C2C7A2B
+// -0.071967
+0xF6C9CD24
+// 0.164993
+0x151E7B57
+// 0.032137
+0x041D1329
+// -0.083301
+0xF55668A4
+// -0.145709
+0xED596BCD
+// 0.031313
+0x0402136F
+// 0.126187
+0x1026E797
+// -0.289872
+0xDAE57D67
+// 0.028997
+0x03B62873
+// 0.208843
+0x1ABB5D7B
+// -0.073241
+0xF6A00AB4
+// -0.191979
+0xE76D3BDC
+// 0.004600
+0x0096BA04
+// -0.164269
+0xEAF93D98
+// 0.130722
+0x10BB7D7C
+// 0.142318
+0x12377C7C
+// 0.133363
+0x11120D33
+// 0.070847
+0x0911851F
+// 0.054667
+0x06FF5282
+// -0.003430
+0xFF8F97D0
+// 0.185865
+0x17CA709A
+// -0.324529
+0xD675D77F
+// -0.130934
+0xEF3D8C44
+// 0.185740
+0x17C652C7
+// 0.010257
+0x01501942
+// 0.069773
+0x08EE4EC8
+// -0.220746
+0xE3BE9BCE
+// -0.004194
+0xFF768F0A
+// 0.106709
+0x0DA8A5D7
+// 0.130070
+0x10A623F0
+// 0.313703
+0x28276DD0
+// -0.170611
+0xEA296A1E
+// -0.304756
+0xD8FDBF39
+// -0.250434
+0xDFF1C718
+// 0.252197
+0x204801E1
+// 0.123758
+0x0FD74FE5
+// 0.003948
+0x00815AD9
+// 0.019370
+0x027ABA3B
+// -0.093392
+0xF40BB856
+// -0.111556
+0xF1B887EB
+// -0.169219
+0xEA5705C1
+// 0.265500
+0x21FBE7B0
+// -0.083953
+0xF5410A7D
+// 0.080276
+0x0A4678A7
+// -0.167716
+0xEA88450A
+// 0.084760
+0x0AD96DBA
+// -0.046054
+0xFA1AE98E
+// 0.048983
+0x06450F36
+// -0.140509
+0xEE03D073
+// 0.028364
+0x03A16B21
+// 0.011978
+0x01887F2D
+// 0.094514
+0x0C190584
+// -0.107401
+0xF240B334
+// 0.239805
+0x1EB1EE6E
+// -0.473829
+0xC3599228
+// -0.000849
+0xFFE43212
+// 0.123330
+0x0FC944F3
+// -0.251658
+0xDFC9A9F1
+// -0.145600
+0xED5CF8BD
+// 0.172654
+0x16198411
+// 0.074291
+0x098260D6
+// 0.264803
+0x21E512B6
+// 0.045479
+0x05D243AF
+// -0.091258
+0xF451AAC0
+// -0.236388
+0xE1BE05E9
+// -0.157546
+0xEBD588AA
+// -0.050192
+0xF9934CC0
+// -0.050381
+0xF98D1A25
+// -0.037767
+0xFB2A70B3
+// 0.155977
+0x13F70FB0
+// 0.003235
+0x006A0263
+// 0.086163
+0x0B0766E1
+// -0.040754
+0xFAC890B5
+// 0.053635
+0x06DD8230
+// 0.134831
+0x114223E5
+// 0.025218
+0x033A55F9
+// 0.027226
+0x037C2114
+// -0.018712
+0xFD9AD959
+// 0.026220
+0x035B2A08
+// -0.196652
+0xE6D41C94
+// 0.269707
+0x2285C530
+// 0.018738
+0x026602DA
+// 0.045371
+0x05CEB7CC
+// 0.056304
+0x0734FACA
+// -0.116499
+0xF116909F
+// -0.061223
+0xF829D8ED
+// 0.047240
+0x060BF2D1
+// -0.075633
+0xF651A463
+// -0.249559
+0xE00E75D6
+// -0.097350
+0xF38A0A53
+// -0.070549
+0xF6F83D51
+// -0.380217
+0xCF550C96
+// -0.122417
+0xF054A1B6
+// -0.048964
+0xF9BB8A6B
+// 0.087231
+0x0B2A5FB2
+// -0.075050
+0xF664BF74
+// -0.054090
+0xF91394CB
+// 0.369280
+0x2F44934D
+// 0.262519
+0x219A3826
+// 0.044190
+0x05A806F5
+// -0.007845
+0xFEFEF384
+// 0.281321
+0x24025612
+// -0.071375
+0xF6DD3148
+// -0.034934
+0xFB87444A
+// -0.298113
+0xD9D77299
+// -0.113011
+0xF188DAE4
+// -0.008441
+0xFEEB66CB
+// -0.053325
+0xF92CA2B2
+// -0.117019
+0xF105848D
+// 0.128732
+0x107A4D47
+// -0.220806
+0xE3BCA422
+// -0.106947
+0xF24F932D
+// 0.169770
+0x15BB0280
+// 0.087019
+0x0B236E4B
+// -0.080488
+0xF5B2900F
+// -0.232886
+0xE230CAF2
+// -0.048109
+0xF9D78FAF
+// 0.036163
+0x04A0FDAE
+// -0.060064
+0xF84FCF38
+// -0.397771
+0xCD15D535
+// -0.170750
+0xEA24DF71
+// -0.118845
+0xF0C9B40D
+// -0.095390
+0xF3CA41F2
+// 0.406008
+0x33F813C9
+// -0.319318
+0xD72099F7
+// -0.055058
+0xF8F3DEB7
+// 0.060811
+0x07C8AAC8
+// -0.173049
+0xE9D987DA
+// 0.074219
+0x097FFE3B
+// -0.204973
+0xE5C36FA5
+// 0.016515
+0x021D2CB8
+// 0.135570
+0x115A589A
+// 0.103585
+0x0D4244FC
+// -0.064579
+0xF7BBDD3C
+// 0.123015
+0x0FBEF6DF
+// 0.282485
+0x242874C9
+// -0.232209
+0xE246FC3C
+// -0.179647
+0xE9015203
+// 0.079233
+0x0A244F87
+// 0.215364
+0x1B910A64
+// -0.074844
+0xF66B8498
+// -0.228847
+0xE2B521C3
+// 0.299055
+0x26476F63
+// -0.128056
+0xEF9BD9FF
+// 0.064670
+0x08471C9F
+// -0.213370
+0xE4B04DB8
+// 0.078060
+0x09FDDEF5
+// -0.027396
+0xFC7E4DD0
+// 0.017052
+0x022EC579
+// 0.019712
+0x0285EA37
+// 0.097118
+0x0C6E5FB4
+// 0.012612
+0x019D42A9
+// -0.232686
+0xE2375C17
+// -0.033171
+0xFBC11047
+// 0.211434
+0x1B1046C1
+// -0.049082
+0xF9B7B039
+// 0.004654
+0x00988326
+// 0.057291
+0x07554BB0
+// -0.041677
+0xFAAA5663
+// -0.112637
+0xF1951C85
+// -0.106577
+0xF25BB0EC
+// 0.130939
+0x10C29B63
+// 0.027313
+0x037F022A
+// 0.049642
+0x065AA75E
+// 0.049964
+0x0665386F
+// 0.165455
+0x152DA21D
+// -0.028051
+0xFC68D0B1
+// -0.183142
+0xE88ED1BF
+// -0.068386
+0xF73F1EAD
+// 0.004737
+0x009B3920
+// -0.245372
+0xE097A2FD
+// 0.020762
+0x02A857C3
+// -0.047467
+0xF9EC9AC7
+// -0.032010
+0xFBE718F1
+// -0.211300
+0xE4F41C0F
+// -0.015600
+0xFE00D20E
+// -0.186593
+0xE81DB48F
+// -0.133685
+0xEEE36595
+// 0.123798
+0x0FD89C79
+// 0.202533
+0x19EC97C9
+// -0.108312
+0xF222D32C
+// -0.003044
+0xFF9C4290
+// -0.067502
+0xF75C1B2B
+// -0.234097
+0xE2091963
+// 0.079620
+0x0A30FFA5
+// 0.129503
+0x10938A02
+// 0.055186
+0x0710552A
+// 0.026228
+0x035B73AE
+// 0.191960
+0x189225F7
+// 0.133880
+0x1122FAD1
+// -0.039082
+0xFAFF598E
+// -0.070576
+0xF6F760CB
+// 0.000755
+0x0018BD2E
+// -0.251455
+0xDFD055C7
+// -0.045187
+0xFA375052
+// -0.055168
+0xF8F042EE
+// -0.019153
+0xFD8C673B
+// -0.053247
+0xF92F364B
+// -0.304638
+0xD901A1E1
+// -0.031407
+0xFBFADE1C
+// -0.075980
+0xF6464CA8
+// 0.130522
+0x10B4EEF0
+// 0.066202
+0x0879525E
+// 0.004733
+0x009B190E
+// 0.018192
+0x02541AA4
+// 0.151531
+0x136560BA
+// -0.009929
+0xFEBAA398
+// -0.002130
+0xFFBA3666
+// -0.047116
+0xF9F81A36

Testing/Patterns/DSP/BasicMaths/BasicMathsQ31/MaxNeg2Input12_s32.txt

@@ -0,0 +1,20 @@
+W
+9
+// -2147483648
+0x80000000
+// -2
+0xFFFFFFFE
+// -2147483648
+0x80000000
+// -2
+0xFFFFFFFE
+// -2147483648
+0x80000000
+// -2
+0xFFFFFFFE
+// -2147483648
+0x80000000
+// -2
+0xFFFFFFFE
+// -2147483648
+0x80000000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ31/MaxNegInput12_s32.txt

@@ -0,0 +1,20 @@
+W
+9
+// -2147483647
+0x80000001
+// -1
+0xFFFFFFFF
+// -2147483647
+0x80000001
+// -1
+0xFFFFFFFF
+// -2147483647
+0x80000001
+// -1
+0xFFFFFFFF
+// -2147483647
+0x80000001
+// -1
+0xFFFFFFFF
+// -2147483647
+0x80000001

Testing/Patterns/DSP/BasicMaths/BasicMathsQ31/MaxPosInput12_s32.txt

@@ -0,0 +1,20 @@
+W
+9
+// 2147483646
+0x7FFFFFFE
+// 1
+0x00000001
+// 2147483646
+0x7FFFFFFE
+// 1
+0x00000001
+// 2147483646
+0x7FFFFFFE
+// 1
+0x00000001
+// 2147483646
+0x7FFFFFFE
+// 1
+0x00000001
+// 2147483646
+0x7FFFFFFE

Testing/Patterns/DSP/BasicMaths/BasicMathsQ31/NegSat13_q31.txt

@@ -0,0 +1,20 @@
+W
+9
+// -2.000000
+0x80000000
+// -0.000000
+0xFFFFFFFE
+// -2.000000
+0x80000000
+// -0.000000
+0xFFFFFFFE
+// -2.000000
+0x80000000
+// -0.000000
+0xFFFFFFFE
+// -2.000000
+0x80000000
+// -0.000000
+0xFFFFFFFE
+// -2.000000
+0x80000000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ31/NegSat15_q31.txt

@@ -0,0 +1,20 @@
+W
+9
+// -2.000000
+0x80000000
+// -0.000000
+0xFFFFFFFE
+// -2.000000
+0x80000000
+// -0.000000
+0xFFFFFFFE
+// -2.000000
+0x80000000
+// -0.000000
+0xFFFFFFFE
+// -2.000000
+0x80000000
+// -0.000000
+0xFFFFFFFE
+// -2.000000
+0x80000000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ31/NegSat19_q31.txt

@@ -0,0 +1,20 @@
+W
+9
+// -1.900000
+0x80000000
+// -0.900000
+0x8CCCCCCC
+// -1.900000
+0x80000000
+// -0.900000
+0x8CCCCCCC
+// -1.900000
+0x80000000
+// -0.900000
+0x8CCCCCCC
+// -1.900000
+0x80000000
+// -0.900000
+0x8CCCCCCC
+// -1.900000
+0x80000000

Testing/Patterns/DSP/BasicMaths/BasicMathsQ31/PosSat12_q31.txt

@@ -0,0 +1,20 @@
+W
+9
+// 2.000000
+0x7FFFFFFF
+// 0.000000
+0x00000002
+// 2.000000
+0x7FFFFFFF
+// 0.000000
+0x00000002
+// 2.000000
+0x7FFFFFFF
+// 0.000000
+0x00000002
+// 2.000000
+0x7FFFFFFF
+// 0.000000
+0x00000002
+// 2.000000
+0x7FFFFFFF

Testing/Patterns/DSP/BasicMaths/BasicMathsQ31/PosSat14_q31.txt

@@ -0,0 +1,20 @@
+W
+9
+// 2.000000
+0x7FFFFFFF
+// 0.000000
+0x00000002
+// 2.000000
+0x7FFFFFFF
+// 0.000000
+0x00000002
+// 2.000000
+0x7FFFFFFF
+// 0.000000
+0x00000002
+// 2.000000
+0x7FFFFFFF
+// 0.000000
+0x00000002
+// 2.000000
+0x7FFFFFFF