dengzhihao
/
CMSIS-DSP
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source
pull/19/head
ClaudioMartino 6 years ago committed by Christophe Favergeon
parent 0e438b58f6
commit 64d43685fb
22 changed files with 1097 additions and 637 deletions
Show Stats Download Patch File Download Diff File

112
Include/arm_math.h
Unescape Escape View File

@ -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);
/**

61
Source/BasicMathFunctions/arm_and_q15.c → Source/BasicMathFunctions/arm_and_u16.c
Unescape Escape View File

@ -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) */
}
/**

58
Source/BasicMathFunctions/arm_and_q31.c → Source/BasicMathFunctions/arm_and_u32.c
Unescape Escape View File

@ -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) */
}
/**

58
Source/BasicMathFunctions/arm_and_q7.c → Source/BasicMathFunctions/arm_and_u8.c
Unescape Escape View File

@ -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) */
}
/**

54
Source/BasicMathFunctions/arm_not_q15.c → Source/BasicMathFunctions/arm_not_u16.c
Unescape Escape View File

@ -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) */
}
/**

52
Source/BasicMathFunctions/arm_not_q31.c → Source/BasicMathFunctions/arm_not_u32.c
Unescape Escape View File

@ -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) */
}
/**

52
Source/BasicMathFunctions/arm_not_q7.c → Source/BasicMathFunctions/arm_not_u8.c
Unescape Escape View File

@ -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) */
}
/**

61
Source/BasicMathFunctions/arm_or_q15.c → Source/BasicMathFunctions/arm_or_u16.c
Unescape Escape View File

@ -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) */
}
/**

59
Source/BasicMathFunctions/arm_or_q31.c → Source/BasicMathFunctions/arm_or_u32.c
Unescape Escape View File

@ -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

59
Source/BasicMathFunctions/arm_or_q7.c → Source/BasicMathFunctions/arm_or_u8.c
Unescape Escape View File

@ -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

62
Source/BasicMathFunctions/arm_xor_q15.c → Source/BasicMathFunctions/arm_xor_u16.c
Unescape Escape View File

@ -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) */
}
/**

61
Source/BasicMathFunctions/arm_xor_q31.c → Source/BasicMathFunctions/arm_xor_u32.c
Unescape Escape View File

@ -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) */
}
/**

61
Source/BasicMathFunctions/arm_xor_q7.c → Source/BasicMathFunctions/arm_xor_u8.c
Unescape Escape View File

@ -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) */
}
/**

4
Testing/FrameworkInclude/Error.h
Unescape Escape View File

@ -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);
}

15
Testing/FrameworkSource/Error.cpp
Unescape Escape View File

@ -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;

5
Testing/Include/Tests/BasicTestsQ15.h
Unescape Escape View File

@ -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;

5
Testing/Include/Tests/BasicTestsQ31.h
Unescape Escape View File

@ -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;

5
Testing/Include/Tests/BasicTestsQ7.h
Unescape Escape View File

@ -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;

270
Testing/Source/Tests/BasicTestsQ15.cpp
Unescape Escape View File

@ -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);
}

270
Testing/Source/Tests/BasicTestsQ31.cpp
Unescape Escape View File

@ -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);
}

272
Testing/Source/Tests/BasicTestsQ7.cpp
Unescape Escape View File

@ -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);
}

78
Testing/desc.txt
Unescape Escape View File

@ -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

Write Preview
Loading…
Cancel
Save