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

90
Include/arm_math.h
Unescape Escape View File

@ -2097,10 +2097,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 * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_and_q15( void arm_and_u16(
const q15_t * pSrcA, const uint16_t * pSrcA,
const q15_t * pSrcB, const uint16_t * pSrcB,
q15_t * pDst, uint16_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**
@ -2111,10 +2111,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 * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_and_q31( void arm_and_u32(
const q31_t * pSrcA, const uint32_t * pSrcA,
const q31_t * pSrcB, const uint32_t * pSrcB,
q31_t * pDst, uint32_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**
@ -2125,10 +2125,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 * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_and_q7( void arm_and_u8(
const q7_t * pSrcA, const uint8_t * pSrcA,
const q7_t * pSrcB, const uint8_t * pSrcB,
q7_t * pDst, uint8_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**
@ -2139,10 +2139,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 * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_or_q15( void arm_or_u16(
const q15_t * pSrcA, const uint16_t * pSrcA,
const q15_t * pSrcB, const uint16_t * pSrcB,
q15_t * pDst, uint16_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**
@ -2153,10 +2153,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 * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_or_q31( void arm_or_u32(
const q31_t * pSrcA, const uint32_t * pSrcA,
const q31_t * pSrcB, const uint32_t * pSrcB,
q31_t * pDst, uint32_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**
@ -2167,10 +2167,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 * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_or_q7( void arm_or_u8(
const q7_t * pSrcA, const uint8_t * pSrcA,
const q7_t * pSrcB, const uint8_t * pSrcB,
q7_t * pDst, uint8_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**
@ -2180,9 +2180,9 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
* @param[in] blockSize number of samples in each vector * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_not_q15( void arm_not_u16(
const q15_t * pSrc, const uint16_t * pSrc,
q15_t * pDst, uint16_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**
@ -2192,9 +2192,9 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
* @param[in] blockSize number of samples in each vector * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_not_q31( void arm_not_u32(
const q31_t * pSrc, const uint32_t * pSrc,
q31_t * pDst, uint32_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**
@ -2204,9 +2204,9 @@ __STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
* @param[in] blockSize number of samples in each vector * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_not_q7( void arm_not_u8(
const q7_t * pSrc, const uint8_t * pSrc,
q7_t * pDst, uint8_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**
@ -2217,10 +2217,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 * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_xor_q15( void arm_xor_u16(
const q15_t * pSrcA, const uint16_t * pSrcA,
const q15_t * pSrcB, const uint16_t * pSrcB,
q15_t * pDst, uint16_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**
@ -2231,10 +2231,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 * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_xor_q31( void arm_xor_u32(
const q31_t * pSrcA, const uint32_t * pSrcA,
const q31_t * pSrcB, const uint32_t * pSrcB,
q31_t * pDst, uint32_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**
@ -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 * @param[in] blockSize number of samples in each vector
* @return none * @return none
*/ */
void arm_xor_q7( void arm_xor_u8(
const q7_t * pSrcA, const uint8_t * pSrcA,
const q7_t * pSrcB, const uint8_t * pSrcB,
q7_t * pDst, uint8_t * pDst,
uint32_t blockSize); uint32_t blockSize);
/** /**

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

@ -1,7 +1,7 @@
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* Project: CMSIS DSP Library * Project: CMSIS DSP Library
* Title: arm_and_q15.c * Title: arm_and_u16.c
* Description: Q15 bitwise AND * Description: uint16_t bitwise AND
* *
* $Date: 14 November 2019 * $Date: 14 November 2019
* $Revision: V1.6.0 * $Revision: V1.6.0
@ -28,18 +28,16 @@
#include "arm_math.h" #include "arm_math.h"
/** /**
@ingroup groupMath @ingroup groupMath
*/ */
/** /**
@defgroup And Vector bitwise AND @defgroup And Vector bitwise AND
Compute the logical 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 @return none
*/ */
void arm_and_q15( void arm_and_u16(
const q15_t * pSrcA, const uint16_t * pSrcA,
const q15_t * pSrcB, const uint16_t * pSrcB,
q15_t * pDst, uint16_t * pDst,
uint32_t blockSize) uint32_t blockSize)
{ {
uint32_t blkCnt; /* Loop counter */ uint32_t blkCnt; /* Loop counter */
#if defined(ARM_MATH_NEON) #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
int16x8_t vecA, vecB; 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 */ /* Compute 8 outputs at a time */
blkCnt = blockSize >> 3U; blkCnt = blockSize >> 3U;
while (blkCnt > 0U) while (blkCnt > 0U)
{ {
vecA = vld1q_s16(pSrcA); vecA = vld1q_u16(pSrcA);
vecB = vld1q_s16(pSrcB); vecB = vld1q_u16(pSrcB);
vst1q_s16(pDst, vandq_s16(vecA, vecB) ); vst1q_u16(pDst, vandq_u16(vecA, vecB) );
pSrcA += 8; pSrcA += 8;
pSrcB += 8; pSrcB += 8;
@ -99,6 +129,7 @@ void arm_and_q15(
/* Decrement the loop counter */ /* Decrement the loop counter */
blkCnt--; blkCnt--;
} }
#endif /* if defined(ARM_MATH_MVEI) */
} }
/** /**

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

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

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

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

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

@ -1,7 +1,7 @@
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* Project: CMSIS DSP Library * Project: CMSIS DSP Library
* Title: arm_not_q15.c * Title: arm_not_u16.c
* Description: Q15 bitwise NOT * Description: uint16_t bitwise NOT
* *
* $Date: 14 November 2019 * $Date: 14 November 2019
* $Revision: V1.6.0 * $Revision: V1.6.0
@ -28,18 +28,16 @@
#include "arm_math.h" #include "arm_math.h"
/** /**
@ingroup groupMath @ingroup groupMath
*/ */
/** /**
@defgroup Not Vector bitwise NOT @defgroup Not Vector bitwise NOT
Compute the logical 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 @return none
*/ */
void arm_not_q15( void arm_not_u16(
const q15_t * pSrc, const uint16_t * pSrc,
q15_t * pDst, uint16_t * pDst,
uint32_t blockSize) uint32_t blockSize)
{ {
uint32_t blkCnt; /* Loop counter */ uint32_t blkCnt; /* Loop counter */
#if defined(ARM_MATH_NEON) #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
int16x8_t inV; 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 */ /* Compute 8 outputs at a time */
blkCnt = blockSize >> 3U; blkCnt = blockSize >> 3U;
while (blkCnt > 0U) 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; pSrc += 8;
pDst += 8; pDst += 8;
@ -95,6 +122,7 @@ void arm_not_q15(
/* Decrement the loop counter */ /* Decrement the loop counter */
blkCnt--; blkCnt--;
} }
#endif /* if defined(ARM_MATH_MVEI) */
} }
/** /**

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

@ -1,7 +1,7 @@
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* Project: CMSIS DSP Library * Project: CMSIS DSP Library
* Title: arm_not_q31.c * Title: arm_not_u32.c
* Description: Q31 bitwise NOT * Description: uint32_t bitwise NOT
* *
* $Date: 14 November 2019 * $Date: 14 November 2019
* $Revision: V1.6.0 * $Revision: V1.6.0
@ -28,12 +28,10 @@
#include "arm_math.h" #include "arm_math.h"
/** /**
@ingroup groupMath @ingroup groupMath
*/ */
/** /**
@addtogroup Not @addtogroup Not
@{ @{
@ -47,24 +45,53 @@
@return none @return none
*/ */
void arm_not_q31( void arm_not_u32(
const q31_t * pSrc, const uint32_t * pSrc,
q31_t * pDst, uint32_t * pDst,
uint32_t blockSize) uint32_t blockSize)
{ {
uint32_t blkCnt; /* Loop counter */ uint32_t blkCnt; /* Loop counter */
#if defined(ARM_MATH_NEON) #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
int32x4_t inV; 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 */ /* Compute 4 outputs at a time */
blkCnt = blockSize >> 2U; blkCnt = blockSize >> 2U;
while (blkCnt > 0U) 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; pSrc += 4;
pDst += 4; pDst += 4;
@ -87,6 +114,7 @@ void arm_not_q31(
/* Decrement the loop counter */ /* Decrement the loop counter */
blkCnt--; blkCnt--;
} }
#endif /* if defined(ARM_MATH_MVEI) */
} }
/** /**

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

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

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

@ -1,7 +1,7 @@
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* Project: CMSIS DSP Library * Project: CMSIS DSP Library
* Title: arm_or_q15.c * Title: arm_or_u16.c
* Description: Q15 bitwise inclusive OR * Description: uint16_t bitwise inclusive OR
* *
* $Date: 14 November 2019 * $Date: 14 November 2019
* $Revision: V1.6.0 * $Revision: V1.6.0
@ -28,18 +28,16 @@
#include "arm_math.h" #include "arm_math.h"
/** /**
@ingroup groupMath @ingroup groupMath
*/ */
/** /**
@defgroup Or Vector bitwise inclusive OR @defgroup Or Vector bitwise inclusive OR
Compute the logical bitwise 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 @return none
*/ */
void arm_or_q15( void arm_or_u16(
const q15_t * pSrcA, const uint16_t * pSrcA,
const q15_t * pSrcB, const uint16_t * pSrcB,
q15_t * pDst, uint16_t * pDst,
uint32_t blockSize) uint32_t blockSize)
{ {
uint32_t blkCnt; /* Loop counter */ uint32_t blkCnt; /* Loop counter */
#if defined(ARM_MATH_NEON) #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
int16x8_t vecA, vecB; 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 */ /* Compute 8 outputs at a time */
blkCnt = blockSize >> 3U; blkCnt = blockSize >> 3U;
while (blkCnt > 0U) while (blkCnt > 0U)
{ {
vecA = vld1q_s16(pSrcA); vecA = vld1q_u16(pSrcA);
vecB = vld1q_s16(pSrcB); vecB = vld1q_u16(pSrcB);
vst1q_s16(pDst, vorrq_s16(vecA, vecB) ); vst1q_u16(pDst, vorrq_u16(vecA, vecB) );
pSrcA += 8; pSrcA += 8;
pSrcB += 8; pSrcB += 8;
@ -99,6 +129,7 @@ void arm_or_q15(
/* Decrement the loop counter */ /* Decrement the loop counter */
blkCnt--; blkCnt--;
} }
#endif /* if defined(ARM_MATH_MVEI) */
} }
/** /**

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

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

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

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

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

@ -1,7 +1,7 @@
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* Project: CMSIS DSP Library * Project: CMSIS DSP Library
* Title: arm_xor_q15.c * Title: arm_xor_u16.c
* Description: Q15 bitwise exclusive OR * Description: uint16_t bitwise exclusive OR
* *
* $Date: 14 November 2019 * $Date: 14 November 2019
* $Revision: V1.6.0 * $Revision: V1.6.0
@ -26,6 +26,7 @@
* limitations under the License. * limitations under the License.
*/ */
#include "arm_math.h"
/** /**
@ingroup groupMath @ingroup groupMath
@ -36,7 +37,7 @@
Compute the logical bitwise XOR. 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 @return none
*/ */
#include "arm_math.h" void arm_xor_u16(
const uint16_t * pSrcA,
void arm_xor_q15( const uint16_t * pSrcB,
const q15_t * pSrcA, uint16_t * pDst,
const q15_t * pSrcB,
q15_t * pDst,
uint32_t blockSize) uint32_t blockSize)
{ {
uint32_t blkCnt; /* Loop counter */ uint32_t blkCnt; /* Loop counter */
#if defined(ARM_MATH_NEON) #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
int16x8_t vecA, vecB; 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 */ /* Compute 8 outputs at a time */
blkCnt = blockSize >> 3U; blkCnt = blockSize >> 3U;
while (blkCnt > 0U) while (blkCnt > 0U)
{ {
vecA = vld1q_s16(pSrcA); vecA = vld1q_u16(pSrcA);
vecB = vld1q_s16(pSrcB); vecB = vld1q_u16(pSrcB);
vst1q_s16(pDst, veorq_s16(vecA, vecB) ); vst1q_u16(pDst, veorq_u16(vecA, vecB) );
pSrcA += 8; pSrcA += 8;
pSrcB += 8; pSrcB += 8;
@ -98,6 +129,7 @@ void arm_xor_q15(
/* Decrement the loop counter */ /* Decrement the loop counter */
blkCnt--; blkCnt--;
} }
#endif /* if defined(ARM_MATH_MVEI) */
} }
/** /**

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

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

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

@ -1,7 +1,7 @@
/* ---------------------------------------------------------------------- /* ----------------------------------------------------------------------
* Project: CMSIS DSP Library * Project: CMSIS DSP Library
* Title: arm_xor_q7.c * Title: arm_xor_u8.c
* Description: Q7 bitwise exclusive OR * Description: uint8_t bitwise exclusive OR
* *
* $Date: 14 November 2019 * $Date: 14 November 2019
* $Revision: V1.6.0 * $Revision: V1.6.0
@ -26,12 +26,12 @@
* limitations under the License. * limitations under the License.
*/ */
#include "arm_math.h"
/** /**
@ingroup groupMath @ingroup groupMath
*/ */
/** /**
@addtogroup Xor @addtogroup Xor
@{ @{
@ -46,28 +46,58 @@
@return none @return none
*/ */
#include "arm_math.h" void arm_xor_u8(
const uint8_t * pSrcA,
void arm_xor_q7( const uint8_t * pSrcB,
const q7_t * pSrcA, uint8_t * pDst,
const q7_t * pSrcB,
q7_t * pDst,
uint32_t blockSize) uint32_t blockSize)
{ {
uint32_t blkCnt; /* Loop counter */ uint32_t blkCnt; /* Loop counter */
#if defined(ARM_MATH_NEON) #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
int8x16_t vecA, vecB; 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 */ /* Compute 16 outputs at a time */
blkCnt = blockSize >> 4U; blkCnt = blockSize >> 4U;
while (blkCnt > 0U) while (blkCnt > 0U)
{ {
vecA = vld1q_s8(pSrcA); vecA = vld1q_u8(pSrcA);
vecB = vld1q_s8(pSrcB); vecB = vld1q_u8(pSrcB);
vst1q_s8(pDst, veorq_s8(vecA, vecB) ); vst1q_u8(pDst, veorq_u8(vecA, vecB) );
pSrcA += 16; pSrcA += 16;
pSrcB += 16; pSrcB += 16;
@ -91,6 +121,7 @@ void arm_xor_q7(
/* Decrement the loop counter */ /* Decrement the loop counter */
blkCnt--; 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<q31_t> &p);
extern void assert_not_empty(unsigned long nb, AnyPattern<q15_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<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); 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) void assert_relative_error(unsigned long nb,float64_t &a, float64_t &b, double threshold)
{ {
float64_t rel,delta,average; 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> input1;
Client::Pattern<q15_t> input2; Client::Pattern<q15_t> input2;
Client::Pattern<uint16_t> inputLogical1;
Client::Pattern<uint16_t> inputLogical2;
Client::LocalPattern<q15_t> output; Client::LocalPattern<q15_t> output;
Client::LocalPattern<q63_t> dotOutput; Client::LocalPattern<q63_t> dotOutput;
Client::LocalPattern<uint16_t> outputLogical;
// Reference patterns are not loaded when we are in dump mode // Reference patterns are not loaded when we are in dump mode
Client::RefPattern<q15_t> ref; Client::RefPattern<q15_t> ref;
Client::RefPattern<q63_t> dotRef; Client::RefPattern<q63_t> dotRef;
Client::RefPattern<uint16_t> refLogical;
/* Offset or scale value */ /* Offset or scale value */
q15_t scalar; 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> input1;
Client::Pattern<q31_t> input2; Client::Pattern<q31_t> input2;
Client::Pattern<uint32_t> inputLogical1;
Client::Pattern<uint32_t> inputLogical2;
Client::LocalPattern<q31_t> output; Client::LocalPattern<q31_t> output;
Client::LocalPattern<q63_t> dotOutput; Client::LocalPattern<q63_t> dotOutput;
Client::LocalPattern<uint32_t> outputLogical;
// Reference patterns are not loaded when we are in dump mode // Reference patterns are not loaded when we are in dump mode
Client::RefPattern<q31_t> ref; Client::RefPattern<q31_t> ref;
Client::RefPattern<q63_t> dotRef; Client::RefPattern<q63_t> dotRef;
Client::RefPattern<uint32_t> refLogical;
/* Offset or scale value */ /* Offset or scale value */
q31_t scalar; 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> input1;
Client::Pattern<q7_t> input2; Client::Pattern<q7_t> input2;
Client::Pattern<uint8_t> inputLogical1;
Client::Pattern<uint8_t> inputLogical2;
Client::LocalPattern<q7_t> output; Client::LocalPattern<q7_t> output;
Client::LocalPattern<q31_t> dotOutput; Client::LocalPattern<q31_t> dotOutput;
Client::LocalPattern<uint8_t> outputLogical;
// Reference patterns are not loaded when we are in dump mode // Reference patterns are not loaded when we are in dump mode
Client::RefPattern<q7_t> ref; Client::RefPattern<q7_t> ref;
Client::RefPattern<q31_t> dotRef; Client::RefPattern<q31_t> dotRef;
Client::RefPattern<uint8_t> refLogical;
/* Offset or scale value */ /* Offset or scale value */
q7_t scalar; 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 *refp=ref.ptr(); \
q15_t *outp=output.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() void BasicTestsQ15::test_add_q15()
{ {
GET_Q15_PTR(); 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: case BasicTestsQ15::TEST_ADD_Q15_1:
nb = 7; nb = 7;
ref.reload(BasicTestsQ15::REF_ADD_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
@ -236,14 +243,14 @@ q15_t *outp=output.ptr();
case BasicTestsQ15::TEST_ADD_Q15_2: case BasicTestsQ15::TEST_ADD_Q15_2:
nb = 16; nb = 16;
ref.reload(BasicTestsQ15::REF_ADD_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_ADD_Q15_3: case BasicTestsQ15::TEST_ADD_Q15_3:
nb = 23; nb = 23;
ref.reload(BasicTestsQ15::REF_ADD_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
@ -252,21 +259,21 @@ q15_t *outp=output.ptr();
case BasicTestsQ15::TEST_SUB_Q15_4: case BasicTestsQ15::TEST_SUB_Q15_4:
nb = 7; nb = 7;
ref.reload(BasicTestsQ15::REF_SUB_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_SUB_Q15_5: case BasicTestsQ15::TEST_SUB_Q15_5:
nb = 16; nb = 16;
ref.reload(BasicTestsQ15::REF_SUB_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_SUB_Q15_6: case BasicTestsQ15::TEST_SUB_Q15_6:
nb = 23; nb = 23;
ref.reload(BasicTestsQ15::REF_SUB_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
@ -274,21 +281,21 @@ q15_t *outp=output.ptr();
case BasicTestsQ15::TEST_MULT_Q15_7: case BasicTestsQ15::TEST_MULT_Q15_7:
nb = 7; nb = 7;
ref.reload(BasicTestsQ15::REF_MULT_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_MULT_Q15_8: case BasicTestsQ15::TEST_MULT_Q15_8:
nb = 16; nb = 16;
ref.reload(BasicTestsQ15::REF_MULT_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_MULT_Q15_9: case BasicTestsQ15::TEST_MULT_Q15_9:
nb = 23; nb = 23;
ref.reload(BasicTestsQ15::REF_MULT_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
@ -296,78 +303,78 @@ q15_t *outp=output.ptr();
case BasicTestsQ15::TEST_NEGATE_Q15_10: case BasicTestsQ15::TEST_NEGATE_Q15_10:
nb = 7; nb = 7;
ref.reload(BasicTestsQ15::REF_NEGATE_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_NEGATE_Q15_11: case BasicTestsQ15::TEST_NEGATE_Q15_11:
nb = 16; nb = 16;
ref.reload(BasicTestsQ15::REF_NEGATE_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_NEGATE_Q15_12: case BasicTestsQ15::TEST_NEGATE_Q15_12:
nb = 23; nb = 23;
ref.reload(BasicTestsQ15::REF_NEGATE_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_OFFSET_Q15_13: case BasicTestsQ15::TEST_OFFSET_Q15_13:
nb = 7; nb = 7;
ref.reload(BasicTestsQ15::REF_OFFSET_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_OFFSET_Q15_14: case BasicTestsQ15::TEST_OFFSET_Q15_14:
nb = 16; nb = 16;
ref.reload(BasicTestsQ15::REF_OFFSET_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_OFFSET_Q15_15: case BasicTestsQ15::TEST_OFFSET_Q15_15:
nb = 23; nb = 23;
ref.reload(BasicTestsQ15::REF_OFFSET_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_SCALE_Q15_16: case BasicTestsQ15::TEST_SCALE_Q15_16:
nb = 7; nb = 7;
ref.reload(BasicTestsQ15::REF_SCALE_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_SCALE_Q15_17: case BasicTestsQ15::TEST_SCALE_Q15_17:
nb = 16; nb = 16;
ref.reload(BasicTestsQ15::REF_SCALE_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_SCALE_Q15_18: case BasicTestsQ15::TEST_SCALE_Q15_18:
nb = 23; nb = 23;
ref.reload(BasicTestsQ15::REF_SCALE_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_DOT_PROD_Q15_19: case BasicTestsQ15::TEST_DOT_PROD_Q15_19:
nb = 7; nb = 7;
dotRef.reload(BasicTestsQ15::REF_DOT_3_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_DOT_PROD_Q15_20: case BasicTestsQ15::TEST_DOT_PROD_Q15_20:
nb = 16; nb = 16;
dotRef.reload(BasicTestsQ15::REF_DOT_4N_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_DOT_PROD_Q15_21: case BasicTestsQ15::TEST_DOT_PROD_Q15_21:
nb = 23; nb = 23;
dotRef.reload(BasicTestsQ15::REF_DOT_4N1_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
@ -375,21 +382,21 @@ q15_t *outp=output.ptr();
case BasicTestsQ15::TEST_ABS_Q15_22: case BasicTestsQ15::TEST_ABS_Q15_22:
nb = 7; nb = 7;
ref.reload(BasicTestsQ15::REF_ABS_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_ABS_Q15_23: case BasicTestsQ15::TEST_ABS_Q15_23:
nb = 16; nb = 16;
ref.reload(BasicTestsQ15::REF_ABS_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_ABS_Q15_24: case BasicTestsQ15::TEST_ABS_Q15_24:
nb = 23; nb = 23;
ref.reload(BasicTestsQ15::REF_ABS_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
@ -398,46 +405,46 @@ q15_t *outp=output.ptr();
input1.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr); input1.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
input2.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr); input2.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
ref.reload(BasicTestsQ15::REF_POSSAT_12_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; break;
case BasicTestsQ15::TEST_ADD_Q15_26: case BasicTestsQ15::TEST_ADD_Q15_26:
input1.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr); input1.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
input2.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr); input2.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
ref.reload(BasicTestsQ15::REF_NEGSAT_13_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; break;
case BasicTestsQ15::TEST_SUB_Q15_27: case BasicTestsQ15::TEST_SUB_Q15_27:
ref.reload(BasicTestsQ15::REF_POSSAT_14_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
input2.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr); input2.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
break; break;
case BasicTestsQ15::TEST_SUB_Q15_28: case BasicTestsQ15::TEST_SUB_Q15_28:
ref.reload(BasicTestsQ15::REF_NEGSAT_15_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
input2.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr); input2.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
break; break;
case BasicTestsQ15::TEST_MULT_Q15_29: case BasicTestsQ15::TEST_MULT_Q15_29:
ref.reload(BasicTestsQ15::REF_POSSAT_16_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::MAXNEG2_Q15_ID,mgr);
input2.reload(BasicTestsQ15::MAXNEG2_Q15_ID,mgr); input2.reload(BasicTestsQ15::MAXNEG2_Q15_ID,mgr);
break; break;
case BasicTestsQ15::TEST_NEGATE_Q15_30: case BasicTestsQ15::TEST_NEGATE_Q15_30:
ref.reload(BasicTestsQ15::REF_POSSAT_17_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::MAXNEG2_Q15_ID,mgr);
break; break;
case BasicTestsQ15::TEST_OFFSET_Q15_31: case BasicTestsQ15::TEST_OFFSET_Q15_31:
ref.reload(BasicTestsQ15::REF_POSSAT_18_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
/* 0.9 */ /* 0.9 */
this->scalar = 0x7333; this->scalar = 0x7333;
@ -445,7 +452,7 @@ q15_t *outp=output.ptr();
case BasicTestsQ15::TEST_OFFSET_Q15_32: case BasicTestsQ15::TEST_OFFSET_Q15_32:
ref.reload(BasicTestsQ15::REF_NEGSAT_19_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
/* -0.9 */ /* -0.9 */
this->scalar = 0x8ccd; this->scalar = 0x8ccd;
@ -453,7 +460,7 @@ q15_t *outp=output.ptr();
case BasicTestsQ15::TEST_SCALE_Q15_33: case BasicTestsQ15::TEST_SCALE_Q15_33:
ref.reload(BasicTestsQ15::REF_POSSAT_20_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::MAXNEG2_Q15_ID,mgr);
/* Minus max*/ /* Minus max*/
this->scalar = 0x8000; this->scalar = 0x8000;
@ -461,163 +468,163 @@ q15_t *outp=output.ptr();
case BasicTestsQ15::TEST_SHIFT_Q15_34: case BasicTestsQ15::TEST_SHIFT_Q15_34:
ref.reload(BasicTestsQ15::REF_SHIFT_21_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::INPUTRAND_Q15_ID,mgr);
break; break;
case BasicTestsQ15::TEST_SHIFT_Q15_35: case BasicTestsQ15::TEST_SHIFT_Q15_35:
ref.reload(BasicTestsQ15::REF_SHIFT_POSSAT_22_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::MAXPOS_Q15_ID,mgr);
break; break;
case BasicTestsQ15::TEST_SHIFT_Q15_36: case BasicTestsQ15::TEST_SHIFT_Q15_36:
ref.reload(BasicTestsQ15::REF_SHIFT_NEGSAT_23_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::MAXNEG_Q15_ID,mgr);
break; break;
case BasicTestsQ15::TEST_AND_Q15_37: case BasicTestsQ15::TEST_AND_U16_37:
nb = 7; nb = 7;
ref.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_AND_Q15_38: case BasicTestsQ15::TEST_AND_U16_38:
nb = 16; nb = 16;
ref.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_AND_Q15_39: case BasicTestsQ15::TEST_AND_U16_39:
nb = 23; nb = 23;
ref.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_AND_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_OR_Q15_40: case BasicTestsQ15::TEST_OR_U16_40:
nb = 7; nb = 7;
ref.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_OR_Q15_41: case BasicTestsQ15::TEST_OR_U16_41:
nb = 16; nb = 16;
ref.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_OR_Q15_42: case BasicTestsQ15::TEST_OR_U16_42:
nb = 23; nb = 23;
ref.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_OR_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_NOT_Q15_43: case BasicTestsQ15::TEST_NOT_U16_43:
nb = 7; nb = 7;
ref.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_NOT_Q15_44: case BasicTestsQ15::TEST_NOT_U16_44:
nb = 16; nb = 16;
ref.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_NOT_Q15_45: case BasicTestsQ15::TEST_NOT_U16_45:
nb = 23; nb = 23;
ref.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_NOT_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_XOR_Q15_46: case BasicTestsQ15::TEST_XOR_U16_46:
nb = 7; nb = 7;
ref.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_XOR_Q15_47: case BasicTestsQ15::TEST_XOR_U16_47:
nb = 16; nb = 16;
ref.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_XOR_Q15_48: case BasicTestsQ15::TEST_XOR_U16_48:
nb = 23; nb = 23;
ref.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb); refLogical.reload(BasicTestsQ15::REF_XOR_Q15_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ15::OUT_SAMPLES_Q15_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ15::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb); inputLogical1.reload(BasicTestsQ15::INPUT1_BITWISE_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb); inputLogical2.reload(BasicTestsQ15::INPUT2_BITWISE_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_ADD_Q15_49: case BasicTestsQ15::TEST_ADD_Q15_49:
ref.reload(BasicTestsQ15::REF_ADD_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_SUB_Q15_50: case BasicTestsQ15::TEST_SUB_Q15_50:
ref.reload(BasicTestsQ15::REF_SUB_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_MULT_Q15_51: case BasicTestsQ15::TEST_MULT_Q15_51:
ref.reload(BasicTestsQ15::REF_MULT_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_NEGATE_Q15_52: case BasicTestsQ15::TEST_NEGATE_Q15_52:
ref.reload(BasicTestsQ15::REF_NEGATE_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_OFFSET_Q15_53: case BasicTestsQ15::TEST_OFFSET_Q15_53:
ref.reload(BasicTestsQ15::REF_OFFSET_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_SCALE_Q15_54: case BasicTestsQ15::TEST_SCALE_Q15_54:
ref.reload(BasicTestsQ15::REF_SCALE_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_DOT_PROD_Q15_55: case BasicTestsQ15::TEST_DOT_PROD_Q15_55:
dotRef.reload(BasicTestsQ15::REF_DOT_LONG_Q15_ID,mgr); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
case BasicTestsQ15::TEST_ABS_Q15_56: case BasicTestsQ15::TEST_ABS_Q15_56:
ref.reload(BasicTestsQ15::REF_ABS_Q15_ID,mgr,nb); 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); input1.reload(BasicTestsQ15::INPUT1_Q15_ID,mgr,nb);
input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb); input2.reload(BasicTestsQ15::INPUT2_Q15_ID,mgr,nb);
break; break;
@ -641,6 +648,21 @@ q15_t *outp=output.ptr();
dotOutput.dump(mgr); dotOutput.dump(mgr);
break; 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: default:
output.dump(mgr); 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 *refp=ref.ptr(); \
q31_t *outp=output.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() void BasicTestsQ31::test_add_q31()
{ {
GET_Q31_PTR(); 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: case BasicTestsQ31::TEST_ADD_Q31_1:
nb = 3; nb = 3;
ref.reload(BasicTestsQ31::REF_ADD_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
@ -233,14 +240,14 @@ q31_t *outp=output.ptr();
case BasicTestsQ31::TEST_ADD_Q31_2: case BasicTestsQ31::TEST_ADD_Q31_2:
nb = 8; nb = 8;
ref.reload(BasicTestsQ31::REF_ADD_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_ADD_Q31_3: case BasicTestsQ31::TEST_ADD_Q31_3:
nb = 11; nb = 11;
ref.reload(BasicTestsQ31::REF_ADD_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
@ -249,21 +256,21 @@ q31_t *outp=output.ptr();
case BasicTestsQ31::TEST_SUB_Q31_4: case BasicTestsQ31::TEST_SUB_Q31_4:
nb = 3; nb = 3;
ref.reload(BasicTestsQ31::REF_SUB_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_SUB_Q31_5: case BasicTestsQ31::TEST_SUB_Q31_5:
nb = 8; nb = 8;
ref.reload(BasicTestsQ31::REF_SUB_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_SUB_Q31_6: case BasicTestsQ31::TEST_SUB_Q31_6:
nb = 11; nb = 11;
ref.reload(BasicTestsQ31::REF_SUB_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
@ -271,21 +278,21 @@ q31_t *outp=output.ptr();
case BasicTestsQ31::TEST_MULT_Q31_7: case BasicTestsQ31::TEST_MULT_Q31_7:
nb = 3; nb = 3;
ref.reload(BasicTestsQ31::REF_MULT_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_MULT_Q31_8: case BasicTestsQ31::TEST_MULT_Q31_8:
nb = 8; nb = 8;
ref.reload(BasicTestsQ31::REF_MULT_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_MULT_Q31_9: case BasicTestsQ31::TEST_MULT_Q31_9:
nb = 11; nb = 11;
ref.reload(BasicTestsQ31::REF_MULT_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
@ -293,78 +300,78 @@ q31_t *outp=output.ptr();
case BasicTestsQ31::TEST_NEGATE_Q31_10: case BasicTestsQ31::TEST_NEGATE_Q31_10:
nb = 3; nb = 3;
ref.reload(BasicTestsQ31::REF_NEGATE_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_NEGATE_Q31_11: case BasicTestsQ31::TEST_NEGATE_Q31_11:
nb = 8; nb = 8;
ref.reload(BasicTestsQ31::REF_NEGATE_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_NEGATE_Q31_12: case BasicTestsQ31::TEST_NEGATE_Q31_12:
nb = 11; nb = 11;
ref.reload(BasicTestsQ31::REF_NEGATE_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_OFFSET_Q31_13: case BasicTestsQ31::TEST_OFFSET_Q31_13:
nb = 3; nb = 3;
ref.reload(BasicTestsQ31::REF_OFFSET_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_OFFSET_Q31_14: case BasicTestsQ31::TEST_OFFSET_Q31_14:
nb = 8; nb = 8;
ref.reload(BasicTestsQ31::REF_OFFSET_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_OFFSET_Q31_15: case BasicTestsQ31::TEST_OFFSET_Q31_15:
nb = 11; nb = 11;
ref.reload(BasicTestsQ31::REF_OFFSET_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_SCALE_Q31_16: case BasicTestsQ31::TEST_SCALE_Q31_16:
nb = 3; nb = 3;
ref.reload(BasicTestsQ31::REF_SCALE_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_SCALE_Q31_17: case BasicTestsQ31::TEST_SCALE_Q31_17:
nb = 8; nb = 8;
ref.reload(BasicTestsQ31::REF_SCALE_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_SCALE_Q31_18: case BasicTestsQ31::TEST_SCALE_Q31_18:
nb = 11; nb = 11;
ref.reload(BasicTestsQ31::REF_SCALE_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_DOT_PROD_Q31_19: case BasicTestsQ31::TEST_DOT_PROD_Q31_19:
nb = 3; nb = 3;
dotRef.reload(BasicTestsQ31::REF_DOT_3_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_DOT_PROD_Q31_20: case BasicTestsQ31::TEST_DOT_PROD_Q31_20:
nb = 8; nb = 8;
dotRef.reload(BasicTestsQ31::REF_DOT_4N_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_DOT_PROD_Q31_21: case BasicTestsQ31::TEST_DOT_PROD_Q31_21:
nb = 11; nb = 11;
dotRef.reload(BasicTestsQ31::REF_DOT_4N1_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
@ -372,21 +379,21 @@ q31_t *outp=output.ptr();
case BasicTestsQ31::TEST_ABS_Q31_22: case BasicTestsQ31::TEST_ABS_Q31_22:
nb = 3; nb = 3;
ref.reload(BasicTestsQ31::REF_ABS_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_ABS_Q31_23: case BasicTestsQ31::TEST_ABS_Q31_23:
nb = 8; nb = 8;
ref.reload(BasicTestsQ31::REF_ABS_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_ABS_Q31_24: case BasicTestsQ31::TEST_ABS_Q31_24:
nb = 11; nb = 11;
ref.reload(BasicTestsQ31::REF_ABS_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
@ -395,46 +402,46 @@ q31_t *outp=output.ptr();
input1.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr); input1.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
input2.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr); input2.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
ref.reload(BasicTestsQ31::REF_POSSAT_12_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; break;
case BasicTestsQ31::TEST_ADD_Q31_26: case BasicTestsQ31::TEST_ADD_Q31_26:
input1.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr); input1.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
input2.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr); input2.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
ref.reload(BasicTestsQ31::REF_NEGSAT_13_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; break;
case BasicTestsQ31::TEST_SUB_Q31_27: case BasicTestsQ31::TEST_SUB_Q31_27:
ref.reload(BasicTestsQ31::REF_POSSAT_14_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
input2.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr); input2.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
break; break;
case BasicTestsQ31::TEST_SUB_Q31_28: case BasicTestsQ31::TEST_SUB_Q31_28:
ref.reload(BasicTestsQ31::REF_NEGSAT_15_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
input2.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr); input2.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
break; break;
case BasicTestsQ31::TEST_MULT_Q31_29: case BasicTestsQ31::TEST_MULT_Q31_29:
ref.reload(BasicTestsQ31::REF_POSSAT_16_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::MAXNEG2_Q31_ID,mgr);
input2.reload(BasicTestsQ31::MAXNEG2_Q31_ID,mgr); input2.reload(BasicTestsQ31::MAXNEG2_Q31_ID,mgr);
break; break;
case BasicTestsQ31::TEST_NEGATE_Q31_30: case BasicTestsQ31::TEST_NEGATE_Q31_30:
ref.reload(BasicTestsQ31::REF_POSSAT_17_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::MAXNEG2_Q31_ID,mgr);
break; break;
case BasicTestsQ31::TEST_OFFSET_Q31_31: case BasicTestsQ31::TEST_OFFSET_Q31_31:
ref.reload(BasicTestsQ31::REF_POSSAT_18_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
/* 0.9 */ /* 0.9 */
this->scalar = 0x73333333; this->scalar = 0x73333333;
@ -442,7 +449,7 @@ q31_t *outp=output.ptr();
case BasicTestsQ31::TEST_OFFSET_Q31_32: case BasicTestsQ31::TEST_OFFSET_Q31_32:
ref.reload(BasicTestsQ31::REF_NEGSAT_19_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
/* -0.9 */ /* -0.9 */
this->scalar = 0x8ccccccd; this->scalar = 0x8ccccccd;
@ -450,7 +457,7 @@ q31_t *outp=output.ptr();
case BasicTestsQ31::TEST_SCALE_Q31_33: case BasicTestsQ31::TEST_SCALE_Q31_33:
ref.reload(BasicTestsQ31::REF_POSSAT_20_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::MAXNEG2_Q31_ID,mgr);
/* Minus max*/ /* Minus max*/
this->scalar = 0x80000000; this->scalar = 0x80000000;
@ -458,163 +465,163 @@ q31_t *outp=output.ptr();
case BasicTestsQ31::TEST_SHIFT_Q31_34: case BasicTestsQ31::TEST_SHIFT_Q31_34:
ref.reload(BasicTestsQ31::REF_SHIFT_21_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::INPUTRAND_Q31_ID,mgr);
break; break;
case BasicTestsQ31::TEST_SHIFT_Q31_35: case BasicTestsQ31::TEST_SHIFT_Q31_35:
ref.reload(BasicTestsQ31::REF_SHIFT_POSSAT_22_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::MAXPOS_Q31_ID,mgr);
break; break;
case BasicTestsQ31::TEST_SHIFT_Q31_36: case BasicTestsQ31::TEST_SHIFT_Q31_36:
ref.reload(BasicTestsQ31::REF_SHIFT_NEGSAT_23_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::MAXNEG_Q31_ID,mgr);
break; break;
case BasicTestsQ31::TEST_AND_Q31_37: case BasicTestsQ31::TEST_AND_U32_37:
nb = 3; nb = 3;
ref.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_AND_Q31_38: case BasicTestsQ31::TEST_AND_U32_38:
nb = 8; nb = 8;
ref.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_AND_Q31_39: case BasicTestsQ31::TEST_AND_U32_39:
nb = 11; nb = 11;
ref.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_AND_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_OR_Q31_40: case BasicTestsQ31::TEST_OR_U32_40:
nb = 3; nb = 3;
ref.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_OR_Q31_41: case BasicTestsQ31::TEST_OR_U32_41:
nb = 8; nb = 8;
ref.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_OR_Q31_42: case BasicTestsQ31::TEST_OR_U32_42:
nb = 11; nb = 11;
ref.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_OR_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_NOT_Q31_43: case BasicTestsQ31::TEST_NOT_U32_43:
nb = 3; nb = 3;
ref.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_NOT_Q31_44: case BasicTestsQ31::TEST_NOT_U32_44:
nb = 8; nb = 8;
ref.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_NOT_Q31_45: case BasicTestsQ31::TEST_NOT_U32_45:
nb = 11; nb = 11;
ref.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_NOT_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_XOR_Q31_46: case BasicTestsQ31::TEST_XOR_U32_46:
nb = 3; nb = 3;
ref.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_XOR_Q31_47: case BasicTestsQ31::TEST_XOR_U32_47:
nb = 8; nb = 8;
ref.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_XOR_Q31_48: case BasicTestsQ31::TEST_XOR_U32_48:
nb = 11; nb = 11;
ref.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb); refLogical.reload(BasicTestsQ31::REF_XOR_Q31_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ31::OUT_SAMPLES_Q31_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ31::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb); inputLogical1.reload(BasicTestsQ31::INPUT1_BITWISE_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb); inputLogical2.reload(BasicTestsQ31::INPUT2_BITWISE_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_ADD_Q31_49: case BasicTestsQ31::TEST_ADD_Q31_49:
ref.reload(BasicTestsQ31::REF_ADD_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_SUB_Q31_50: case BasicTestsQ31::TEST_SUB_Q31_50:
ref.reload(BasicTestsQ31::REF_SUB_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_MULT_Q31_51: case BasicTestsQ31::TEST_MULT_Q31_51:
ref.reload(BasicTestsQ31::REF_MULT_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_NEGATE_Q31_52: case BasicTestsQ31::TEST_NEGATE_Q31_52:
ref.reload(BasicTestsQ31::REF_NEGATE_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_OFFSET_Q31_53: case BasicTestsQ31::TEST_OFFSET_Q31_53:
ref.reload(BasicTestsQ31::REF_OFFSET_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_SCALE_Q31_54: case BasicTestsQ31::TEST_SCALE_Q31_54:
ref.reload(BasicTestsQ31::REF_SCALE_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_DOT_PROD_Q31_55: case BasicTestsQ31::TEST_DOT_PROD_Q31_55:
dotRef.reload(BasicTestsQ31::REF_DOT_LONG_Q31_ID,mgr); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
case BasicTestsQ31::TEST_ABS_Q31_56: case BasicTestsQ31::TEST_ABS_Q31_56:
ref.reload(BasicTestsQ31::REF_ABS_Q31_ID,mgr,nb); 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); input1.reload(BasicTestsQ31::INPUT1_Q31_ID,mgr,nb);
input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb); input2.reload(BasicTestsQ31::INPUT2_Q31_ID,mgr,nb);
break; break;
@ -639,6 +646,21 @@ q31_t *outp=output.ptr();
dotOutput.dump(mgr); dotOutput.dump(mgr);
break; 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: default:
output.dump(mgr); 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 *refp=ref.ptr(); \
q7_t *outp=output.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() void BasicTestsQ7::test_add_q7()
{ {
GET_Q7_PTR(); 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();
ASSERT_EMPTY_TAIL(output);
ASSERT_EQ(output,ref); arm_and_u8(inp1,inp2,outp,inputLogical1.nbSamples());
ASSERT_EMPTY_TAIL(outputLogical);
ASSERT_EQ(outputLogical, refLogical);
} }
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: case BasicTestsQ7::TEST_ADD_Q7_1:
nb = 15; nb = 15;
ref.reload(BasicTestsQ7::REF_ADD_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
@ -247,14 +256,14 @@ q7_t *outp=output.ptr();
case BasicTestsQ7::TEST_ADD_Q7_2: case BasicTestsQ7::TEST_ADD_Q7_2:
nb = 32; nb = 32;
ref.reload(BasicTestsQ7::REF_ADD_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_ADD_Q7_3: case BasicTestsQ7::TEST_ADD_Q7_3:
nb = 47; nb = 47;
ref.reload(BasicTestsQ7::REF_ADD_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
@ -263,21 +272,21 @@ q7_t *outp=output.ptr();
case BasicTestsQ7::TEST_SUB_Q7_4: case BasicTestsQ7::TEST_SUB_Q7_4:
nb = 15; nb = 15;
ref.reload(BasicTestsQ7::REF_SUB_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_SUB_Q7_5: case BasicTestsQ7::TEST_SUB_Q7_5:
nb = 32; nb = 32;
ref.reload(BasicTestsQ7::REF_SUB_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_SUB_Q7_6: case BasicTestsQ7::TEST_SUB_Q7_6:
nb = 47; nb = 47;
ref.reload(BasicTestsQ7::REF_SUB_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
@ -285,21 +294,21 @@ q7_t *outp=output.ptr();
case BasicTestsQ7::TEST_MULT_SHORT_Q7_7: case BasicTestsQ7::TEST_MULT_SHORT_Q7_7:
nb = 15; nb = 15;
ref.reload(BasicTestsQ7::REF_MULT_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_MULT_Q7_8: case BasicTestsQ7::TEST_MULT_Q7_8:
nb = 32; nb = 32;
ref.reload(BasicTestsQ7::REF_MULT_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_MULT_Q7_9: case BasicTestsQ7::TEST_MULT_Q7_9:
nb = 47; nb = 47;
ref.reload(BasicTestsQ7::REF_MULT_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
@ -307,78 +316,78 @@ q7_t *outp=output.ptr();
case BasicTestsQ7::TEST_NEGATE_Q7_10: case BasicTestsQ7::TEST_NEGATE_Q7_10:
nb = 15; nb = 15;
ref.reload(BasicTestsQ7::REF_NEGATE_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_NEGATE_Q7_11: case BasicTestsQ7::TEST_NEGATE_Q7_11:
nb = 32; nb = 32;
ref.reload(BasicTestsQ7::REF_NEGATE_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_NEGATE_Q7_12: case BasicTestsQ7::TEST_NEGATE_Q7_12:
nb = 47; nb = 47;
ref.reload(BasicTestsQ7::REF_NEGATE_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_OFFSET_Q7_13: case BasicTestsQ7::TEST_OFFSET_Q7_13:
nb = 15; nb = 15;
ref.reload(BasicTestsQ7::REF_OFFSET_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_OFFSET_Q7_14: case BasicTestsQ7::TEST_OFFSET_Q7_14:
nb = 32; nb = 32;
ref.reload(BasicTestsQ7::REF_OFFSET_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_OFFSET_Q7_15: case BasicTestsQ7::TEST_OFFSET_Q7_15:
nb = 47; nb = 47;
ref.reload(BasicTestsQ7::REF_OFFSET_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_SCALE_Q7_16: case BasicTestsQ7::TEST_SCALE_Q7_16:
nb = 15; nb = 15;
ref.reload(BasicTestsQ7::REF_SCALE_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_SCALE_Q7_17: case BasicTestsQ7::TEST_SCALE_Q7_17:
nb = 32; nb = 32;
ref.reload(BasicTestsQ7::REF_SCALE_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_SCALE_Q7_18: case BasicTestsQ7::TEST_SCALE_Q7_18:
nb = 47; nb = 47;
ref.reload(BasicTestsQ7::REF_SCALE_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_DOT_PROD_Q7_19: case BasicTestsQ7::TEST_DOT_PROD_Q7_19:
nb = 15; nb = 15;
dotRef.reload(BasicTestsQ7::REF_DOT_3_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_DOT_PROD_Q7_20: case BasicTestsQ7::TEST_DOT_PROD_Q7_20:
nb = 32; nb = 32;
dotRef.reload(BasicTestsQ7::REF_DOT_4N_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_DOT_PROD_Q7_21: case BasicTestsQ7::TEST_DOT_PROD_Q7_21:
nb = 47; nb = 47;
dotRef.reload(BasicTestsQ7::REF_DOT_4N1_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
@ -386,21 +395,21 @@ q7_t *outp=output.ptr();
case BasicTestsQ7::TEST_ABS_Q7_22: case BasicTestsQ7::TEST_ABS_Q7_22:
nb = 15; nb = 15;
ref.reload(BasicTestsQ7::REF_ABS_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_ABS_Q7_23: case BasicTestsQ7::TEST_ABS_Q7_23:
nb = 32; nb = 32;
ref.reload(BasicTestsQ7::REF_ABS_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_ABS_Q7_24: case BasicTestsQ7::TEST_ABS_Q7_24:
nb = 47; nb = 47;
ref.reload(BasicTestsQ7::REF_ABS_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
@ -409,46 +418,46 @@ q7_t *outp=output.ptr();
input1.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr); input1.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
input2.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr); input2.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
ref.reload(BasicTestsQ7::REF_POSSAT_12_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; break;
case BasicTestsQ7::TEST_ADD_Q7_26: case BasicTestsQ7::TEST_ADD_Q7_26:
input1.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr); input1.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
input2.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr); input2.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
ref.reload(BasicTestsQ7::REF_NEGSAT_13_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; break;
case BasicTestsQ7::TEST_SUB_Q7_27: case BasicTestsQ7::TEST_SUB_Q7_27:
ref.reload(BasicTestsQ7::REF_POSSAT_14_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
input2.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr); input2.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
break; break;
case BasicTestsQ7::TEST_SUB_Q7_28: case BasicTestsQ7::TEST_SUB_Q7_28:
ref.reload(BasicTestsQ7::REF_NEGSAT_15_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
input2.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr); input2.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
break; break;
case BasicTestsQ7::TEST_MULT_Q7_29: case BasicTestsQ7::TEST_MULT_Q7_29:
ref.reload(BasicTestsQ7::REF_POSSAT_16_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::MAXNEG2_Q7_ID,mgr);
input2.reload(BasicTestsQ7::MAXNEG2_Q7_ID,mgr); input2.reload(BasicTestsQ7::MAXNEG2_Q7_ID,mgr);
break; break;
case BasicTestsQ7::TEST_NEGATE_Q7_30: case BasicTestsQ7::TEST_NEGATE_Q7_30:
ref.reload(BasicTestsQ7::REF_POSSAT_17_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::MAXNEG2_Q7_ID,mgr);
break; break;
case BasicTestsQ7::TEST_OFFSET_Q7_31: case BasicTestsQ7::TEST_OFFSET_Q7_31:
ref.reload(BasicTestsQ7::REF_POSSAT_18_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
/* 0.9 */ /* 0.9 */
this->scalar = 0x73; this->scalar = 0x73;
@ -456,7 +465,7 @@ q7_t *outp=output.ptr();
case BasicTestsQ7::TEST_OFFSET_Q7_32: case BasicTestsQ7::TEST_OFFSET_Q7_32:
ref.reload(BasicTestsQ7::REF_NEGSAT_19_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
/* -0.9 */ /* -0.9 */
this->scalar = 0x8d; this->scalar = 0x8d;
@ -464,7 +473,7 @@ q7_t *outp=output.ptr();
case BasicTestsQ7::TEST_SCALE_Q7_33: case BasicTestsQ7::TEST_SCALE_Q7_33:
ref.reload(BasicTestsQ7::REF_POSSAT_20_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::MAXNEG2_Q7_ID,mgr);
/* Minus max*/ /* Minus max*/
this->scalar = 0x80; this->scalar = 0x80;
@ -472,163 +481,163 @@ q7_t *outp=output.ptr();
case BasicTestsQ7::TEST_SHIFT_Q7_34: case BasicTestsQ7::TEST_SHIFT_Q7_34:
ref.reload(BasicTestsQ7::REF_SHIFT_21_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::INPUTRAND_Q7_ID,mgr);
break; break;
case BasicTestsQ7::TEST_SHIFT_Q7_35: case BasicTestsQ7::TEST_SHIFT_Q7_35:
ref.reload(BasicTestsQ7::REF_SHIFT_POSSAT_22_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::MAXPOS_Q7_ID,mgr);
break; break;
case BasicTestsQ7::TEST_SHIFT_Q7_36: case BasicTestsQ7::TEST_SHIFT_Q7_36:
ref.reload(BasicTestsQ7::REF_SHIFT_NEGSAT_23_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::MAXNEG_Q7_ID,mgr);
break; break;
case BasicTestsQ7::TEST_AND_Q7_37: case BasicTestsQ7::TEST_AND_U8_37:
nb = 15; nb = 15;
ref.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_AND_Q7_38: case BasicTestsQ7::TEST_AND_U8_38:
nb = 32; nb = 32;
ref.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_AND_Q7_39: case BasicTestsQ7::TEST_AND_U8_39:
nb = 47; nb = 47;
ref.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_AND_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_OR_Q7_40: case BasicTestsQ7::TEST_OR_U8_40:
nb = 15; nb = 15;
ref.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_OR_Q7_41: case BasicTestsQ7::TEST_OR_U8_41:
nb = 32; nb = 32;
ref.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_OR_Q7_42: case BasicTestsQ7::TEST_OR_U8_42:
nb = 47; nb = 47;
ref.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_OR_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_NOT_Q7_43: case BasicTestsQ7::TEST_NOT_U8_43:
nb = 15; nb = 15;
ref.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_NOT_Q7_44: case BasicTestsQ7::TEST_NOT_U8_44:
nb = 32; nb = 32;
ref.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_NOT_Q7_45: case BasicTestsQ7::TEST_NOT_U8_45:
nb = 47; nb = 47;
ref.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_NOT_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_XOR_Q7_46: case BasicTestsQ7::TEST_XOR_U8_46:
nb = 15; nb = 15;
ref.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_XOR_Q7_47: case BasicTestsQ7::TEST_XOR_U8_47:
nb = 32; nb = 32;
ref.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_XOR_Q7_48: case BasicTestsQ7::TEST_XOR_U8_48:
nb = 47; nb = 47;
ref.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb); refLogical.reload(BasicTestsQ7::REF_XOR_Q7_ID,mgr,nb);
output.create(ref.nbSamples(),BasicTestsQ7::OUT_SAMPLES_Q7_ID,mgr); outputLogical.create(refLogical.nbSamples(),BasicTestsQ7::OUT_SAMPLES_ID,mgr);
input1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb); inputLogical1.reload(BasicTestsQ7::INPUT1_BITWISE_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb); inputLogical2.reload(BasicTestsQ7::INPUT2_BITWISE_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_ADD_Q7_49: case BasicTestsQ7::TEST_ADD_Q7_49:
ref.reload(BasicTestsQ7::REF_ADD_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_SUB_Q7_50: case BasicTestsQ7::TEST_SUB_Q7_50:
ref.reload(BasicTestsQ7::REF_SUB_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_MULT_Q7_51: case BasicTestsQ7::TEST_MULT_Q7_51:
ref.reload(BasicTestsQ7::REF_MULT_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_NEGATE_Q7_52: case BasicTestsQ7::TEST_NEGATE_Q7_52:
ref.reload(BasicTestsQ7::REF_NEGATE_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_OFFSET_Q7_53: case BasicTestsQ7::TEST_OFFSET_Q7_53:
ref.reload(BasicTestsQ7::REF_OFFSET_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_SCALE_Q7_54: case BasicTestsQ7::TEST_SCALE_Q7_54:
ref.reload(BasicTestsQ7::REF_SCALE_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_DOT_PROD_Q7_55: case BasicTestsQ7::TEST_DOT_PROD_Q7_55:
dotRef.reload(BasicTestsQ7::REF_DOT_LONG_Q7_ID,mgr); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
case BasicTestsQ7::TEST_ABS_Q7_56: case BasicTestsQ7::TEST_ABS_Q7_56:
ref.reload(BasicTestsQ7::REF_ABS_Q7_ID,mgr,nb); 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); input1.reload(BasicTestsQ7::INPUT1_Q7_ID,mgr,nb);
input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb); input2.reload(BasicTestsQ7::INPUT2_Q7_ID,mgr,nb);
break; break;
@ -652,6 +661,21 @@ q7_t *outp=output.ptr();
dotOutput.dump(mgr); dotOutput.dump(mgr);
break; 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: default:
output.dump(mgr); 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_NOT_Q31_ID : Not26_s32.txt
Pattern REF_XOR_Q31_ID : Xor27_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 Output OUT_STATE_Q31_ID : State
Functions { Functions {
@ -749,21 +749,21 @@ group Root {
Test shift pos sat:test_shift_q31 Test shift pos sat:test_shift_q31
Test shift neg sat:test_shift_q31 Test shift neg sat:test_shift_q31
Test nb=3 arm_and_q31:test_and_q31 Test nb=3 arm_and_u32:test_and_u32
Test nb=4n arm_and_q31:test_and_q31 Test nb=4n arm_and_u32:test_and_u32
Test nb=4n+3 arm_and_q31:test_and_q31 Test nb=4n+3 arm_and_u32:test_and_u32
Test nb=3 arm_or_q31:test_or_q31 Test nb=3 arm_or_u32:test_or_u32
Test nb=4n arm_or_q31:test_or_q31 Test nb=4n arm_or_u32:test_or_u32
Test nb=4n+3 arm_or_q31:test_or_q31 Test nb=4n+3 arm_or_u32:test_or_u32
Test nb=3 arm_not_q31:test_not_q31 Test nb=3 arm_not_u32:test_not_u32
Test nb=4n arm_not_q31:test_not_q31 Test nb=4n arm_not_u32:test_not_u32
Test nb=4n+3 arm_not_q31:test_not_q31 Test nb=4n+3 arm_not_u32:test_not_u32
Test nb=3 arm_xor_q31:test_xor_q31 Test nb=3 arm_xor_u32:test_xor_u32
Test nb=4n arm_xor_q31:test_xor_q31 Test nb=4n arm_xor_u32:test_xor_u32
Test nb=4n+3 arm_xor_q31:test_xor_q31 Test nb=4n+3 arm_xor_u32:test_xor_u32
Test long arm_add_q31:test_add_q31 Test long arm_add_q31:test_add_q31
Test long arm_sub_q31:test_sub_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_NOT_Q15_ID : Not26_s16.txt
Pattern REF_XOR_Q15_ID : Xor27_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 Output OUT_STATE_Q15_ID : State
Functions { Functions {
@ -878,21 +878,21 @@ group Root {
Test shift pos sat:test_shift_q15 Test shift pos sat:test_shift_q15
Test shift neg sat:test_shift_q15 Test shift neg sat:test_shift_q15
Test nb=7 arm_and_q15:test_and_q15 Test nb=7 arm_and_u16:test_and_u16
Test nb=8n arm_and_q15:test_and_q15 Test nb=8n arm_and_u16:test_and_u16
Test nb=8n+7 arm_and_q15:test_and_q15 Test nb=8n+7 arm_and_u16:test_and_u16
Test nb=7 arm_or_q15:test_or_q15 Test nb=7 arm_or_u16:test_or_u16
Test nb=8n arm_or_q15:test_or_q15 Test nb=8n arm_or_u16:test_or_u16
Test nb=8n+7 arm_or_q15:test_or_q15 Test nb=8n+7 arm_or_u16:test_or_u16
Test nb=7 arm_not_q15:test_not_q15 Test nb=7 arm_not_u16:test_not_u16
Test nb=8n arm_not_q15:test_not_q15 Test nb=8n arm_not_u16:test_not_u16
Test nb=8n+7 arm_not_q15:test_not_q15 Test nb=8n+7 arm_not_u16:test_not_u16
Test nb=7 arm_xor_q15:test_xor_q15 Test nb=7 arm_xor_u16:test_xor_u16
Test nb=8n arm_xor_q15:test_xor_q15 Test nb=8n arm_xor_u16:test_xor_u16
Test nb=8n+7 arm_xor_q15:test_xor_q15 Test nb=8n+7 arm_xor_u16:test_xor_u16
Test long arm_add_q15:test_add_q15 Test long arm_add_q15:test_add_q15
Test long arm_sub_q15:test_sub_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_NOT_Q7_ID : Not26_s8.txt
Pattern REF_XOR_Q7_ID : Xor27_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 Output OUT_STATE_Q7_ID : State
Functions { Functions {
@ -1007,21 +1007,21 @@ group Root {
Test shift pos sat:test_shift_q7 Test shift pos sat:test_shift_q7
Test shift neg sat:test_shift_q7 Test shift neg sat:test_shift_q7
Test nb=15 arm_and_q7:test_and_q7 Test nb=15 arm_and_u8:test_and_u8
Test nb=16n arm_and_q7:test_and_q7 Test nb=16n arm_and_u8:test_and_u8
Test nb=16n+15 arm_and_q7:test_and_q7 Test nb=16n+15 arm_and_u8:test_and_u8
Test nb=15 arm_or_q7:test_or_q7 Test nb=15 arm_or_u8:test_or_u8
Test nb=16n arm_or_q7:test_or_q7 Test nb=16n arm_or_u8:test_or_u8
Test nb=16n+15 arm_or_q7:test_or_q7 Test nb=16n+15 arm_or_u8:test_or_u8
Test nb=15 arm_not_q7:test_not_q7 Test nb=15 arm_not_u8:test_not_u8
Test nb=16n arm_not_q7:test_not_q7 Test nb=16n arm_not_u8:test_not_u8
Test nb=16n+15 arm_not_q7:test_not_q7 Test nb=16n+15 arm_not_u8:test_not_u8
Test nb=15 arm_xor_q7:test_xor_q7 Test nb=15 arm_xor_u8:test_xor_u8
Test nb=16n arm_xor_q7:test_xor_q7 Test nb=16n arm_xor_u8:test_xor_u8
Test nb=16n+15 arm_xor_q7:test_xor_q7 Test nb=16n+15 arm_xor_u8:test_xor_u8
Test long arm_add_q7:test_add_q7 Test long arm_add_q7:test_add_q7
Test long arm_sub_q7:test_sub_q7 Test long arm_sub_q7:test_sub_q7

Write Preview
Loading…
Cancel
Save