CMSIS-DSP: Added MVE support for logical operators (modified prototypes)

CMSIS/DSP/Include/arm_math.h

@@ -2097,11 +2097,11 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_and_q15(
-    const q15_t * pSrcA,
-    const q15_t * pSrcB,
-    q15_t * pDst,
-    uint32_t blockSize);
+  void arm_and_u16(
+    const uint16_t * pSrcA,
+    const uint16_t * pSrcB,
+          uint16_t * pDst,
+          uint32_t blockSize);
 
   /**
    * @brief         Compute the logical bitwise AND of two fixed-point vectors.
@@ -2111,11 +2111,11 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_and_q31(
-    const q31_t * pSrcA,
-    const q31_t * pSrcB,
-    q31_t * pDst,
-    uint32_t blockSize);
+  void arm_and_u32(
+    const uint32_t * pSrcA,
+    const uint32_t * pSrcB,
+          uint32_t * pDst,
+          uint32_t blockSize);
 
   /**
    * @brief         Compute the logical bitwise AND of two fixed-point vectors.
@@ -2125,11 +2125,11 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_and_q7(
-    const q7_t * pSrcA,
-    const q7_t * pSrcB,
-    q7_t * pDst,
-    uint32_t blockSize);
+  void arm_and_u8(
+    const uint8_t * pSrcA,
+    const uint8_t * pSrcB,
+          uint8_t * pDst,
+          uint32_t blockSize);
 
   /**
    * @brief         Compute the logical bitwise OR of two fixed-point vectors.
@@ -2139,11 +2139,11 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_or_q15(
-    const q15_t * pSrcA,
-    const q15_t * pSrcB,
-    q15_t * pDst,
-    uint32_t blockSize);
+  void arm_or_u16(
+    const uint16_t * pSrcA,
+    const uint16_t * pSrcB,
+          uint16_t * pDst,
+          uint32_t blockSize);
 
   /**
    * @brief         Compute the logical bitwise OR of two fixed-point vectors.
@@ -2153,11 +2153,11 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_or_q31(
-    const q31_t * pSrcA,
-    const q31_t * pSrcB,
-    q31_t * pDst,
-    uint32_t blockSize);
+  void arm_or_u32(
+    const uint32_t * pSrcA,
+    const uint32_t * pSrcB,
+          uint32_t * pDst,
+          uint32_t blockSize);
 
   /**
    * @brief         Compute the logical bitwise OR of two fixed-point vectors.
@@ -2167,11 +2167,11 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_or_q7(
-    const q7_t * pSrcA,
-    const q7_t * pSrcB,
-    q7_t * pDst,
-    uint32_t blockSize);
+  void arm_or_u8(
+    const uint8_t * pSrcA,
+    const uint8_t * pSrcB,
+          uint8_t * pDst,
+          uint32_t blockSize);
 
   /**
    * @brief         Compute the logical bitwise NOT of a fixed-point vector.
@@ -2180,10 +2180,10 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_not_q15(
-    const q15_t * pSrc,
-          q15_t * pDst,
-    uint32_t blockSize);
+  void arm_not_u16(
+    const uint16_t * pSrc,
+          uint16_t * pDst,
+          uint32_t blockSize);
 
   /**
    * @brief         Compute the logical bitwise NOT of a fixed-point vector.
@@ -2192,10 +2192,10 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_not_q31(
-    const q31_t * pSrc,
-          q31_t * pDst,
-    uint32_t blockSize);
+  void arm_not_u32(
+    const uint32_t * pSrc,
+          uint32_t * pDst,
+          uint32_t blockSize);
 
   /**
    * @brief         Compute the logical bitwise NOT of a fixed-point vector.
@@ -2204,10 +2204,10 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_not_q7(
-    const q7_t * pSrc,
-          q7_t * pDst,
-    uint32_t blockSize);
+  void arm_not_u8(
+    const uint8_t * pSrc,
+          uint8_t * pDst,
+          uint32_t blockSize);
 
 /**
    * @brief         Compute the logical bitwise XOR of two fixed-point vectors.
@@ -2217,11 +2217,11 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_xor_q15(
-    const q15_t * pSrcA,
-    const q15_t * pSrcB,
-    q15_t * pDst,
-    uint32_t blockSize);
+  void arm_xor_u16(
+    const uint16_t * pSrcA,
+    const uint16_t * pSrcB,
+          uint16_t * pDst,
+          uint32_t blockSize);
 
   /**
    * @brief         Compute the logical bitwise XOR of two fixed-point vectors.
@@ -2231,11 +2231,11 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_xor_q31(
-    const q31_t * pSrcA,
-    const q31_t * pSrcB,
-    q31_t * pDst,
-    uint32_t blockSize);
+  void arm_xor_u32(
+    const uint32_t * pSrcA,
+    const uint32_t * pSrcB,
+          uint32_t * pDst,
+          uint32_t blockSize);
 
   /**
    * @brief         Compute the logical bitwise XOR of two fixed-point vectors.
@@ -2245,10 +2245,10 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
    * @param[in]     blockSize  number of samples in each vector
    * @return        none
    */
-  void arm_xor_q7(
-    const q7_t * pSrcA,
-    const q7_t * pSrcB,
-    q7_t * pDst,
+  void arm_xor_u8(
+    const uint8_t * pSrcA,
+    const uint8_t * pSrcB,
+          uint8_t * pDst,
     uint32_t blockSize);
 
   /**

CMSIS/DSP/Source/BasicMathFunctions/arm_and_q15.c → CMSIS/DSP/Source/BasicMathFunctions/arm_and_u16.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_and_q15.c
- * Description:  Q15 bitwise AND
+ * Title:        arm_and_u16.c
+ * Description:  uint16_t bitwise AND
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -28,18 +28,16 @@
 
 #include "arm_math.h"
 
-
 /**
   @ingroup groupMath
  */
 
-
 /**
   @defgroup And Vector bitwise AND
 
   Compute the logical bitwise AND.
 
-  There are separate functions for Q31, Q15, and Q7 data types.
+  There are separate functions for uint32_t, uint16_t, and uint7_t data types.
  */
 
 /**
@@ -56,26 +54,58 @@
   @return        none
  */
 
-void arm_and_q15(
-    const q15_t * pSrcA,
-    const q15_t * pSrcB,
-    q15_t * pDst,
-    uint32_t blockSize)
+void arm_and_u16(
+    const uint16_t * pSrcA,
+    const uint16_t * pSrcB,
+          uint16_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int16x8_t vecA, vecB;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q15x8_t vecSrcA, vecSrcB;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+
+    while (blkCnt > 0U)
+    {
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+
+        vst1q(pDst, vandq_u16(vecSrcA, vecSrcB) );
+
+        pSrcA += 8;
+        pSrcB += 8;
+        pDst  += 8;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 7;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+        vstrhq_p(pDst, vandq_u16(vecSrcA, vecSrcB), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint16x8_t vecA, vecB;
 
     /* Compute 8 outputs at a time */
     blkCnt = blockSize >> 3U;
 
     while (blkCnt > 0U)
     {
-        vecA = vld1q_s16(pSrcA);
-        vecB = vld1q_s16(pSrcB);
+        vecA = vld1q_u16(pSrcA);
+        vecB = vld1q_u16(pSrcB);
 
-        vst1q_s16(pDst, vandq_s16(vecA, vecB) );
+        vst1q_u16(pDst, vandq_u16(vecA, vecB) );
 
         pSrcA += 8;
         pSrcB += 8;
@@ -99,6 +129,7 @@ void arm_and_q15(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 
 /**

CMSIS/DSP/Source/BasicMathFunctions/arm_and_q31.c → CMSIS/DSP/Source/BasicMathFunctions/arm_and_u32.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_and_q31.c
- * Description:  Q31 bitwise AND
+ * Title:        arm_and_u32.c
+ * Description:  uint32_t bitwise AND
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -28,7 +28,6 @@
 
 #include "arm_math.h"
 
-
 /**
   @ingroup groupMath
  */
@@ -47,26 +46,58 @@
   @return        none
  */
 
-void arm_and_q31(
-    const q31_t * pSrcA,
-    const q31_t * pSrcB,
-    q31_t * pDst,
-    uint32_t blockSize)
+void arm_and_u32(
+    const uint32_t * pSrcA,
+    const uint32_t * pSrcB,
+          uint32_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int32x4_t vecA, vecB;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q31x4_t vecSrcA, vecSrcB;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+
+    while (blkCnt > 0U)
+    {
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+
+        vst1q(pDst, vandq_u32(vecSrcA, vecSrcB) );
+
+        pSrcA += 4;
+        pSrcB += 4;
+        pDst  += 4;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 3;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+        vstrwq_p(pDst, vandq_u32(vecSrcA, vecSrcB), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint32x4_t vecA, vecB;
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
 
     while (blkCnt > 0U)
     {
-        vecA = vld1q_s32(pSrcA);
-        vecB = vld1q_s32(pSrcB);
+        vecA = vld1q_u32(pSrcA);
+        vecB = vld1q_u32(pSrcB);
 
-        vst1q_s32(pDst, vandq_s32(vecA, vecB) );
+        vst1q_u32(pDst, vandq_u32(vecA, vecB) );
 
         pSrcA += 4;
         pSrcB += 4;
@@ -90,6 +121,7 @@ void arm_and_q31(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 
 /**

CMSIS/DSP/Source/BasicMathFunctions/arm_and_q7.c → CMSIS/DSP/Source/BasicMathFunctions/arm_and_u8.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_and_q7.c
- * Description:  Q7 bitwise AND
+ * Title:        arm_and_u8.c
+ * Description:  uint8_t bitwise AND
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -28,7 +28,6 @@
 
 #include "arm_math.h"
 
-
 /**
   @ingroup groupMath
  */
@@ -48,26 +47,58 @@
   @return        none
  */
 
-void arm_and_q7(
-    const q7_t * pSrcA,
-    const q7_t * pSrcB,
-    q7_t * pDst,
-    uint32_t blockSize)
+void arm_and_u8(
+    const uint8_t * pSrcA,
+    const uint8_t * pSrcB,
+          uint8_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int8x16_t vecA, vecB;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q7x16_t vecSrcA, vecSrcB;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+
+    while (blkCnt > 0U)
+    {
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+
+        vst1q(pDst, vandq_u8(vecSrcA, vecSrcB) );
+
+        pSrcA += 16;
+        pSrcB += 16;
+        pDst  += 16;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0xF;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+        vstrbq_p(pDst, vandq_u8(vecSrcA, vecSrcB), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint8x16_t vecA, vecB;
 
     /* Compute 16 outputs at a time */
     blkCnt = blockSize >> 4U;
 
     while (blkCnt > 0U)
     {
-        vecA = vld1q_s8(pSrcA);
-        vecB = vld1q_s8(pSrcB);
+        vecA = vld1q_u8(pSrcA);
+        vecB = vld1q_u8(pSrcB);
 
-        vst1q_s8(pDst, vandq_s8(vecA, vecB) );
+        vst1q_u8(pDst, vandq_u8(vecA, vecB) );
 
         pSrcA += 16;
         pSrcB += 16;
@@ -91,6 +122,7 @@ void arm_and_q7(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 
 /**

CMSIS/DSP/Source/BasicMathFunctions/arm_not_q15.c → CMSIS/DSP/Source/BasicMathFunctions/arm_not_u16.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_not_q15.c
- * Description:  Q15 bitwise NOT
+ * Title:        arm_not_u16.c
+ * Description:  uint16_t bitwise NOT
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -28,18 +28,16 @@
 
 #include "arm_math.h"
 
-
 /**
   @ingroup groupMath
  */
 
-
 /**
   @defgroup Not Vector bitwise NOT
 
   Compute the logical bitwise NOT.
 
-  There are separate functions for Q31, Q15, and Q7 data types.
+  There are separate functions for uint32_t, uint16_t, and uint8_t data types.
  */
 
 /**
@@ -55,24 +53,53 @@
   @return        none
  */
 
-void arm_not_q15(
-    const q15_t * pSrc,
-          q15_t * pDst,
-    uint32_t blockSize)
+void arm_not_u16(
+    const uint16_t * pSrc,
+          uint16_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int16x8_t inV;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q15x8_t vecSrc;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+
+    while (blkCnt > 0U)
+    {
+        vecSrc = vld1q(pSrc);
+
+        vst1q(pDst, vmvnq_u16(vecSrc) );
+
+        pSrc += 8;
+        pDst += 8;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 7;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrhq_p(pDst, vmvnq_u16(vecSrc), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint16x8_t inV;
 
     /* Compute 8 outputs at a time */
     blkCnt = blockSize >> 3U;
 
     while (blkCnt > 0U)
     {
-        inV = vld1q_s16(pSrc);
+        inV = vld1q_u16(pSrc);
 
-        vst1q_s16(pDst, vmvnq_s16(inV) );
+        vst1q_u16(pDst, vmvnq_u16(inV) );
 
         pSrc += 8;
         pDst += 8;
@@ -95,6 +122,7 @@ void arm_not_q15(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 
 /**

CMSIS/DSP/Source/BasicMathFunctions/arm_not_q31.c → CMSIS/DSP/Source/BasicMathFunctions/arm_not_u32.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_not_q31.c
- * Description:  Q31 bitwise NOT
+ * Title:        arm_not_u32.c
+ * Description:  uint32_t bitwise NOT
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -28,12 +28,10 @@
 
 #include "arm_math.h"
 
-
 /**
   @ingroup groupMath
  */
 
-
 /**
   @addtogroup Not
   @{
@@ -47,24 +45,53 @@
   @return        none
  */
 
-void arm_not_q31(
-    const q31_t * pSrc,
-          q31_t * pDst,
-    uint32_t blockSize)
+void arm_not_u32(
+    const uint32_t * pSrc,
+          uint32_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int32x4_t inV;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q31x4_t vecSrc;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 2;
+
+    while (blkCnt > 0U)
+    {
+        vecSrc = vld1q(pSrc);
+
+        vst1q(pDst, vmvnq_u32(vecSrc) );
+
+        pSrc += 4;
+        pDst += 4;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 3;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrwq_p(pDst, vmvnq_u32(vecSrc), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint32x4_t inV;
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
 
     while (blkCnt > 0U)
     {
-        inV = vld1q_s32(pSrc);
+        inV = vld1q_u32(pSrc);
 
-        vst1q_s32(pDst, vmvnq_s32(inV) );
+        vst1q_u32(pDst, vmvnq_u32(inV) );
 
         pSrc += 4;
         pDst += 4;
@@ -87,6 +114,7 @@ void arm_not_q31(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 
 /**

CMSIS/DSP/Source/BasicMathFunctions/arm_not_q7.c → CMSIS/DSP/Source/BasicMathFunctions/arm_not_u8.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_not_q7.c
- * Description:  Q7 bitwise NOT
+ * Title:        arm_not_u8.c
+ * Description:  uint8_t bitwise NOT
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -28,12 +28,10 @@
 
 #include "arm_math.h"
 
-
 /**
   @ingroup groupMath
  */
 
-
 /**
   @addtogroup Not
   @{
@@ -47,24 +45,53 @@
   @return        none
  */
 
-void arm_not_q7(
-    const q7_t * pSrc,
-          q7_t * pDst,
-    uint32_t blockSize)
+void arm_not_u8(
+    const uint8_t * pSrc,
+          uint8_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int8x16_t inV;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q7x16_t vecSrc;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+
+    while (blkCnt > 0U)
+    {
+        vecSrc = vld1q(pSrc);
+
+        vst1q(pDst, vmvnq_u8(vecSrc) );
+
+        pSrc += 16;
+        pDst += 16;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0xF;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecSrc = vld1q(pSrc);
+        vstrbq_p(pDst, vmvnq_u8(vecSrc), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint8x16_t inV;
 
     /* Compute 16 outputs at a time */
     blkCnt = blockSize >> 4U;
 
     while (blkCnt > 0U)
     {
-        inV = vld1q_s8(pSrc);
+        inV = vld1q_u8(pSrc);
 
-        vst1q_s8(pDst, vmvnq_s8(inV) );
+        vst1q_u8(pDst, vmvnq_u8(inV) );
 
         pSrc += 16;
         pDst += 16;
@@ -87,6 +114,7 @@ void arm_not_q7(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 
 /**

CMSIS/DSP/Source/BasicMathFunctions/arm_or_q15.c → CMSIS/DSP/Source/BasicMathFunctions/arm_or_u16.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_or_q15.c
- * Description:  Q15 bitwise inclusive OR
+ * Title:        arm_or_u16.c
+ * Description:  uint16_t bitwise inclusive OR
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -28,18 +28,16 @@
 
 #include "arm_math.h"
 
-
 /**
   @ingroup groupMath
  */
 
-
 /**
   @defgroup Or Vector bitwise inclusive OR
 
   Compute the logical bitwise OR.
 
-  There are separate functions for Q31, Q15, and Q7 data types.
+  There are separate functions for uint32_t, uint16_t, and uint8_t data types.
  */
 
 /**
@@ -56,26 +54,58 @@
   @return        none
  */
 
-void arm_or_q15(
-    const q15_t * pSrcA,
-    const q15_t * pSrcB,
-    q15_t * pDst,
-    uint32_t blockSize)
+void arm_or_u16(
+    const uint16_t * pSrcA,
+    const uint16_t * pSrcB,
+          uint16_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int16x8_t vecA, vecB;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q15x8_t vecSrcA, vecSrcB;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+
+    while (blkCnt > 0U)
+    {
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+
+        vst1q(pDst, vorrq_u16(vecSrcA, vecSrcB) );
+
+        pSrcA += 8;
+        pSrcB += 8;
+        pDst  += 8;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 7;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+        vstrhq_p(pDst, vorrq_u16(vecSrcA, vecSrcB), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint16x8_t vecA, vecB;
 
     /* Compute 8 outputs at a time */
     blkCnt = blockSize >> 3U;
 
     while (blkCnt > 0U)
     {
-        vecA = vld1q_s16(pSrcA);
-        vecB = vld1q_s16(pSrcB);
+        vecA = vld1q_u16(pSrcA);
+        vecB = vld1q_u16(pSrcB);
 
-        vst1q_s16(pDst, vorrq_s16(vecA, vecB) );
+        vst1q_u16(pDst, vorrq_u16(vecA, vecB) );
 
         pSrcA += 8;
         pSrcB += 8;
@@ -99,6 +129,7 @@ void arm_or_q15(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 
 /**

CMSIS/DSP/Source/BasicMathFunctions/arm_or_q31.c → CMSIS/DSP/Source/BasicMathFunctions/arm_or_u32.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_or_q31.c
- * Description:  Q31 bitwise inclusive OR
+ * Title:        arm_or_u32.c
+ * Description:  uint32_t bitwise inclusive OR
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -28,12 +28,10 @@
 
 #include "arm_math.h"
 
-
 /**
   @ingroup groupMath
  */
 
-
 /**
   @addtogroup Or
   @{
@@ -48,26 +46,58 @@
   @return        none
  */
 
-void arm_or_q31(
-    const q31_t * pSrcA,
-    const q31_t * pSrcB,
-    q31_t * pDst,
-    uint32_t blockSize)
+void arm_or_u32(
+    const uint32_t * pSrcA,
+    const uint32_t * pSrcB,
+          uint32_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int32x4_t vecA, vecB;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q31x4_t vecSrcA, vecSrcB;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+
+    while (blkCnt > 0U)
+    {
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+
+        vst1q(pDst, vorrq_u32(vecSrcA, vecSrcB) );
+
+        pSrcA += 4;
+        pSrcB += 4;
+        pDst  += 4;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 3;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+        vstrwq_p(pDst, vorrq_u32(vecSrcA, vecSrcB), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint32x4_t vecA, vecB;
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
 
     while (blkCnt > 0U)
     {
-        vecA = vld1q_s32(pSrcA);
-        vecB = vld1q_s32(pSrcB);
+        vecA = vld1q_u32(pSrcA);
+        vecB = vld1q_u32(pSrcB);
 
-        vst1q_s32(pDst, vorrq_s32(vecA, vecB) );
+        vst1q_u32(pDst, vorrq_u32(vecA, vecB) );
 
         pSrcA += 4;
         pSrcB += 4;
@@ -91,6 +121,7 @@ void arm_or_q31(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 /**
   @} end of Or group

CMSIS/DSP/Source/BasicMathFunctions/arm_or_q7.c → CMSIS/DSP/Source/BasicMathFunctions/arm_or_u8.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_or_q7.c
- * Description:  Q7 bitwise inclusive OR
+ * Title:        arm_or_u8.c
+ * Description:  uint8_t bitwise inclusive OR
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -28,12 +28,10 @@
 
 #include "arm_math.h"
 
-
 /**
   @ingroup groupMath
  */
 
-
 /**
   @addtogroup Or
   @{
@@ -48,26 +46,58 @@
   @return        none
  */
 
-void arm_or_q7(
-    const q7_t * pSrcA,
-    const q7_t * pSrcB,
-    q7_t * pDst,
-    uint32_t blockSize)
+void arm_or_u8(
+    const uint8_t * pSrcA,
+    const uint8_t * pSrcB,
+          uint8_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int8x16_t vecA, vecB;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q7x16_t vecSrcA, vecSrcB;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+
+    while (blkCnt > 0U)
+    {
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+
+        vst1q(pDst, vorrq_u8(vecSrcA, vecSrcB) );
+
+        pSrcA += 16;
+        pSrcB += 16;
+        pDst  += 16;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0xF;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+        vstrbq_p(pDst, vorrq_u8(vecSrcA, vecSrcB), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint8x16_t vecA, vecB;
 
     /* Compute 16 outputs at a time */
     blkCnt = blockSize >> 4U;
 
     while (blkCnt > 0U)
     {
-        vecA = vld1q_s8(pSrcA);
-        vecB = vld1q_s8(pSrcB);
+        vecA = vld1q_u8(pSrcA);
+        vecB = vld1q_u8(pSrcB);
 
-        vst1q_s8(pDst, vorrq_s8(vecA, vecB) );
+        vst1q_u8(pDst, vorrq_u8(vecA, vecB) );
 
         pSrcA += 16;
         pSrcB += 16;
@@ -91,6 +121,7 @@ void arm_or_q7(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 /**
   @} end of Or group

CMSIS/DSP/Source/BasicMathFunctions/arm_xor_q15.c → CMSIS/DSP/Source/BasicMathFunctions/arm_xor_u16.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_xor_q15.c
- * Description:  Q15 bitwise exclusive OR
+ * Title:        arm_xor_u16.c
+ * Description:  uint16_t bitwise exclusive OR
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -26,6 +26,7 @@
  * limitations under the License.
  */
 
+#include "arm_math.h"
 
 /**
   @ingroup groupMath
@@ -36,7 +37,7 @@
 
   Compute the logical bitwise XOR.
 
-  There are separate functions for Q31, Q15, and Q7 data types.
+  There are separate functions for uint32_t, uint16_t, and uint8_t data types.
  */
 
 /**
@@ -53,28 +54,58 @@
   @return        none
  */
 
-#include "arm_math.h"
-
-void arm_xor_q15(
-    const q15_t * pSrcA,
-    const q15_t * pSrcB,
-    q15_t * pDst,
-    uint32_t blockSize)
+void arm_xor_u16(
+    const uint16_t * pSrcA,
+    const uint16_t * pSrcB,
+          uint16_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int16x8_t vecA, vecB;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q15x8_t vecSrcA, vecSrcB;
+
+    /* Compute 8 outputs at a time */
+    blkCnt = blockSize >> 3;
+
+    while (blkCnt > 0U)
+    {
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+
+        vst1q(pDst, veorq_u16(vecSrcA, vecSrcB) );
+
+        pSrcA += 8;
+        pSrcB += 8;
+        pDst  += 8;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 7;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp16q(blkCnt);
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+        vstrhq_p(pDst, veorq_u16(vecSrcA, vecSrcB), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint16x8_t vecA, vecB;
 
     /* Compute 8 outputs at a time */
     blkCnt = blockSize >> 3U;
 
     while (blkCnt > 0U)
     {
-        vecA = vld1q_s16(pSrcA);
-        vecB = vld1q_s16(pSrcB);
+        vecA = vld1q_u16(pSrcA);
+        vecB = vld1q_u16(pSrcB);
 
-        vst1q_s16(pDst, veorq_s16(vecA, vecB) );
+        vst1q_u16(pDst, veorq_u16(vecA, vecB) );
 
         pSrcA += 8;
         pSrcB += 8;
@@ -98,6 +129,7 @@ void arm_xor_q15(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 
 /**

CMSIS/DSP/Source/BasicMathFunctions/arm_xor_q31.c → CMSIS/DSP/Source/BasicMathFunctions/arm_xor_u32.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_xor_q31.c
- * Description:  Q31 bitwise exclusive OR
+ * Title:        arm_xor_u32.c
+ * Description:  uint32_t bitwise exclusive OR
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -26,12 +26,12 @@
  * limitations under the License.
  */
 
+#include "arm_math.h"
 
 /**
   @ingroup groupMath
  */
 
-
 /**
   @addtogroup Xor
   @{
@@ -46,28 +46,58 @@
   @return        none
  */
 
-#include "arm_math.h"
-
-void arm_xor_q31(
-    const q31_t * pSrcA,
-    const q31_t * pSrcB,
-    q31_t * pDst,
-    uint32_t blockSize)
+void arm_xor_u32(
+    const uint32_t * pSrcA,
+    const uint32_t * pSrcB,
+          uint32_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int32x4_t vecA, vecB;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q31x4_t vecSrcA, vecSrcB;
+
+    /* Compute 4 outputs at a time */
+    blkCnt = blockSize >> 2;
+
+    while (blkCnt > 0U)
+    {
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+
+        vst1q(pDst, veorq_u32(vecSrcA, vecSrcB) );
+
+        pSrcA += 4;
+        pSrcB += 4;
+        pDst  += 4;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 3;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp32q(blkCnt);
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+        vstrwq_p(pDst, veorq_u32(vecSrcA, vecSrcB), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint32x4_t vecA, vecB;
 
     /* Compute 4 outputs at a time */
     blkCnt = blockSize >> 2U;
 
     while (blkCnt > 0U)
     {
-        vecA = vld1q_s32(pSrcA);
-        vecB = vld1q_s32(pSrcB);
+        vecA = vld1q_u32(pSrcA);
+        vecB = vld1q_u32(pSrcB);
 
-        vst1q_s32(pDst, veorq_s32(vecA, vecB) );
+        vst1q_u32(pDst, veorq_u32(vecA, vecB) );
 
         pSrcA += 4;
         pSrcB += 4;
@@ -91,6 +121,7 @@ void arm_xor_q31(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 
 /**

CMSIS/DSP/Source/BasicMathFunctions/arm_xor_q7.c → CMSIS/DSP/Source/BasicMathFunctions/arm_xor_u8.c

@@ -1,7 +1,7 @@
 /* ----------------------------------------------------------------------
  * Project:      CMSIS DSP Library
- * Title:        arm_xor_q7.c
- * Description:  Q7 bitwise exclusive OR
+ * Title:        arm_xor_u8.c
+ * Description:  uint8_t bitwise exclusive OR
  *
  * $Date:        14 November 2019
  * $Revision:    V1.6.0
@@ -26,12 +26,12 @@
  * limitations under the License.
  */
 
+#include "arm_math.h"
 
 /**
   @ingroup groupMath
  */
 
-
 /**
   @addtogroup Xor
   @{
@@ -46,28 +46,58 @@
   @return        none
  */
 
-#include "arm_math.h"
-
-void arm_xor_q7(
-    const q7_t * pSrcA,
-    const q7_t * pSrcB,
-    q7_t * pDst,
-    uint32_t blockSize)
+void arm_xor_u8(
+    const uint8_t * pSrcA,
+    const uint8_t * pSrcB,
+          uint8_t * pDst,
+          uint32_t blockSize)
 {
     uint32_t blkCnt;      /* Loop counter */
 
-#if defined(ARM_MATH_NEON)
-    int8x16_t vecA, vecB;
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+    q7x16_t vecSrcA, vecSrcB;
+
+    /* Compute 16 outputs at a time */
+    blkCnt = blockSize >> 4;
+
+    while (blkCnt > 0U)
+    {
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+
+        vst1q(pDst, veorq_u8(vecSrcA, vecSrcB) );
+
+        pSrcA += 16;
+        pSrcB += 16;
+        pDst  += 16;
+
+        /* Decrement the loop counter */
+        blkCnt--;
+    }
+
+    /* Tail */
+    blkCnt = blockSize & 0xF;
+
+    if (blkCnt > 0U)
+    {
+        mve_pred16_t p0 = vctp8q(blkCnt);
+        vecSrcA = vld1q(pSrcA);
+        vecSrcB = vld1q(pSrcB);
+        vstrbq_p(pDst, veorq_u8(vecSrcA, vecSrcB), p0);
+    }
+#else
+#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
+    uint8x16_t vecA, vecB;
 
     /* Compute 16 outputs at a time */
     blkCnt = blockSize >> 4U;
 
     while (blkCnt > 0U)
     {
-        vecA = vld1q_s8(pSrcA);
-        vecB = vld1q_s8(pSrcB);
+        vecA = vld1q_u8(pSrcA);
+        vecB = vld1q_u8(pSrcB);
 
-        vst1q_s8(pDst, veorq_s8(vecA, vecB) );
+        vst1q_u8(pDst, veorq_u8(vecA, vecB) );
 
         pSrcA += 16;
         pSrcB += 16;
@@ -91,6 +121,7 @@ void arm_xor_q7(
         /* Decrement the loop counter */
         blkCnt--;
     }
+#endif /* if defined(ARM_MATH_MVEI) */
 }
 
 /**

CMSIS/DSP/Testing/FrameworkInclude/Error.h

@@ -118,7 +118,9 @@ extern void assert_not_empty(unsigned long nb, AnyPattern<q63_t> &p);
 extern void assert_not_empty(unsigned long nb, AnyPattern<q31_t> &p);
 extern void assert_not_empty(unsigned long nb, AnyPattern<q15_t> &p);
 extern void assert_not_empty(unsigned long nb, AnyPattern<q7_t> &p);
-
+extern void assert_not_empty(unsigned long nb, AnyPattern<uint32_t> &p);
+extern void assert_not_empty(unsigned long nb, AnyPattern<uint16_t> &p);
+extern void assert_not_empty(unsigned long nb, AnyPattern<uint8_t> &p);
 
 }
 

CMSIS/DSP/Testing/FrameworkSource/Error.cpp

@@ -143,6 +143,21 @@ void assert_not_empty(unsigned long nb, AnyPattern<q7_t> &p)
   assert_not_empty_generic(nb,p);
 }
 
+void assert_not_empty(unsigned long nb, AnyPattern<uint32_t> &p)
+{
+  assert_not_empty_generic(nb,p);
+}
+
+void assert_not_empty(unsigned long nb, AnyPattern<uint16_t> &p)
+{
+  assert_not_empty_generic(nb,p);
+}
+
+void assert_not_empty(unsigned long nb, AnyPattern<uint8_t> &p)
+{
+  assert_not_empty_generic(nb,p);
+}
+
 void assert_relative_error(unsigned long nb,float64_t &a, float64_t &b, double threshold)
 {
     float64_t rel,delta,average;

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

@@ -11,14 +11,17 @@ class BasicTestsQ15:public Client::Suite
             
             Client::Pattern<q15_t> input1;
             Client::Pattern<q15_t> input2;
+            Client::Pattern<uint16_t> inputLogical1;
+            Client::Pattern<uint16_t> inputLogical2;
 
             Client::LocalPattern<q15_t> output;
             Client::LocalPattern<q63_t> dotOutput;
+            Client::LocalPattern<uint16_t> outputLogical;
 
             // Reference patterns are not loaded when we are in dump mode
             Client::RefPattern<q15_t> ref;
-
             Client::RefPattern<q63_t> dotRef;
+            Client::RefPattern<uint16_t> refLogical;
 
             /* Offset or scale value */
             q15_t scalar;

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

@@ -11,14 +11,17 @@ class BasicTestsQ31:public Client::Suite
             
             Client::Pattern<q31_t> input1;
             Client::Pattern<q31_t> input2;
+            Client::Pattern<uint32_t> inputLogical1;
+            Client::Pattern<uint32_t> inputLogical2;
 
             Client::LocalPattern<q31_t> output;
             Client::LocalPattern<q63_t> dotOutput;
+            Client::LocalPattern<uint32_t> outputLogical;
 
             // Reference patterns are not loaded when we are in dump mode
             Client::RefPattern<q31_t> ref;
-
             Client::RefPattern<q63_t> dotRef;
+            Client::RefPattern<uint32_t> refLogical;
 
             /* Offset or scale value */
             q31_t scalar;

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

@@ -11,14 +11,17 @@ class BasicTestsQ7:public Client::Suite
             
             Client::Pattern<q7_t> input1;
             Client::Pattern<q7_t> input2;
+            Client::Pattern<uint8_t> inputLogical1;
+            Client::Pattern<uint8_t> inputLogical2;
 
             Client::LocalPattern<q7_t> output;
             Client::LocalPattern<q31_t> dotOutput;
+            Client::LocalPattern<uint8_t> outputLogical;
 
             // Reference patterns are not loaded when we are in dump mode
             Client::RefPattern<q7_t> ref;
-
             Client::RefPattern<q31_t> dotRef;
+            Client::RefPattern<uint8_t> refLogical;
 
             /* Offset or scale value */
             q7_t scalar;

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

@@ -23,6 +23,13 @@ const q15_t *inp2=input2.ptr(); \
 q15_t *refp=ref.ptr(); \
 q15_t *outp=output.ptr();
 
+#define GET_LOGICAL_UINT16_PTR() \
+const uint16_t *inp1=inputLogical1.ptr(); \
+const uint16_t *inp2=inputLogical2.ptr(); \
+uint16_t *refp=refLogical.ptr(); \
+uint16_t *outp=outputLogical.ptr();
+
+
     void BasicTestsQ15::test_add_q15()
     {
         GET_Q15_PTR();
@@ -166,51 +173,51 @@ q15_t *outp=output.ptr();
        
     } 
 
-    void BasicTestsQ15::test_and_q15()
+    void BasicTestsQ15::test_and_u16()
     {
-        GET_Q15_PTR();
+        GET_LOGICAL_UINT16_PTR();
 
-        arm_and_q15(inp1,inp2,outp,input1.nbSamples());
+        arm_and_u16(inp1,inp2,outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
 
-        ASSERT_EQ(output,ref);
+        ASSERT_EQ(outputLogical,refLogical);
 
     } 
 
-    void BasicTestsQ15::test_or_q15()
+    void BasicTestsQ15::test_or_u16()
     {
-        GET_Q15_PTR();
+        GET_LOGICAL_UINT16_PTR();
 
-        arm_or_q15(inp1,inp2,outp,input1.nbSamples());
+        arm_or_u16(inp1,inp2,outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
 
-        ASSERT_EQ(output,ref);
+        ASSERT_EQ(outputLogical,refLogical);
 
     } 
 
-    void BasicTestsQ15::test_not_q15()
+    void BasicTestsQ15::test_not_u16()
     {
-        GET_Q15_PTR();
+        GET_LOGICAL_UINT16_PTR();
 
-        arm_not_q15(inp1,outp,input1.nbSamples());
+        arm_not_u16(inp1,outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
 
-        ASSERT_EQ(output,ref);
+        ASSERT_EQ(outputLogical,refLogical);
 
     } 
 
-    void BasicTestsQ15::test_xor_q15()
+    void BasicTestsQ15::test_xor_u16()
     {
-        GET_Q15_PTR();
+        GET_LOGICAL_UINT16_PTR();
 
-        arm_xor_q15(inp1,inp2,outp,input1.nbSamples());
+        arm_xor_u16(inp1,inp2,outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
 
-        ASSERT_EQ(output,ref);
+        ASSERT_EQ(outputLogical,refLogical);
 
     } 
 
@@ -228,7 +235,7 @@ q15_t *outp=output.ptr();
         case BasicTestsQ15::TEST_ADD_Q15_1:
           nb = 7;
           ref.reload(BasicTestsQ15::REF_ADD_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
@@ -236,14 +243,14 @@ q15_t *outp=output.ptr();
         case BasicTestsQ15::TEST_ADD_Q15_2:
           nb = 16;
           ref.reload(BasicTestsQ15::REF_ADD_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_ADD_Q15_3:
           nb = 23;
           ref.reload(BasicTestsQ15::REF_ADD_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
@@ -252,21 +259,21 @@ q15_t *outp=output.ptr();
         case BasicTestsQ15::TEST_SUB_Q15_4:
           nb = 7;
           ref.reload(BasicTestsQ15::REF_SUB_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_SUB_Q15_5:
           nb = 16;
           ref.reload(BasicTestsQ15::REF_SUB_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_SUB_Q15_6:
           nb = 23;
           ref.reload(BasicTestsQ15::REF_SUB_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
@@ -274,21 +281,21 @@ q15_t *outp=output.ptr();
         case BasicTestsQ15::TEST_MULT_Q15_7:
           nb = 7;
           ref.reload(BasicTestsQ15::REF_MULT_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_MULT_Q15_8:
           nb = 16;
           ref.reload(BasicTestsQ15::REF_MULT_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_MULT_Q15_9:
           nb = 23;
           ref.reload(BasicTestsQ15::REF_MULT_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
@@ -296,78 +303,78 @@ q15_t *outp=output.ptr();
         case BasicTestsQ15::TEST_NEGATE_Q15_10:
           nb = 7;
           ref.reload(BasicTestsQ15::REF_NEGATE_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_NEGATE_Q15_11:
           nb = 16;
           ref.reload(BasicTestsQ15::REF_NEGATE_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_NEGATE_Q15_12:
           nb = 23;
           ref.reload(BasicTestsQ15::REF_NEGATE_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           break;
 
         case BasicTestsQ15::TEST_OFFSET_Q15_13:
           nb = 7;
           ref.reload(BasicTestsQ15::REF_OFFSET_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_OFFSET_Q15_14:
           nb = 16;
           ref.reload(BasicTestsQ15::REF_OFFSET_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_OFFSET_Q15_15:
           nb = 23;
           ref.reload(BasicTestsQ15::REF_OFFSET_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           break;
 
         case BasicTestsQ15::TEST_SCALE_Q15_16:
           nb = 7;
           ref.reload(BasicTestsQ15::REF_SCALE_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_SCALE_Q15_17:
           nb = 16;
           ref.reload(BasicTestsQ15::REF_SCALE_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_SCALE_Q15_18:
           nb = 23;
           ref.reload(BasicTestsQ15::REF_SCALE_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           break;
 
         case BasicTestsQ15::TEST_DOT_PROD_Q15_19:
           nb = 7;
           dotRef.reload(BasicTestsQ15::REF_DOT_3_Q15_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_DOT_PROD_Q15_20:
           nb = 16;
           dotRef.reload(BasicTestsQ15::REF_DOT_4N_Q15_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_DOT_PROD_Q15_21:
           nb = 23;
           dotRef.reload(BasicTestsQ15::REF_DOT_4N1_Q15_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
@@ -375,21 +382,21 @@ q15_t *outp=output.ptr();
         case BasicTestsQ15::TEST_ABS_Q15_22:
           nb = 7;
           ref.reload(BasicTestsQ15::REF_ABS_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_ABS_Q15_23:
           nb = 16;
           ref.reload(BasicTestsQ15::REF_ABS_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
         case BasicTestsQ15::TEST_ABS_Q15_24:
           nb = 23;
           ref.reload(BasicTestsQ15::REF_ABS_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
           break;
@@ -398,46 +405,46 @@ q15_t *outp=output.ptr();
           input1.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
           input2.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
           ref.reload(BasicTestsQ15::REF_POSSAT_12_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
         break;
 
         case BasicTestsQ15::TEST_ADD_Q15_26:
           input1.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
           input2.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
           ref.reload(BasicTestsQ15::REF_NEGSAT_13_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
         break;
 
         case BasicTestsQ15::TEST_SUB_Q15_27:
           ref.reload(BasicTestsQ15::REF_POSSAT_14_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
           input2.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
         break;
 
         case BasicTestsQ15::TEST_SUB_Q15_28:
           ref.reload(BasicTestsQ15::REF_NEGSAT_15_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
           input2.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
         break;
 
         case BasicTestsQ15::TEST_MULT_Q15_29:
           ref.reload(BasicTestsQ15::REF_POSSAT_16_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::MAXNEG2_Q15_ID,mgr);
           input2.reload(BasicTestsQ15::MAXNEG2_Q15_ID,mgr);
         break;
 
         case BasicTestsQ15::TEST_NEGATE_Q15_30:
           ref.reload(BasicTestsQ15::REF_POSSAT_17_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::MAXNEG2_Q15_ID,mgr);
           break;
 
         case BasicTestsQ15::TEST_OFFSET_Q15_31:
           ref.reload(BasicTestsQ15::REF_POSSAT_18_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
           /* 0.9 */
           this->scalar = 0x7333;
@@ -445,7 +452,7 @@ q15_t *outp=output.ptr();
 
         case BasicTestsQ15::TEST_OFFSET_Q15_32:
           ref.reload(BasicTestsQ15::REF_NEGSAT_19_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
           /* -0.9 */
           this->scalar = 0x8ccd;
@@ -453,7 +460,7 @@ q15_t *outp=output.ptr();
 
         case BasicTestsQ15::TEST_SCALE_Q15_33:
           ref.reload(BasicTestsQ15::REF_POSSAT_20_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::MAXNEG2_Q15_ID,mgr);
           /* Minus max*/
           this->scalar = 0x8000;
@@ -461,163 +468,163 @@ q15_t *outp=output.ptr();
 
         case BasicTestsQ15::TEST_SHIFT_Q15_34:
           ref.reload(BasicTestsQ15::REF_SHIFT_21_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUTRAND_Q15_ID,mgr);
         break;
 
         case BasicTestsQ15::TEST_SHIFT_Q15_35:
           ref.reload(BasicTestsQ15::REF_SHIFT_POSSAT_22_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
         break;
 
         case BasicTestsQ15::TEST_SHIFT_Q15_36:
           ref.reload(BasicTestsQ15::REF_SHIFT_NEGSAT_23_Q15_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
         break;
 
-	case BasicTestsQ15::TEST_AND_Q15_37:
+        case BasicTestsQ15::TEST_AND_U16_37:
           nb = 7;
-          ref.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
 
-        case BasicTestsQ15::TEST_AND_Q15_38:
+        case BasicTestsQ15::TEST_AND_U16_38:
           nb = 16;
-          ref.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
-        case BasicTestsQ15::TEST_AND_Q15_39:
+        case BasicTestsQ15::TEST_AND_U16_39:
           nb = 23;
-          ref.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
 
-	case BasicTestsQ15::TEST_OR_Q15_40:
+        case BasicTestsQ15::TEST_OR_U16_40:
           nb = 7;
-          ref.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
 
-        case BasicTestsQ15::TEST_OR_Q15_41:
+        case BasicTestsQ15::TEST_OR_U16_41:
           nb = 16;
-          ref.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
-        case BasicTestsQ15::TEST_OR_Q15_42:
+        case BasicTestsQ15::TEST_OR_U16_42:
           nb = 23;
-          ref.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
 
-	case BasicTestsQ15::TEST_NOT_Q15_43:
+        case BasicTestsQ15::TEST_NOT_U16_43:
           nb = 7;
-          ref.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
 
-	case BasicTestsQ15::TEST_NOT_Q15_44:
+        case BasicTestsQ15::TEST_NOT_U16_44:
           nb = 16;
-          ref.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
-        case BasicTestsQ15::TEST_NOT_Q15_45:
+        case BasicTestsQ15::TEST_NOT_U16_45:
           nb = 23;
-          ref.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
 
-	case BasicTestsQ15::TEST_XOR_Q15_46:
+        case BasicTestsQ15::TEST_XOR_U16_46:
           nb = 7;
-          ref.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
 
-        case BasicTestsQ15::TEST_XOR_Q15_47:
+        case BasicTestsQ15::TEST_XOR_U16_47:
           nb = 16;
-          ref.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
-        case BasicTestsQ15::TEST_XOR_Q15_48:
+        case BasicTestsQ15::TEST_XOR_U16_48:
           nb = 23;
-          ref.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
-          input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
-          input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
           break;
 
         case BasicTestsQ15::TEST_ADD_Q15_49:
              ref.reload(BasicTestsQ15::REF_ADD_Q15_ID,mgr,nb);
-             output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+             output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
              input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
              input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
         break;
 
         case BasicTestsQ15::TEST_SUB_Q15_50:
              ref.reload(BasicTestsQ15::REF_SUB_Q15_ID,mgr,nb);
-             output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+             output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
              input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
              input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
         break;
           
         case BasicTestsQ15::TEST_MULT_Q15_51:
           ref.reload(BasicTestsQ15::REF_MULT_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
         break;
           
         case BasicTestsQ15::TEST_NEGATE_Q15_52:
           ref.reload(BasicTestsQ15::REF_NEGATE_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
         break;
           
         case BasicTestsQ15::TEST_OFFSET_Q15_53:
           ref.reload(BasicTestsQ15::REF_OFFSET_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
         break;
           
         case BasicTestsQ15::TEST_SCALE_Q15_54:
           ref.reload(BasicTestsQ15::REF_SCALE_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
         break;
           
         case BasicTestsQ15::TEST_DOT_PROD_Q15_55:
           dotRef.reload(BasicTestsQ15::REF_DOT_LONG_Q15_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
         break;
           
         case BasicTestsQ15::TEST_ABS_Q15_56:
           ref.reload(BasicTestsQ15::REF_ABS_Q15_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
           input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
         break;
@@ -641,6 +648,21 @@ q15_t *outp=output.ptr();
             dotOutput.dump(mgr);
          break;
 
+         case BasicTestsQ15::TEST_AND_U16_37:
+         case BasicTestsQ15::TEST_AND_U16_38:
+         case BasicTestsQ15::TEST_AND_U16_39:
+         case BasicTestsQ15::TEST_OR_U16_40:
+         case BasicTestsQ15::TEST_OR_U16_41:
+         case BasicTestsQ15::TEST_OR_U16_42:
+         case BasicTestsQ15::TEST_NOT_U16_43:
+         case BasicTestsQ15::TEST_NOT_U16_44:
+         case BasicTestsQ15::TEST_NOT_U16_45:
+         case BasicTestsQ15::TEST_XOR_U16_46:
+         case BasicTestsQ15::TEST_XOR_U16_47:
+         case BasicTestsQ15::TEST_XOR_U16_48:
+           outputLogical.dump(mgr);
+         break;
+
          default:
             output.dump(mgr);
        }

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

@@ -21,6 +21,13 @@ const q31_t *inp2=input2.ptr(); \
 q31_t *refp=ref.ptr(); \
 q31_t *outp=output.ptr();
 
+#define GET_LOGICAL_UINT32_PTR() \
+const uint32_t *inp1=inputLogical1.ptr(); \
+const uint32_t *inp2=inputLogical2.ptr(); \
+uint32_t *refp=refLogical.ptr(); \
+uint32_t *outp=outputLogical.ptr();
+
+
     void BasicTestsQ31::test_add_q31()
     {
         GET_Q31_PTR();
@@ -164,51 +171,51 @@ q31_t *outp=output.ptr();
        
     } 
 
-    void BasicTestsQ31::test_and_q31()
+    void BasicTestsQ31::test_and_u32()
     {
-        GET_Q31_PTR();
+        GET_LOGICAL_UINT32_PTR();
 
-        arm_and_q31(inp1,inp2,outp,input1.nbSamples());
+        arm_and_u32(inp1, inp2, outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
 
-        ASSERT_EQ(output,ref);
+        ASSERT_EQ(outputLogical,refLogical);
 
     } 
 
-    void BasicTestsQ31::test_or_q31()
+    void BasicTestsQ31::test_or_u32()
     {
-        GET_Q31_PTR();
+        GET_LOGICAL_UINT32_PTR();
 
-        arm_or_q31(inp1,inp2,outp,input1.nbSamples());
+        arm_or_u32(inp1,inp2,outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
 
-        ASSERT_EQ(output,ref);
+        ASSERT_EQ(outputLogical,refLogical);
 
     } 
 
-    void BasicTestsQ31::test_not_q31()
+    void BasicTestsQ31::test_not_u32()
     {
-        GET_Q31_PTR();
+        GET_LOGICAL_UINT32_PTR();
 
-        arm_not_q31(inp1,outp,input1.nbSamples());
+        arm_not_u32(inp1,outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
 
-        ASSERT_EQ(output,ref);
+        ASSERT_EQ(outputLogical,refLogical);
 
     } 
 
-    void BasicTestsQ31::test_xor_q31()
+    void BasicTestsQ31::test_xor_u32()
     {
-        GET_Q31_PTR();
+        GET_LOGICAL_UINT32_PTR();
 
-        arm_xor_q31(inp1,inp2,outp,input1.nbSamples());
+        arm_xor_u32(inp1,inp2,outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
 
-        ASSERT_EQ(output,ref);
+        ASSERT_EQ(outputLogical,refLogical);
 
     } 
 
@@ -225,7 +232,7 @@ q31_t *outp=output.ptr();
         case BasicTestsQ31::TEST_ADD_Q31_1:
           nb = 3;
           ref.reload(BasicTestsQ31::REF_ADD_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
@@ -233,14 +240,14 @@ q31_t *outp=output.ptr();
         case BasicTestsQ31::TEST_ADD_Q31_2:
           nb = 8;
           ref.reload(BasicTestsQ31::REF_ADD_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_ADD_Q31_3:
           nb = 11;
           ref.reload(BasicTestsQ31::REF_ADD_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
@@ -249,21 +256,21 @@ q31_t *outp=output.ptr();
         case BasicTestsQ31::TEST_SUB_Q31_4:
           nb = 3;
           ref.reload(BasicTestsQ31::REF_SUB_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_SUB_Q31_5:
           nb = 8;
           ref.reload(BasicTestsQ31::REF_SUB_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_SUB_Q31_6:
           nb = 11;
           ref.reload(BasicTestsQ31::REF_SUB_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
@@ -271,21 +278,21 @@ q31_t *outp=output.ptr();
         case BasicTestsQ31::TEST_MULT_Q31_7:
           nb = 3;
           ref.reload(BasicTestsQ31::REF_MULT_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_MULT_Q31_8:
           nb = 8;
           ref.reload(BasicTestsQ31::REF_MULT_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_MULT_Q31_9:
           nb = 11;
           ref.reload(BasicTestsQ31::REF_MULT_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
@@ -293,78 +300,78 @@ q31_t *outp=output.ptr();
         case BasicTestsQ31::TEST_NEGATE_Q31_10:
           nb = 3;
           ref.reload(BasicTestsQ31::REF_NEGATE_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_NEGATE_Q31_11:
           nb = 8;
           ref.reload(BasicTestsQ31::REF_NEGATE_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_NEGATE_Q31_12:
           nb = 11;
           ref.reload(BasicTestsQ31::REF_NEGATE_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           break;
 
         case BasicTestsQ31::TEST_OFFSET_Q31_13:
           nb = 3;
           ref.reload(BasicTestsQ31::REF_OFFSET_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_OFFSET_Q31_14:
           nb = 8;
           ref.reload(BasicTestsQ31::REF_OFFSET_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_OFFSET_Q31_15:
           nb = 11;
           ref.reload(BasicTestsQ31::REF_OFFSET_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           break;
 
         case BasicTestsQ31::TEST_SCALE_Q31_16:
           nb = 3;
           ref.reload(BasicTestsQ31::REF_SCALE_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_SCALE_Q31_17:
           nb = 8;
           ref.reload(BasicTestsQ31::REF_SCALE_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_SCALE_Q31_18:
           nb = 11;
           ref.reload(BasicTestsQ31::REF_SCALE_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           break;
 
         case BasicTestsQ31::TEST_DOT_PROD_Q31_19:
           nb = 3;
           dotRef.reload(BasicTestsQ31::REF_DOT_3_Q31_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_DOT_PROD_Q31_20:
           nb = 8;
           dotRef.reload(BasicTestsQ31::REF_DOT_4N_Q31_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_DOT_PROD_Q31_21:
           nb = 11;
           dotRef.reload(BasicTestsQ31::REF_DOT_4N1_Q31_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
@@ -372,21 +379,21 @@ q31_t *outp=output.ptr();
         case BasicTestsQ31::TEST_ABS_Q31_22:
           nb = 3;
           ref.reload(BasicTestsQ31::REF_ABS_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_ABS_Q31_23:
           nb = 8;
           ref.reload(BasicTestsQ31::REF_ABS_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
         case BasicTestsQ31::TEST_ABS_Q31_24:
           nb = 11;
           ref.reload(BasicTestsQ31::REF_ABS_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
           break;
@@ -395,46 +402,46 @@ q31_t *outp=output.ptr();
           input1.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
           input2.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
           ref.reload(BasicTestsQ31::REF_POSSAT_12_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
         break;
 
         case BasicTestsQ31::TEST_ADD_Q31_26:
           input1.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
           input2.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
           ref.reload(BasicTestsQ31::REF_NEGSAT_13_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
         break;
 
         case BasicTestsQ31::TEST_SUB_Q31_27:
           ref.reload(BasicTestsQ31::REF_POSSAT_14_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
           input2.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
         break;
 
         case BasicTestsQ31::TEST_SUB_Q31_28:
           ref.reload(BasicTestsQ31::REF_NEGSAT_15_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
           input2.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
         break;
 
         case BasicTestsQ31::TEST_MULT_Q31_29:
           ref.reload(BasicTestsQ31::REF_POSSAT_16_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::MAXNEG2_Q31_ID,mgr);
           input2.reload(BasicTestsQ31::MAXNEG2_Q31_ID,mgr);
         break;
 
         case BasicTestsQ31::TEST_NEGATE_Q31_30:
           ref.reload(BasicTestsQ31::REF_POSSAT_17_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::MAXNEG2_Q31_ID,mgr);
           break;
 
         case BasicTestsQ31::TEST_OFFSET_Q31_31:
           ref.reload(BasicTestsQ31::REF_POSSAT_18_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
           /* 0.9 */
           this->scalar = 0x73333333;
@@ -442,7 +449,7 @@ q31_t *outp=output.ptr();
 
         case BasicTestsQ31::TEST_OFFSET_Q31_32:
           ref.reload(BasicTestsQ31::REF_NEGSAT_19_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
           /* -0.9 */
           this->scalar = 0x8ccccccd;
@@ -450,7 +457,7 @@ q31_t *outp=output.ptr();
 
         case BasicTestsQ31::TEST_SCALE_Q31_33:
           ref.reload(BasicTestsQ31::REF_POSSAT_20_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::MAXNEG2_Q31_ID,mgr);
           /* Minus max*/
           this->scalar = 0x80000000;
@@ -458,163 +465,163 @@ q31_t *outp=output.ptr();
 
         case BasicTestsQ31::TEST_SHIFT_Q31_34:
           ref.reload(BasicTestsQ31::REF_SHIFT_21_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUTRAND_Q31_ID,mgr);
         break;
 
         case BasicTestsQ31::TEST_SHIFT_Q31_35:
           ref.reload(BasicTestsQ31::REF_SHIFT_POSSAT_22_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
         break;
 
         case BasicTestsQ31::TEST_SHIFT_Q31_36:
           ref.reload(BasicTestsQ31::REF_SHIFT_NEGSAT_23_Q31_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
         break;
 
-        case BasicTestsQ31::TEST_AND_Q31_37:
+        case BasicTestsQ31::TEST_AND_U32_37:
           nb = 3;
-          ref.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
 
-        case BasicTestsQ31::TEST_AND_Q31_38:
+        case BasicTestsQ31::TEST_AND_U32_38:
           nb = 8;
-          ref.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
-        case BasicTestsQ31::TEST_AND_Q31_39:
+        case BasicTestsQ31::TEST_AND_U32_39:
           nb = 11;
-          ref.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
 
-        case BasicTestsQ31::TEST_OR_Q31_40:
+        case BasicTestsQ31::TEST_OR_U32_40:
           nb = 3;
-          ref.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
 
-        case BasicTestsQ31::TEST_OR_Q31_41:
+        case BasicTestsQ31::TEST_OR_U32_41:
           nb = 8;
-          ref.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
-        case BasicTestsQ31::TEST_OR_Q31_42:
+        case BasicTestsQ31::TEST_OR_U32_42:
           nb = 11;
-          ref.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
 
-        case BasicTestsQ31::TEST_NOT_Q31_43:
+        case BasicTestsQ31::TEST_NOT_U32_43:
           nb = 3;
-          ref.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
 
-        case BasicTestsQ31::TEST_NOT_Q31_44:
+        case BasicTestsQ31::TEST_NOT_U32_44:
           nb = 8;
-          ref.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
-        case BasicTestsQ31::TEST_NOT_Q31_45:
+        case BasicTestsQ31::TEST_NOT_U32_45:
           nb = 11;
-          ref.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
 
-        case BasicTestsQ31::TEST_XOR_Q31_46:
+        case BasicTestsQ31::TEST_XOR_U32_46:
           nb = 3;
-          ref.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
 
-        case BasicTestsQ31::TEST_XOR_Q31_47:
+        case BasicTestsQ31::TEST_XOR_U32_47:
           nb = 8;
-          ref.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
-        case BasicTestsQ31::TEST_XOR_Q31_48:
+        case BasicTestsQ31::TEST_XOR_U32_48:
           nb = 11;
-          ref.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
-          input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
-          input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
           break;
 
         case BasicTestsQ31::TEST_ADD_Q31_49:
           ref.reload(BasicTestsQ31::REF_ADD_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
         break;
         
         case BasicTestsQ31::TEST_SUB_Q31_50:
           ref.reload(BasicTestsQ31::REF_SUB_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
         break;
         
         case BasicTestsQ31::TEST_MULT_Q31_51:
           ref.reload(BasicTestsQ31::REF_MULT_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
         break;
         
         case BasicTestsQ31::TEST_NEGATE_Q31_52:
           ref.reload(BasicTestsQ31::REF_NEGATE_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
         break;
         
         case BasicTestsQ31::TEST_OFFSET_Q31_53:
           ref.reload(BasicTestsQ31::REF_OFFSET_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
         break;
         
         case BasicTestsQ31::TEST_SCALE_Q31_54:
           ref.reload(BasicTestsQ31::REF_SCALE_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
         break;
         
         case BasicTestsQ31::TEST_DOT_PROD_Q31_55:
           dotRef.reload(BasicTestsQ31::REF_DOT_LONG_Q31_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
         break;
         
         case BasicTestsQ31::TEST_ABS_Q31_56:
           ref.reload(BasicTestsQ31::REF_ABS_Q31_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
           input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
         break;
@@ -639,6 +646,21 @@ q31_t *outp=output.ptr();
             dotOutput.dump(mgr);
          break;
 
+         case BasicTestsQ31::TEST_AND_U32_37:
+         case BasicTestsQ31::TEST_AND_U32_38:
+         case BasicTestsQ31::TEST_AND_U32_39:
+         case BasicTestsQ31::TEST_OR_U32_40:
+         case BasicTestsQ31::TEST_OR_U32_41:
+         case BasicTestsQ31::TEST_OR_U32_42:
+         case BasicTestsQ31::TEST_NOT_U32_43:
+         case BasicTestsQ31::TEST_NOT_U32_44:
+         case BasicTestsQ31::TEST_NOT_U32_45:
+         case BasicTestsQ31::TEST_XOR_U32_46:
+         case BasicTestsQ31::TEST_XOR_U32_47:
+         case BasicTestsQ31::TEST_XOR_U32_48:
+            outputLogical.dump(mgr);
+         break;
+
          default:
             output.dump(mgr);
        }

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

@@ -15,6 +15,12 @@ const q7_t *inp2=input2.ptr(); \
 q7_t *refp=ref.ptr(); \
 q7_t *outp=output.ptr();
 
+#define GET_LOGICAL_UINT8_PTR() \
+const uint8_t *inp1=inputLogical1.ptr(); \
+const uint8_t *inp2=inputLogical2.ptr(); \
+uint8_t *refp=refLogical.ptr(); \
+uint8_t *outp=outputLogical.ptr();
+
     void BasicTestsQ7::test_add_q7()
     {
         GET_Q7_PTR();
@@ -178,51 +184,54 @@ q7_t *outp=output.ptr();
        
     } 
 
-    void BasicTestsQ7::test_and_q7()
+    void BasicTestsQ7::test_and_u8()
     {
-        GET_Q7_PTR();
 
-        arm_and_q7(inp1,inp2,outp,input1.nbSamples());
+            GET_LOGICAL_UINT8_PTR();
+
+
+        arm_and_u8(inp1,inp2,outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
+
+        ASSERT_EQ(outputLogical, refLogical);
 
-        ASSERT_EQ(output,ref);
 
     } 
 
-    void BasicTestsQ7::test_or_q7()
+    void BasicTestsQ7::test_or_u8()
     {
-        GET_Q7_PTR();
+        GET_LOGICAL_UINT8_PTR();
 
-        arm_or_q7(inp1,inp2,outp,input1.nbSamples());
+        arm_or_u8(inp1,inp2,outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
 
-        ASSERT_EQ(output,ref);
+        ASSERT_EQ(outputLogical, refLogical);
 
     } 
 
-    void BasicTestsQ7::test_not_q7()
+    void BasicTestsQ7::test_not_u8()
     {
-        GET_Q7_PTR();
+        GET_LOGICAL_UINT8_PTR();
 
-        arm_not_q7(inp1,outp,input1.nbSamples());
+        arm_not_u8(inp1,outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
 
-        ASSERT_EQ(output,ref);
+        ASSERT_EQ(outputLogical, refLogical);
 
     } 
 
-    void BasicTestsQ7::test_xor_q7()
+    void BasicTestsQ7::test_xor_u8()
     {
-        GET_Q7_PTR();
+        GET_LOGICAL_UINT8_PTR();
 
-        arm_xor_q7(inp1,inp2,outp,input1.nbSamples());
+        arm_xor_u8(inp1,inp2,outp,inputLogical1.nbSamples());
         
-        ASSERT_EMPTY_TAIL(output);
+        ASSERT_EMPTY_TAIL(outputLogical);
 
-        ASSERT_EQ(output,ref);
+        ASSERT_EQ(outputLogical, refLogical);
 
     } 
 
@@ -239,7 +248,7 @@ q7_t *outp=output.ptr();
         case BasicTestsQ7::TEST_ADD_Q7_1:
           nb = 15;
           ref.reload(BasicTestsQ7::REF_ADD_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
@@ -247,14 +256,14 @@ q7_t *outp=output.ptr();
         case BasicTestsQ7::TEST_ADD_Q7_2:
           nb = 32;
           ref.reload(BasicTestsQ7::REF_ADD_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_ADD_Q7_3:
           nb = 47;
           ref.reload(BasicTestsQ7::REF_ADD_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
@@ -263,21 +272,21 @@ q7_t *outp=output.ptr();
         case BasicTestsQ7::TEST_SUB_Q7_4:
           nb = 15;
           ref.reload(BasicTestsQ7::REF_SUB_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_SUB_Q7_5:
           nb = 32;
           ref.reload(BasicTestsQ7::REF_SUB_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_SUB_Q7_6:
           nb = 47;
           ref.reload(BasicTestsQ7::REF_SUB_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
@@ -285,21 +294,21 @@ q7_t *outp=output.ptr();
         case BasicTestsQ7::TEST_MULT_SHORT_Q7_7:
           nb = 15;
           ref.reload(BasicTestsQ7::REF_MULT_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_MULT_Q7_8:
           nb = 32;
           ref.reload(BasicTestsQ7::REF_MULT_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_MULT_Q7_9:
           nb = 47;
           ref.reload(BasicTestsQ7::REF_MULT_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
@@ -307,78 +316,78 @@ q7_t *outp=output.ptr();
         case BasicTestsQ7::TEST_NEGATE_Q7_10:
           nb = 15;
           ref.reload(BasicTestsQ7::REF_NEGATE_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_NEGATE_Q7_11:
           nb = 32;
           ref.reload(BasicTestsQ7::REF_NEGATE_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_NEGATE_Q7_12:
           nb = 47;
           ref.reload(BasicTestsQ7::REF_NEGATE_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           break;
 
         case BasicTestsQ7::TEST_OFFSET_Q7_13:
           nb = 15;
           ref.reload(BasicTestsQ7::REF_OFFSET_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_OFFSET_Q7_14:
           nb = 32;
           ref.reload(BasicTestsQ7::REF_OFFSET_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_OFFSET_Q7_15:
           nb = 47;
           ref.reload(BasicTestsQ7::REF_OFFSET_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           break;
 
         case BasicTestsQ7::TEST_SCALE_Q7_16:
           nb = 15;
           ref.reload(BasicTestsQ7::REF_SCALE_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_SCALE_Q7_17:
           nb = 32;
           ref.reload(BasicTestsQ7::REF_SCALE_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_SCALE_Q7_18:
           nb = 47;
           ref.reload(BasicTestsQ7::REF_SCALE_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           break;
 
         case BasicTestsQ7::TEST_DOT_PROD_Q7_19:
           nb = 15;
           dotRef.reload(BasicTestsQ7::REF_DOT_3_Q7_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_DOT_PROD_Q7_20:
           nb = 32;
           dotRef.reload(BasicTestsQ7::REF_DOT_4N_Q7_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_DOT_PROD_Q7_21:
           nb = 47;
           dotRef.reload(BasicTestsQ7::REF_DOT_4N1_Q7_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
@@ -386,21 +395,21 @@ q7_t *outp=output.ptr();
         case BasicTestsQ7::TEST_ABS_Q7_22:
           nb = 15;
           ref.reload(BasicTestsQ7::REF_ABS_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_ABS_Q7_23:
           nb = 32;
           ref.reload(BasicTestsQ7::REF_ABS_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
         case BasicTestsQ7::TEST_ABS_Q7_24:
           nb = 47;
           ref.reload(BasicTestsQ7::REF_ABS_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
           break;
@@ -409,46 +418,46 @@ q7_t *outp=output.ptr();
           input1.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
           input2.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
           ref.reload(BasicTestsQ7::REF_POSSAT_12_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
         break;
 
         case BasicTestsQ7::TEST_ADD_Q7_26:
           input1.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
           input2.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
           ref.reload(BasicTestsQ7::REF_NEGSAT_13_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
         break;
 
         case BasicTestsQ7::TEST_SUB_Q7_27:
           ref.reload(BasicTestsQ7::REF_POSSAT_14_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
           input2.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
         break;
 
         case BasicTestsQ7::TEST_SUB_Q7_28:
           ref.reload(BasicTestsQ7::REF_NEGSAT_15_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
           input2.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
         break;
 
         case BasicTestsQ7::TEST_MULT_Q7_29:
           ref.reload(BasicTestsQ7::REF_POSSAT_16_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::MAXNEG2_Q7_ID,mgr);
           input2.reload(BasicTestsQ7::MAXNEG2_Q7_ID,mgr);
         break;
 
         case BasicTestsQ7::TEST_NEGATE_Q7_30:
           ref.reload(BasicTestsQ7::REF_POSSAT_17_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::MAXNEG2_Q7_ID,mgr);
           break;
 
         case BasicTestsQ7::TEST_OFFSET_Q7_31:
           ref.reload(BasicTestsQ7::REF_POSSAT_18_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
           /* 0.9 */
           this->scalar = 0x73;
@@ -456,7 +465,7 @@ q7_t *outp=output.ptr();
 
         case BasicTestsQ7::TEST_OFFSET_Q7_32:
           ref.reload(BasicTestsQ7::REF_NEGSAT_19_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
           /* -0.9 */
           this->scalar = 0x8d;
@@ -464,7 +473,7 @@ q7_t *outp=output.ptr();
 
         case BasicTestsQ7::TEST_SCALE_Q7_33:
           ref.reload(BasicTestsQ7::REF_POSSAT_20_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::MAXNEG2_Q7_ID,mgr);
           /* Minus max*/
           this->scalar = 0x80;
@@ -472,163 +481,163 @@ q7_t *outp=output.ptr();
 
         case BasicTestsQ7::TEST_SHIFT_Q7_34:
           ref.reload(BasicTestsQ7::REF_SHIFT_21_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUTRAND_Q7_ID,mgr);
         break;
 
         case BasicTestsQ7::TEST_SHIFT_Q7_35:
           ref.reload(BasicTestsQ7::REF_SHIFT_POSSAT_22_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
         break;
 
         case BasicTestsQ7::TEST_SHIFT_Q7_36:
           ref.reload(BasicTestsQ7::REF_SHIFT_NEGSAT_23_Q7_ID,mgr);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
         break;
 
-        case BasicTestsQ7::TEST_AND_Q7_37:
+        case BasicTestsQ7::TEST_AND_U8_37:
           nb = 15;
-          ref.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
 
-        case BasicTestsQ7::TEST_AND_Q7_38:
+        case BasicTestsQ7::TEST_AND_U8_38:
           nb = 32;
-          ref.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
-        case BasicTestsQ7::TEST_AND_Q7_39:
+        case BasicTestsQ7::TEST_AND_U8_39:
           nb = 47;
-          ref.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
 
-        case BasicTestsQ7::TEST_OR_Q7_40:
+        case BasicTestsQ7::TEST_OR_U8_40:
           nb = 15;
-          ref.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
 
-        case BasicTestsQ7::TEST_OR_Q7_41:
+        case BasicTestsQ7::TEST_OR_U8_41:
           nb = 32;
-          ref.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
-        case BasicTestsQ7::TEST_OR_Q7_42:
+        case BasicTestsQ7::TEST_OR_U8_42:
           nb = 47;
-          ref.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
 
-        case BasicTestsQ7::TEST_NOT_Q7_43:
+        case BasicTestsQ7::TEST_NOT_U8_43:
           nb = 15;
-          ref.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
 
-        case BasicTestsQ7::TEST_NOT_Q7_44:
+        case BasicTestsQ7::TEST_NOT_U8_44:
           nb = 32;
-          ref.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
-        case BasicTestsQ7::TEST_NOT_Q7_45:
+        case BasicTestsQ7::TEST_NOT_U8_45:
           nb = 47;
-          ref.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
 
-        case BasicTestsQ7::TEST_XOR_Q7_46:
+        case BasicTestsQ7::TEST_XOR_U8_46:
           nb = 15;
-          ref.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
 
-        case BasicTestsQ7::TEST_XOR_Q7_47:
+        case BasicTestsQ7::TEST_XOR_U8_47:
           nb = 32;
-          ref.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
-        case BasicTestsQ7::TEST_XOR_Q7_48:
+        case BasicTestsQ7::TEST_XOR_U8_48:
           nb = 47;
-          ref.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
-          input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
-          input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
+          refLogical.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb);
+          outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
+          inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
+          inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
           break;
 
         case BasicTestsQ7::TEST_ADD_Q7_49:
           ref.reload(BasicTestsQ7::REF_ADD_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
         break;
         
         case BasicTestsQ7::TEST_SUB_Q7_50:
           ref.reload(BasicTestsQ7::REF_SUB_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
         break;
         
         case BasicTestsQ7::TEST_MULT_Q7_51:
           ref.reload(BasicTestsQ7::REF_MULT_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
         break;
         
         case BasicTestsQ7::TEST_NEGATE_Q7_52:
           ref.reload(BasicTestsQ7::REF_NEGATE_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
         break;
         
         case BasicTestsQ7::TEST_OFFSET_Q7_53:
           ref.reload(BasicTestsQ7::REF_OFFSET_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
         break;
         
         case BasicTestsQ7::TEST_SCALE_Q7_54:
           ref.reload(BasicTestsQ7::REF_SCALE_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
         break;
         
         case BasicTestsQ7::TEST_DOT_PROD_Q7_55:
           dotRef.reload(BasicTestsQ7::REF_DOT_LONG_Q7_ID,mgr);
-          dotOutput.create(dotRef.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          dotOutput.create(dotRef.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
         break;
         
         case BasicTestsQ7::TEST_ABS_Q7_56:
           ref.reload(BasicTestsQ7::REF_ABS_Q7_ID,mgr,nb);
-          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr);
+          output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
           input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
           input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
         break;
@@ -652,6 +661,21 @@ q7_t *outp=output.ptr();
             dotOutput.dump(mgr);
          break;
 
+         case BasicTestsQ7::TEST_AND_U8_37:
+         case BasicTestsQ7::TEST_AND_U8_38:
+         case BasicTestsQ7::TEST_AND_U8_39:
+         case BasicTestsQ7::TEST_OR_U8_40:
+         case BasicTestsQ7::TEST_OR_U8_41:
+         case BasicTestsQ7::TEST_OR_U8_42:
+         case BasicTestsQ7::TEST_NOT_U8_43:
+         case BasicTestsQ7::TEST_NOT_U8_44:
+         case BasicTestsQ7::TEST_NOT_U8_45:
+         case BasicTestsQ7::TEST_XOR_U8_46:
+         case BasicTestsQ7::TEST_XOR_U8_47:
+         case BasicTestsQ7::TEST_XOR_U8_48:
+            outputLogical.dump(mgr);
+         break;
+         
          default:
             output.dump(mgr);
        }

CMSIS/DSP/Testing/desc.txt

@@ -694,7 +694,7 @@ group Root {
               Pattern REF_NOT_Q31_ID : Not26_s32.txt
               Pattern REF_XOR_Q31_ID : Xor27_s32.txt
 
-              Output  OUT_SAMPLES_Q31_ID : Output
+              Output  OUT_SAMPLES_ID : Output
               Output  OUT_STATE_Q31_ID : State
    
               Functions {
@@ -749,21 +749,21 @@ group Root {
                 Test shift pos sat:test_shift_q31
                 Test shift neg sat:test_shift_q31
 
-                Test nb=3    arm_and_q31:test_and_q31
-                Test nb=4n   arm_and_q31:test_and_q31
-                Test nb=4n+3 arm_and_q31:test_and_q31
+                Test nb=3    arm_and_u32:test_and_u32
+                Test nb=4n   arm_and_u32:test_and_u32
+                Test nb=4n+3 arm_and_u32:test_and_u32
             
-                Test nb=3    arm_or_q31:test_or_q31
-                Test nb=4n   arm_or_q31:test_or_q31
-                Test nb=4n+3 arm_or_q31:test_or_q31
+                Test nb=3    arm_or_u32:test_or_u32
+                Test nb=4n   arm_or_u32:test_or_u32
+                Test nb=4n+3 arm_or_u32:test_or_u32
             
-                Test nb=3    arm_not_q31:test_not_q31
-                Test nb=4n   arm_not_q31:test_not_q31
-                Test nb=4n+3 arm_not_q31:test_not_q31
+                Test nb=3    arm_not_u32:test_not_u32
+                Test nb=4n   arm_not_u32:test_not_u32
+                Test nb=4n+3 arm_not_u32:test_not_u32
             
-                Test nb=3    arm_xor_q31:test_xor_q31
-                Test nb=4n   arm_xor_q31:test_xor_q31
-                Test nb=4n+3 arm_xor_q31:test_xor_q31
+                Test nb=3    arm_xor_u32:test_xor_u32
+                Test nb=4n   arm_xor_u32:test_xor_u32
+                Test nb=4n+3 arm_xor_u32:test_xor_u32
 
                 Test long    arm_add_q31:test_add_q31
                 Test long    arm_sub_q31:test_sub_q31
@@ -823,7 +823,7 @@ group Root {
               Pattern REF_NOT_Q15_ID : Not26_s16.txt
               Pattern REF_XOR_Q15_ID : Xor27_s16.txt
 
-              Output  OUT_SAMPLES_Q15_ID : Output
+              Output  OUT_SAMPLES_ID : Output
               Output  OUT_STATE_Q15_ID : State
    
               Functions {
@@ -878,21 +878,21 @@ group Root {
                 Test shift pos sat:test_shift_q15
                 Test shift neg sat:test_shift_q15
 
-                Test nb=7    arm_and_q15:test_and_q15
-                Test nb=8n   arm_and_q15:test_and_q15
-                Test nb=8n+7 arm_and_q15:test_and_q15
+                Test nb=7    arm_and_u16:test_and_u16
+                Test nb=8n   arm_and_u16:test_and_u16
+                Test nb=8n+7 arm_and_u16:test_and_u16
             
-                Test nb=7    arm_or_q15:test_or_q15
-                Test nb=8n   arm_or_q15:test_or_q15
-                Test nb=8n+7 arm_or_q15:test_or_q15
+                Test nb=7    arm_or_u16:test_or_u16
+                Test nb=8n   arm_or_u16:test_or_u16
+                Test nb=8n+7 arm_or_u16:test_or_u16
             
-                Test nb=7    arm_not_q15:test_not_q15
-                Test nb=8n   arm_not_q15:test_not_q15
-                Test nb=8n+7 arm_not_q15:test_not_q15
+                Test nb=7    arm_not_u16:test_not_u16
+                Test nb=8n   arm_not_u16:test_not_u16
+                Test nb=8n+7 arm_not_u16:test_not_u16
             
-                Test nb=7    arm_xor_q15:test_xor_q15
-                Test nb=8n   arm_xor_q15:test_xor_q15
-                Test nb=8n+7 arm_xor_q15:test_xor_q15
+                Test nb=7    arm_xor_u16:test_xor_u16
+                Test nb=8n   arm_xor_u16:test_xor_u16
+                Test nb=8n+7 arm_xor_u16:test_xor_u16
 
                 Test long    arm_add_q15:test_add_q15
                 Test long    arm_sub_q15:test_sub_q15
@@ -952,7 +952,7 @@ group Root {
               Pattern REF_NOT_Q7_ID : Not26_s8.txt
               Pattern REF_XOR_Q7_ID : Xor27_s8.txt
 
-              Output  OUT_SAMPLES_Q7_ID : Output
+              Output  OUT_SAMPLES_ID : Output
               Output  OUT_STATE_Q7_ID : State
    
               Functions {
@@ -1007,21 +1007,21 @@ group Root {
                 Test shift pos sat:test_shift_q7
                 Test shift neg sat:test_shift_q7
 
-                Test nb=15     arm_and_q7:test_and_q7
-                Test nb=16n    arm_and_q7:test_and_q7
-                Test nb=16n+15 arm_and_q7:test_and_q7
+                Test nb=15     arm_and_u8:test_and_u8
+                Test nb=16n    arm_and_u8:test_and_u8
+                Test nb=16n+15 arm_and_u8:test_and_u8
              
-                Test nb=15     arm_or_q7:test_or_q7
-                Test nb=16n    arm_or_q7:test_or_q7
-                Test nb=16n+15 arm_or_q7:test_or_q7
+                Test nb=15     arm_or_u8:test_or_u8
+                Test nb=16n    arm_or_u8:test_or_u8
+                Test nb=16n+15 arm_or_u8:test_or_u8
              
-                Test nb=15     arm_not_q7:test_not_q7
-                Test nb=16n    arm_not_q7:test_not_q7
-                Test nb=16n+15 arm_not_q7:test_not_q7
+                Test nb=15     arm_not_u8:test_not_u8
+                Test nb=16n    arm_not_u8:test_not_u8
+                Test nb=16n+15 arm_not_u8:test_not_u8
              
-                Test nb=15     arm_xor_q7:test_xor_q7
-                Test nb=16n    arm_xor_q7:test_xor_q7
-                Test nb=16n+15 arm_xor_q7:test_xor_q7
+                Test nb=15     arm_xor_u8:test_xor_u8
+                Test nb=16n    arm_xor_u8:test_xor_u8
+                Test nb=16n+15 arm_xor_u8:test_xor_u8
 
                 Test long    arm_add_q7:test_add_q7
                 Test long    arm_sub_q7:test_sub_q7