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

CMSIS-DSP: Added f16 support functions

Browse Source
pull/19/head
Christophe Favergeon 6 years ago
parent 48c5d3c145
commit 534c34f883
34 changed files with 10003 additions and 5 deletions
Show Stats Download Patch File Download Diff File

88
Include/dsp/support_functions_f16.h
Unescape Escape View File

@ -26,12 +26,100 @@
#ifndef _SUPPORT_FUNCTIONS_F16_H_
#define _SUPPORT_FUNCTIONS_F16_H_
#include "arm_math_types_f16.h"
#include "arm_math_memory.h"
#include "dsp/none.h"
#include "dsp/utils.h"
#ifdef __cplusplus
extern "C"
{
#endif
#if defined(ARM_FLOAT16_SUPPORTED)
/**
* @brief Copies the elements of a floating-point vector.
* @param[in] pSrc input pointer
* @param[out] pDst output pointer
* @param[in] blockSize number of samples to process
*/
void arm_copy_f16(const float16_t * pSrc, float16_t * pDst, uint32_t blockSize);
/**
* @brief Fills a constant value into a floating-point vector.
* @param[in] value input value to be filled
* @param[out] pDst output pointer
* @param[in] blockSize number of samples to process
*/
void arm_fill_f16(float16_t value, float16_t * pDst, uint32_t blockSize);
/**
* @brief Converts the elements of the floating-point vector to Q31 vector.
* @param[in] pSrc points to the f16 input vector
* @param[out] pDst points to the q15 output vector
* @param[in] blockSize length of the input vector
*/
void arm_f16_to_q15(const float16_t * pSrc, q15_t * pDst, uint32_t blockSize);
/**
* @brief Converts the elements of the floating-point vector to Q31 vector.
* @param[in] pSrc points to the q15 input vector
* @param[out] pDst points to the f16 output vector
* @param[in] blockSize length of the input vector
*/
void arm_q15_to_f16(const q15_t * pSrc, float16_t * pDst, uint32_t blockSize);
/**
* @brief Converts the elements of the floating-point vector to Q31 vector.
* @param[in] pSrc points to the f32 input vector
* @param[out] pDst points to the f16 output vector
* @param[in] blockSize length of the input vector
*/
void arm_float_to_f16(const float32_t * pSrc, float16_t * pDst, uint32_t blockSize);
/**
* @brief Converts the elements of the floating-point vector to Q31 vector.
* @param[in] pSrc points to the f16 input vector
* @param[out] pDst points to the f32 output vector
* @param[in] blockSize length of the input vector
*/
void arm_f16_to_float(const float16_t * pSrc, float32_t * pDst, uint32_t blockSize);
/**
* @brief Weighted sum
*
*
* @param[in] *in Array of input values.
* @param[in] *weigths Weights
* @param[in] blockSize Number of samples in the input array.
* @return Weighted sum
*
*/
float16_t arm_weighted_sum_f16(const float16_t *in
, const float16_t *weigths
, uint32_t blockSize);
/**
* @brief Barycenter
*
*
* @param[in] in List of vectors
* @param[in] weights Weights of the vectors
* @param[out] out Barycenter
* @param[in] nbVectors Number of vectors
* @param[in] vecDim Dimension of space (vector dimension)
* @return None
*
*/
void arm_barycenter_f16(const float16_t *in
, const float16_t *weights
, float16_t *out
, uint32_t nbVectors
, uint32_t vecDim);
#endif /*defined(ARM_FLOAT16_SUPPORTED)*/
#ifdef __cplusplus
}

1
PythonWrapper/setup.py
Unescape Escape View File

@ -25,6 +25,7 @@ transform.remove(os.path.join(ROOT,"Source","TransformFunctions","TransformFunct
support = glob.glob(os.path.join(ROOT,"Source","SupportFunctions","*.c"))
support.remove(os.path.join(ROOT,"Source","SupportFunctions","SupportFunctions.c"))
support.remove(os.path.join(ROOT,"Source","SupportFunctions","SupportFunctionsF16.c"))
fastmath = glob.glob(os.path.join(ROOT,"Source","FastMathFunctions","*.c"))
fastmath.remove(os.path.join(ROOT,"Source","FastMathFunctions","FastMathFunctions.c"))

11
Source/SupportFunctions/CMakeLists.txt
Unescape Escape View File

@ -15,5 +15,14 @@ configDsp(CMSISDSPSupport ${ROOT})
### Includes
target_include_directories(CMSISDSPSupport PUBLIC "${DSP}/Include")
if ((NOT ARMAC5) AND (NOT DISABLEFLOAT16))
target_sources(CMSISDSPSupport PRIVATE arm_copy_f16.c)
target_sources(CMSISDSPSupport PRIVATE arm_fill_f16.c)
target_sources(CMSISDSPSupport PRIVATE arm_f16_to_q15.c)
target_sources(CMSISDSPSupport PRIVATE arm_q15_to_f16.c)
target_sources(CMSISDSPSupport PRIVATE arm_float_to_f16.c)
target_sources(CMSISDSPSupport PRIVATE arm_f16_to_float.c)
target_sources(CMSISDSPSupport PRIVATE arm_weighted_sum_f16.c)
target_sources(CMSISDSPSupport PRIVATE arm_barycenter_f16.c)
endif()

36
Source/SupportFunctions/SupportFunctionsF16.c
Unescape Escape View File

@ -0,0 +1,36 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: SupportFunctions.c
* Description: Combination of all support function source files.
*
* $Date: 16. March 2020
* $Revision: V1.1.0
*
* Target Processor: Cortex-M cores
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2019-2020 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "arm_copy_f16.c"
#include "arm_fill_f16.c"
#include "arm_f16_to_q15.c"
#include "arm_f16_to_float.c"
#include "arm_q15_to_f16.c"
#include "arm_float_to_f16.c"
#include "arm_weighted_sum_f16.c"
#include "arm_barycenter_f16.c"

262
Source/SupportFunctions/arm_barycenter_f16.c
Unescape Escape View File

@ -0,0 +1,262 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_barycenter_f16.c
* Description: Barycenter
*
*
* Target Processor: Cortex-M and Cortex-A cores
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dsp/support_functions_f16.h"
#if defined(ARM_FLOAT16_SUPPORTED)
#include <limits.h>
#include <math.h>
/**
@ingroup groupSupport
*/
/**
* @brief Barycenter
*
*
* @param[in] *in List of vectors
* @param[in] *weights Weights of the vectors
* @param[out] *out Barycenter
* @param[in] nbVectors Number of vectors
* @param[in] vecDim Dimension of space (vector dimension)
* @return None
*
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
void arm_barycenter_f16(const float16_t *in,
const float16_t *weights,
float16_t *out,
uint32_t nbVectors,
uint32_t vecDim)
{
const float16_t *pIn, *pW;
const float16_t *pIn1, *pIn2, *pIn3, *pIn4;
float16_t *pOut;
uint32_t blkCntVector, blkCntSample;
float16_t accum, w;
blkCntVector = nbVectors;
blkCntSample = vecDim;
accum = 0.0f;
pW = weights;
pIn = in;
arm_fill_f16(0.0f, out, vecDim);
/* Sum */
pIn1 = pIn;
pIn2 = pIn1 + vecDim;
pIn3 = pIn2 + vecDim;
pIn4 = pIn3 + vecDim;
blkCntVector = nbVectors >> 2;
while (blkCntVector > 0)
{
f16x8_t outV, inV1, inV2, inV3, inV4;
float16_t w1, w2, w3, w4;
pOut = out;
w1 = *pW++;
w2 = *pW++;
w3 = *pW++;
w4 = *pW++;
accum += w1 + w2 + w3 + w4;
blkCntSample = vecDim >> 3;
while (blkCntSample > 0) {
outV = vld1q((const float16_t *) pOut);
inV1 = vld1q(pIn1);
inV2 = vld1q(pIn2);
inV3 = vld1q(pIn3);
inV4 = vld1q(pIn4);
outV = vfmaq(outV, inV1, w1);
outV = vfmaq(outV, inV2, w2);
outV = vfmaq(outV, inV3, w3);
outV = vfmaq(outV, inV4, w4);
vst1q(pOut, outV);
pOut += 8;
pIn1 += 8;
pIn2 += 8;
pIn3 += 8;
pIn4 += 8;
blkCntSample--;
}
blkCntSample = vecDim & 7;
while (blkCntSample > 0) {
*pOut = *pOut + *pIn1++ * w1;
*pOut = *pOut + *pIn2++ * w2;
*pOut = *pOut + *pIn3++ * w3;
*pOut = *pOut + *pIn4++ * w4;
pOut++;
blkCntSample--;
}
pIn1 += 3 * vecDim;
pIn2 += 3 * vecDim;
pIn3 += 3 * vecDim;
pIn4 += 3 * vecDim;
blkCntVector--;
}
pIn = pIn1;
blkCntVector = nbVectors & 3;
while (blkCntVector > 0)
{
f16x8_t inV, outV;
pOut = out;
w = *pW++;
accum += w;
blkCntSample = vecDim >> 3;
while (blkCntSample > 0)
{
outV = vld1q_f16(pOut);
inV = vld1q_f16(pIn);
outV = vfmaq(outV, inV, w);
vst1q_f16(pOut, outV);
pOut += 8;
pIn += 8;
blkCntSample--;
}
blkCntSample = vecDim & 7;
while (blkCntSample > 0)
{
*pOut = *pOut + *pIn++ * w;
pOut++;
blkCntSample--;
}
blkCntVector--;
}
/* Normalize */
pOut = out;
accum = 1.0f / accum;
blkCntSample = vecDim >> 3;
while (blkCntSample > 0)
{
f16x8_t tmp;
tmp = vld1q((const float16_t *) pOut);
tmp = vmulq(tmp, accum);
vst1q(pOut, tmp);
pOut += 8;
blkCntSample--;
}
blkCntSample = vecDim & 7;
while (blkCntSample > 0)
{
*pOut = *pOut * accum;
pOut++;
blkCntSample--;
}
}
#else
void arm_barycenter_f16(const float16_t *in, const float16_t *weights, float16_t *out, uint32_t nbVectors,uint32_t vecDim)
{
const float16_t *pIn,*pW;
float16_t *pOut;
uint32_t blkCntVector,blkCntSample;
float16_t accum, w;
blkCntVector = nbVectors;
blkCntSample = vecDim;
accum = 0.0f;
pW = weights;
pIn = in;
/* Set counters to 0 */
blkCntSample = vecDim;
pOut = out;
while(blkCntSample > 0)
{
*pOut = 0.0f;
pOut++;
blkCntSample--;
}
/* Sum */
while(blkCntVector > 0)
{
pOut = out;
w = *pW++;
accum += w;
blkCntSample = vecDim;
while(blkCntSample > 0)
{
*pOut = *pOut + *pIn++ * w;
pOut++;
blkCntSample--;
}
blkCntVector--;
}
/* Normalize */
blkCntSample = vecDim;
pOut = out;
while(blkCntSample > 0)
{
*pOut = *pOut / accum;
pOut++;
blkCntSample--;
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
* @} end of groupSupport group
*/
#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

130
Source/SupportFunctions/arm_copy_f16.c
Unescape Escape View File

@ -0,0 +1,130 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_copy_f16.c
* Description: Copies the elements of a floating-point vector
*
* $Date: 18. March 2020
* $Revision: V1.6.0
*
* Target Processor: Cortex-M cores
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dsp/support_functions_f16.h"
#if defined(ARM_FLOAT16_SUPPORTED)
/**
@ingroup groupSupport
*/
/**
@addtogroup copy
@{
*/
/**
@brief Copies the elements of a f16 vector.
@param[in] pSrc points to input vector
@param[out] pDst points to output vector
@param[in] blockSize number of samples in each vector
@return none
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
void arm_copy_f16(
const float16_t * pSrc,
float16_t * pDst,
uint32_t blockSize)
{
do {
mve_pred16_t p = vctp16q(blockSize);
vstrhq_p_f16(pDst,
vldrhq_z_f16((float16_t const *) pSrc, p), p);
/*
* Decrement the blockSize loop counter
* Advance vector source and destination pointers
*/
pSrc += 8;
pDst += 8;
blockSize -= 8;
}
while ((int32_t) blockSize > 0);
}
#else
void arm_copy_f16(
const float16_t * pSrc,
float16_t * pDst,
uint32_t blockSize)
{
uint32_t blkCnt; /* Loop counter */
#if defined (ARM_MATH_LOOPUNROLL)
/* Loop unrolling: Compute 4 outputs at a time */
blkCnt = blockSize >> 2U;
while (blkCnt > 0U)
{
/* C = A */
/* Copy and store result in destination buffer */
*pDst++ = *pSrc++;
*pDst++ = *pSrc++;
*pDst++ = *pSrc++;
*pDst++ = *pSrc++;
/* Decrement loop counter */
blkCnt--;
}
/* Loop unrolling: Compute remaining outputs */
blkCnt = blockSize % 0x4U;
#else
/* Initialize blkCnt with number of samples */
blkCnt = blockSize;
#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
while (blkCnt > 0U)
{
/* C = A */
/* Copy and store result in destination buffer */
*pDst++ = *pSrc++;
/* Decrement loop counter */
blkCnt--;
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of BasicCopy group
*/
#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

130
Source/SupportFunctions/arm_f16_to_float.c
Unescape Escape View File

@ -0,0 +1,130 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_float_to_q15.c
* Description: Converts the elements of the floating-point vector to Q15 vector
*
* $Date: 18. March 2020
* $Revision: V1.6.0
*
* Target Processor: Cortex-M cores
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dsp/support_functions_f16.h"
#if defined(ARM_FLOAT16_SUPPORTED)
/**
@ingroup groupSupport
*/
/**
* @defgroup f16_to_x Convert 16-bit floating point value
*/
/**
@addtogroup f16_to_x
@{
*/
/**
@brief Converts the elements of the f16 vector to f32 vector.
@param[in] pSrc points to the f16 input vector
@param[out] pDst points to the f32 output vector
@param[in] blockSize number of samples in each vector
@return none
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
void arm_f16_to_float(
const float16_t * pSrc,
float32_t * pDst,
uint32_t blockSize)
{
int32_t blkCnt; /* loop counters */
float16x8_t vecDst;
float32x4x2_t tmp;
blkCnt = blockSize >> 3;
while (blkCnt > 0)
{
vecDst = vldrhq_f16(pSrc);
pSrc += 8;
tmp.val[0] = vcvtbq_f32_f16(vecDst);
tmp.val[1] = vcvttq_f32_f16(vecDst);
vst2q(pDst,tmp);
pDst += 8;
/*
* Decrement the blockSize loop counter
*/
blkCnt--;
}
/*
* tail
* (will be merged thru tail predication)
*/
blkCnt = blockSize & 7;
while (blkCnt > 0)
{
*pDst++ = (float32_t) *pSrc++;
/*
* Decrement the loop counter
*/
blkCnt--;
}
}
#else
void arm_f16_to_float(
const float16_t * pSrc,
float32_t * pDst,
uint32_t blockSize)
{
const float16_t *pIn = pSrc; /* Src pointer */
uint32_t blkCnt; /* loop counter */
/*
* Loop over blockSize number of values
*/
blkCnt = blockSize;
while (blkCnt > 0U)
{
*pDst++ = (float32_t) * pIn++;
/*
* Decrement the loop counter
*/
blkCnt--;
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of f16_to_x group
*/
#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

157
Source/SupportFunctions/arm_f16_to_q15.c
Unescape Escape View File

@ -0,0 +1,157 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_float_to_q15.c
* Description: Converts the elements of the floating-point vector to Q15 vector
*
* $Date: 18. March 2020
* $Revision: V1.6.0
*
* Target Processor: Cortex-M cores
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dsp/support_functions_f16.h"
#if defined(ARM_FLOAT16_SUPPORTED)
/**
@ingroup groupSupport
*/
/**
@addtogroup f16_to_x
@{
*/
/**
@brief Converts the elements of the f16 vector to Q15 vector.
@param[in] pSrc points to the f16 input vector
@param[out] pDst points to the Q15 output vector
@param[in] blockSize number of samples in each vector
@return none
@par Details
The equation used for the conversion process is:
<pre>
pDst[n] = (q15_t)(pSrc[n] * 32768); 0 <= n < blockSize.
</pre>
@par Scaling and Overflow Behavior
The function uses saturating arithmetic.
Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
@note
In order to apply rounding in scalar version, the library should be rebuilt with the ROUNDING macro
defined in the preprocessor section of project options.
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
void arm_f16_to_q15(
const float16_t * pSrc,
q15_t * pDst,
uint32_t blockSize)
{
float16_t maxQ = (float16_t) Q15_MAX;
float16x8_t vecDst;
do {
mve_pred16_t p = vctp16q(blockSize);
vecDst = vldrhq_z_f16((float16_t const *) pSrc, p);
/* C = A * 32767 */
/* convert from float to Q15 and then store the results in the destination buffer */
vecDst = vmulq_m(vuninitializedq_f16(), vecDst, maxQ, p);
vstrhq_p_s16(pDst,
vcvtaq_m(vuninitializedq_s16(), vecDst, p), p);
/*
* Decrement the blockSize loop counter
* Advance vector source and destination pointers
*/
pSrc += 8;
pDst += 8;
blockSize -= 8;
}
while ((int32_t) blockSize > 0);
}
#else
void arm_f16_to_q15(
const float16_t * pSrc,
q15_t * pDst,
uint32_t blockSize)
{
const float16_t *pIn = pSrc; /* Src pointer */
uint32_t blkCnt; /* loop counter */
#ifdef ARM_MATH_ROUNDING
float16_t in;
#endif /* #ifdef ARM_MATH_ROUNDING */
/*
* Loop over blockSize number of values
*/
blkCnt = blockSize;
while (blkCnt > 0U)
{
#ifdef ARM_MATH_ROUNDING
/*
* C = A * 65536
*/
/*
* convert from float to Q31 and then store the results in the destination buffer
*/
in = *pIn++;
in = (in * 32768.0);
in += in > 0.0 ? 0.5 : -0.5;
*pDst++ = clip_q31_to_q15((q31_t) (in));
#else
/*
* C = A * 32768
*/
/*
* convert from float to Q31 and then store the results in the destination buffer
*/
*pDst++ = clip_q31_to_q15((q31_t) (*pIn++ * 32768.0));
#endif /* #ifdef ARM_MATH_ROUNDING */
/*
* Decrement the loop counter
*/
blkCnt--;
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of f16_to_x group
*/
#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

127
Source/SupportFunctions/arm_fill_f16.c
Unescape Escape View File

@ -0,0 +1,127 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_fill_f16.c
* Description: Fills a constant value into a floating-point vector
*
* $Date: 18. March 2020
* $Revision: V1.6.0
*
* Target Processor: Cortex-M cores
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dsp/support_functions_f16.h"
#if defined(ARM_FLOAT16_SUPPORTED)
/**
@ingroup groupSupport
*/
/**
@addtogroup Fill
@{
*/
/**
@brief Fills a constant value into a f16 vector.
@param[in] value input value to be filled
@param[out] pDst points to output vector
@param[in] blockSize number of samples in each vector
@return none
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
void arm_fill_f16(
float16_t value,
float16_t * pDst,
uint32_t blockSize)
{
do {
mve_pred16_t p = vctp16q(blockSize);
vstrhq_p_f16(pDst,
vdupq_m_n_f16(vuninitializedq_f16(), value, p), p);
/*
* Decrement the blockSize loop counter
* Advance vector source and destination pointers
*/
pDst += 8;
blockSize -= 8;
}
while ((int32_t) blockSize > 0);
}
#else
void arm_fill_f16(
float16_t value,
float16_t * pDst,
uint32_t blockSize)
{
uint32_t blkCnt; /* Loop counter */
#if defined (ARM_MATH_LOOPUNROLL)
/* Loop unrolling: Compute 4 outputs at a time */
blkCnt = blockSize >> 2U;
while (blkCnt > 0U)
{
/* C = value */
/* Fill value in destination buffer */
*pDst++ = value;
*pDst++ = value;
*pDst++ = value;
*pDst++ = value;
/* Decrement loop counter */
blkCnt--;
}
/* Loop unrolling: Compute remaining outputs */
blkCnt = blockSize % 0x4U;
#else
/* Initialize blkCnt with number of samples */
blkCnt = blockSize;
#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
while (blkCnt > 0U)
{
/* C = value */
/* Fill value in destination buffer */
*pDst++ = value;
/* Decrement loop counter */
blkCnt--;
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of Fill group
*/
#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

127
Source/SupportFunctions/arm_float_to_f16.c
Unescape Escape View File

@ -0,0 +1,127 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_float_to_q15.c
* Description: Converts the elements of the floating-point vector to Q15 vector
*
* $Date: 18. March 2020
* $Revision: V1.6.0
*
* Target Processor: Cortex-M cores
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dsp/support_functions_f16.h"
#if defined(ARM_FLOAT16_SUPPORTED)
/**
@ingroup groupSupport
*/
/**
@addtogroup float_to_x
@{
*/
/**
@brief Converts the elements of the floating-point vector to f16 vector.
@param[in] pSrc points to the f32 input vector
@param[out] pDst points to the f16 output vector
@param[in] blockSize number of samples in each vector
@return none
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
void arm_float_to_f16(
const float32_t * pSrc,
float16_t * pDst,
uint32_t blockSize)
{
int32_t blkCnt; /* loop counters */
float32x4x2_t tmp;
float16x8_t vecDst;
float32_t const *pSrcVec;
pSrcVec = (float32_t const *) pSrc;
blkCnt = blockSize >> 3;
while (blkCnt > 0)
{
/* convert from float32 to float16 and then store the results in the destination buffer */
tmp = vld2q(pSrcVec); pSrcVec += 8;
/* narrow / merge */
vecDst = vcvtbq_f16_f32(vecDst, tmp.val[0]);
vecDst = vcvttq_f16_f32(vecDst, tmp.val[1]);
vst1q(pDst, vecDst); pDst += 8;
/*
* Decrement the blockSize loop counter
*/
blkCnt--;
}
/*
* tail
*/
blkCnt = blockSize & 7;
if (blkCnt > 0)
{
mve_pred16_t p0 = vctp16q(blkCnt);
tmp = vld2q(pSrcVec);
vecDst = vcvtbq_f16_f32(vecDst, tmp.val[0]);
vecDst = vcvttq_f16_f32(vecDst, tmp.val[1]);
vstrhq_p(pDst, vecDst, p0);
}
}
#else
void arm_float_to_f16(
const float32_t * pSrc,
float16_t * pDst,
uint32_t blockSize)
{
const float32_t *pIn = pSrc; /* Src pointer */
uint32_t blkCnt; /* loop counter */
/*
* Loop over blockSize number of values
*/
blkCnt = blockSize;
while (blkCnt > 0U)
{
*pDst++ = (float16_t) * pIn++;
/*
* Decrement the loop counter
*/
blkCnt--;
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of float_to_x group
*/
#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

155
Source/SupportFunctions/arm_q15_to_f16.c
Unescape Escape View File

@ -0,0 +1,155 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_q15_to_float.c
* Description: Converts the elements of the Q15 vector to floating-point vector
*
* $Date: 18. March 2020
* $Revision: V1.6.0
*
* Target Processor: Cortex-M cores
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dsp/support_functions_f16.h"
#if defined(ARM_FLOAT16_SUPPORTED)
/**
@ingroup groupSupport
*/
/**
* @defgroup q15_to_x Convert 16-bit Integer value
*/
/**
@addtogroup q15_to_x
@{
*/
/**
@brief Converts the elements of the Q15 vector to f16 vector.
@param[in] pSrc points to the Q15 input vector
@param[out] pDst points to the f16 output vector
@param[in] blockSize number of samples in each vector
@return none
@par Details
The equation used for the conversion process is:
<pre>
pDst[n] = (float16_t) pSrc[n] / 32768; 0 <= n < blockSize.
</pre>
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
void arm_q15_to_f16(
const q15_t * pSrc,
float16_t * pDst,
uint32_t blockSize)
{
int32_t blkCnt; /* loop counters */
q15x8_t vecDst;
q15_t const *pSrcVec;
pSrcVec = (q15_t const *) pSrc;
blkCnt = blockSize >> 3;
while (blkCnt > 0)
{
/* C = (float16_t) A / 32768 */
/* convert from q15 to float and then store the results in the destination buffer */
vecDst = vld1q(pSrcVec); pSrcVec += 8;
vstrhq(pDst, vcvtq_n_f16_s16(vecDst, 15)); pDst += 8;
/*
* Decrement the blockSize loop counter
*/
blkCnt--;
}
/*
* tail
* (will be merged thru tail predication)
*/
blkCnt = blockSize & 7;
if (blkCnt > 0)
{
mve_pred16_t p0 = vctp16q(blkCnt);
vecDst = vld1q(pSrcVec); pSrcVec += 8;
vstrhq_p(pDst, vcvtq_n_f16_s16(vecDst, 15), p0);
}
}
#else
void arm_q15_to_f16(
const q15_t * pSrc,
float16_t * pDst,
uint32_t blockSize)
{
uint32_t blkCnt; /* Loop counter */
const q15_t *pIn = pSrc; /* Source pointer */
#if defined (ARM_MATH_LOOPUNROLL)
/* Loop unrolling: Compute 4 outputs at a time */
blkCnt = blockSize >> 2U;
while (blkCnt > 0U)
{
/* C = (float16_t) A / 32768 */
/* Convert from q15 to float and store result in destination buffer */
*pDst++ = ((float16_t) * pIn++ / 32768.0f);
*pDst++ = ((float16_t) * pIn++ / 32768.0f);
*pDst++ = ((float16_t) * pIn++ / 32768.0f);
*pDst++ = ((float16_t) * pIn++ / 32768.0f);
/* Decrement loop counter */
blkCnt--;
}
/* Loop unrolling: Compute remaining outputs */
blkCnt = blockSize % 0x4U;
#else
/* Initialize blkCnt with number of samples */
blkCnt = blockSize;
#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
while (blkCnt > 0U)
{
/* C = (float16_t) A / 32768 */
/* Convert from q15 to float and store result in destination buffer */
*pDst++ = ((float16_t) *pIn++ / 32768.0f);
/* Decrement loop counter */
blkCnt--;
}
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
@} end of q15_to_x group
*/
#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

135
Source/SupportFunctions/arm_weighted_sum_f16.c
Unescape Escape View File

@ -0,0 +1,135 @@
/* ----------------------------------------------------------------------
* Project: CMSIS DSP Library
* Title: arm_weighted_sum_f16.c
* Description: Weighted Sum
*
*
* Target Processor: Cortex-M and Cortex-A cores
* -------------------------------------------------------------------- */
/*
* Copyright (C) 2010-2020 ARM Limited or its affiliates. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "arm_math.h"
#include <limits.h>
#include <math.h>
#include "dsp/support_functions_f16.h"
#if defined(ARM_FLOAT16_SUPPORTED)
/**
* @addtogroup groupSupport
* @{
*/
/**
* @brief Weighted sum
*
*
* @param[in] *in Array of input values.
* @param[in] *weigths Weights
* @param[in] blockSize Number of samples in the input array.
* @return Weighted sum
*
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
#include "arm_helium_utils.h"
float16_t arm_weighted_sum_f16(const float16_t *in,const float16_t *weigths, uint32_t blockSize)
{
_Float16 accum1, accum2;
float16x8_t accum1V, accum2V;
float16x8_t inV, wV;
const float16_t *pIn, *pW;
uint32_t blkCnt;
pIn = in;
pW = weigths;
accum1V = vdupq_n_f16(0.0f16);
accum2V = vdupq_n_f16(0.0f16);
blkCnt = blockSize >> 2;
while (blkCnt > 0)
{
inV = vld1q(pIn);
wV = vld1q(pW);
pIn += 4;
pW += 4;
accum1V = vfmaq(accum1V, inV, wV);
accum2V = vaddq(accum2V, wV);
blkCnt--;
}
accum1 = vecAddAcrossF16Mve(accum1V);
accum2 = vecAddAcrossF16Mve(accum2V);
blkCnt = blockSize & 3;
while(blkCnt > 0)
{
accum1 += (_Float16)*pIn++ * (_Float16)*pW;
accum2 += (_Float16)*pW++;
blkCnt--;
}
return (accum1 / accum2);
}
#else
float16_t arm_weighted_sum_f16(const float16_t *in, const float16_t *weigths, uint32_t blockSize)
{
_Float16 accum1, accum2;
const float16_t *pIn, *pW;
uint32_t blkCnt;
pIn = in;
pW = weigths;
accum1=0.0f16;
accum2=0.0f16;
blkCnt = blockSize;
while(blkCnt > 0)
{
accum1 += (_Float16)*pIn++ * (_Float16)*pW;
accum2 += (_Float16)*pW++;
blkCnt--;
}
return(accum1 / accum2);
}
#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
/**
* @} end of groupSupport group
*/
#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */

1
Source/SupportFunctions/arm_weighted_sum_f32.c
Unescape Escape View File

@ -28,6 +28,7 @@
#include <limits.h>
#include <math.h>
#include "dsp/support_functions.h"
/**
* @addtogroup groupSupport

2
Testing/CMakeLists.txt
Unescape Escape View File

@ -337,6 +337,8 @@ set(TESTSRC16
Source/Tests/UnaryTestsF16.cpp
Source/Tests/TransformCF16.cpp
Source/Tests/TransformRF16.cpp
Source/Tests/SupportTestsF16.cpp
Source/Tests/SupportBarTestsF16.cpp
)
endif()
endif()

24
Testing/Include/Tests/SupportBarTestsF16.h
Unescape Escape View File

@ -0,0 +1,24 @@
#include "Test.h"
#include "Pattern.h"
#include "dsp/support_functions_f16.h"
class SupportBarTestsF16:public Client::Suite
{
public:
SupportBarTestsF16(Testing::testID_t id);
virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& params,Client::PatternMgr *mgr);
virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
private:
#include "SupportBarTestsF16_decl.h"
Client::Pattern<float16_t> input;
Client::Pattern<float16_t> coefs;
Client::Pattern<float16_t> ref;
Client::Pattern<int16_t> dims;
Client::LocalPattern<float16_t> output;
int nbTests;
};

33
Testing/Include/Tests/SupportTestsF16.h
Unescape Escape View File

@ -0,0 +1,33 @@
#include "Test.h"
#include "Pattern.h"
#include "dsp/support_functions_f16.h"
class SupportTestsF16:public Client::Suite
{
public:
SupportTestsF16(Testing::testID_t id);
virtual void setUp(Testing::testID_t,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr);
virtual void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
private:
#include "SupportTestsF16_decl.h"
Client::Pattern<float16_t> input;
Client::Pattern<q15_t> inputQ15;
Client::Pattern<float32_t> inputF32;
Client::Pattern<float16_t> coefs;
Client::LocalPattern<float16_t> buffer;
Client::LocalPattern<float16_t> output;
Client::LocalPattern<q15_t> outputQ15;
Client::LocalPattern<float32_t> outputF32;
// Reference patterns are not loaded when we are in dump mode
Client::RefPattern<float16_t> ref;
Client::RefPattern<q15_t> refQ15;
Client::RefPattern<float32_t> refF32;
int nbSamples;
int offset;
};

20
Testing/PatternGeneration/Support.py
Unescape Escape View File

@ -85,15 +85,27 @@ def writeTestsF32(config):
va = np.random.rand(NBSAMPLES)
va = Tools.normalize(va)
config.writeInput(1,va,"Samples")
config.writeInputQ15(3,va,"Samples")
config.writeInputQ31(4,va,"Samples")
config.writeInputQ7(5,va,"Samples")
config.writeInputF16(11,va,"Samples")
# This is for benchmarking the weighted sum and we use only one test pattern
genWsum(config,6)
def writeTestsF16(config):
NBSAMPLES=256
va = np.random.rand(NBSAMPLES)
va = Tools.normalize(va)
config.writeInputF32(1,va,"Samples")
config.writeInputQ15(3,va,"Samples")
config.writeInput(11,va,"Samples")
# This is for benchmarking the weighted sum and we use only one test pattern
genWsum(config,6)
def writeTestsQ31(config):
NBSAMPLES=256
@ -115,6 +127,7 @@ def writeTestsQ15(config):
config.writeInput(3,va,"Samples")
config.writeInputQ31(4,va,"Samples")
config.writeInputQ7(5,va,"Samples")
config.writeInputF16(11,va,"Samples")
def writeTestsQ7(config):
NBSAMPLES=256
@ -171,16 +184,19 @@ def generatePatterns():
PARAMDIR = os.path.join("Parameters","DSP","Support","Support")
configf32=Tools.Config(PATTERNDIR,PARAMDIR,"f32")
configf16=Tools.Config(PATTERNDIR,PARAMDIR,"f16")
configq31=Tools.Config(PATTERNDIR,PARAMDIR,"q31")
configq15=Tools.Config(PATTERNDIR,PARAMDIR,"q15")
configq7=Tools.Config(PATTERNDIR,PARAMDIR,"q7")
writeTestsF32(configf32)
writeTestsF16(configf16)
writeTestsQ31(configq31)
writeTestsQ15(configq15)
writeTestsQ7(configq7)
writeTests2(configf32,0)
# For benchmarking we need to vary number of vectors and vector dimension separately
@ -188,8 +204,10 @@ def generatePatterns():
PARAMBARDIR = os.path.join("Parameters","DSP","SupportBar")
configBarf32=Tools.Config(PATTERNBARDIR,PARAMBARDIR,"f32")
configBarf16=Tools.Config(PATTERNBARDIR,PARAMBARDIR,"f16")
writeBarTests(configBarf32)
writeBarTests(configBarf16)
if __name__ == '__main__':
generatePatterns()

102
Testing/Patterns/DSP/Support/SupportF16/Inputs6_f16.txt
Unescape Escape View File

@ -0,0 +1,102 @@
H
50
// 0.549118
0x3865
// 0.782574
0x3a43
// 0.537389
0x384d
// 0.576597
0x389d
// 0.849496
0x3acc
// 0.764850
0x3a1e
// 0.539151
0x3850
// 0.459163
0x3759
// 0.352476
0x35a4
// 0.333343
0x3555
// 0.362662
0x35cd
// 0.343928
0x3581
// 0.046084
0x29e6
// 0.583088
0x38aa
// 0.464789
0x3770
// 0.659567
0x3947
// 0.177360
0x31ad
// 0.465121
0x3771
// 0.849010
0x3acb
// 0.748383
0x39fd
// 0.493254
0x37e4
// 0.023579
0x2609
// 0.354457
0x35ac
// 0.880690
0x3b0c
// 0.029813
0x27a2
// 0.338038
0x3569
// 0.724386
0x39cc
// 0.341454
0x3577
// 0.676073
0x3969
// 0.041176
0x2945
// 0.214019
0x32d9
// 0.322539
0x3529
// 0.499026
0x37fc
// 0.616038
0x38ee
// 0.688882
0x3983
// 0.066439
0x2c41
// 0.094981
0x2e14
// 0.873092
0x3afc
// 0.642707
0x3924
// 0.537527
0x384d
// 0.370953
0x35ef
// 0.450042
0x3733
// 0.434679
0x36f4
// 0.676789
0x396a
// 0.303649
0x34dc
// 0.076930
0x2cec
// 0.871305
0x3af8
// 0.855053
0x3ad7
// 0.498935
0x37fc
// 0.854980
0x3ad7

8
Testing/Patterns/DSP/Support/SupportF16/Ref6_f16.txt
Unescape Escape View File

@ -0,0 +1,8 @@
H
3
// 0.544937
0x385c
// 0.581009
0x38a6
// 0.504352
0x3809

514
Testing/Patterns/DSP/Support/SupportF16/Samples11_f16.txt
Unescape Escape View File

@ -0,0 +1,514 @@
H
256
// 0.232213
0x336e
// 0.160670
0x3124
// 0.314001
0x3506
// 0.360407
0x35c4
// 0.166373
0x3153
// 0.728551
0x39d4
// 0.248761
0x33f6
// 0.520383
0x382a
// 0.394236
0x364f
// 0.566054
0x3887
// 0.270999
0x3456
// 0.277125
0x346f
// 0.720051
0x39c3
// 0.143232
0x3095
// 0.953418
0x3ba1
// 0.926008
0x3b68
// 0.298628
0x34c7
// 0.453645
0x3742
// 0.854467
0x3ad6
// 0.634962
0x3914
// 0.020716
0x254e
// 0.201798
0x3275
// 0.754917
0x3a0a
// 0.160460
0x3122
// 0.860240
0x3ae2
// 0.456928
0x3750
// 0.798465
0x3a63
// 0.606581
0x38da
// 0.918952
0x3b5a
// 0.840406
0x3ab9
// 0.882951
0x3b10
// 0.788696
0x3a4f
// 0.872629
0x3afb
// 0.739226
0x39ea
// 0.851721
0x3ad0
// 0.721847
0x39c6
// 0.064343
0x2c1e
// 0.155535
0x30fa
// 0.296368
0x34be
// 0.602155
0x38d1
// 0.668798
0x395a
// 0.567897
0x388b
// 0.027349
0x2700
// 0.208933
0x32b0
// 0.391116
0x3642
// 0.320529
0x3521
// 0.239981
0x33ae
// 0.742395
0x39f0
// 0.302185
0x34d6
// 0.297422
0x34c2
// 0.339546
0x356f
// 0.606334
0x38da
// 0.802948
0x3a6c
// 0.783320
0x3a44
// 0.301217
0x34d2
// 0.392084
0x3646
// 0.906930
0x3b41
// 0.784974
0x3a48
// 0.820630
0x3a91
// 0.555112
0x3871
// 0.249777
0x33fe
// 0.397971
0x365e
// 0.766186
0x3a21
// 0.102160
0x2e8a
// 0.932833
0x3b76
// 0.232574
0x3371
// 0.351984
0x35a2
// 0.413864
0x369f
// 0.649752
0x3933
// 0.661229
0x394a
// 0.160011
0x311f
// 0.515113
0x381f
// 0.401695
0x366d
// 0.639391
0x391d
// 0.184963
0x31eb
// 0.309950
0x34f6
// 0.997266
0x3bfa
// 0.442989
0x3716
// 0.687126
0x397f
// 0.791793
0x3a56
// 0.450806
0x3737
// 0.857254
0x3adc
// 0.103779
0x2ea4
// 0.866772
0x3aef
// 0.052627
0x2abc
// 0.228961
0x3354
// 0.479702
0x37ad
// 0.988195
0x3be8
// 0.073056
0x2cad
// 0.716525
0x39bb
// 0.346232
0x358a
// 0.040766
0x2938
// 0.774048
0x3a31
// 0.484317
0x37c0
// 0.253514
0x340e
// 0.186310
0x31f6
// 0.498707
0x37fb
// 0.941175
0x3b88
// 0.897112
0x3b2d
// 0.756706
0x3a0e
// 0.510568
0x3816
// 0.361185
0x35c7
// 0.924279
0x3b65
// 0.213337
0x32d4
// 0.434672
0x36f4
// 0.608576
0x38de
// 0.488150
0x37cf
// 0.216525
0x32ee
// 0.137149
0x3064
// 0.659985
0x3948
// 0.176793
0x31a8
// 0.217174
0x32f3
// 0.622483
0x38fb
// 0.050904
0x2a84
// 0.736709
0x39e5
// 0.568254
0x388c
// 0.295369
0x34ba
// 0.789799
0x3a52
// 0.756526
0x3a0d
// 0.261791
0x3430
// 0.779672
0x3a3d
// 0.369407
0x35e9
// 0.317762
0x3516
// 0.070755
0x2c87
// 0.570782
0x3891
// 0.785270
0x3a48
// 0.765575
0x3a20
// 0.093798
0x2e01
// 0.287046
0x3498
// 0.164721
0x3145
// 0.669478
0x395b
// 0.270905
0x3456
// 0.528716
0x383b
// 0.229784
0x335a
// 0.246877
0x33e6
// 0.034023
0x285b
// 0.167404
0x315b
// 0.981554
0x3bda
// 0.134720
0x3050
// 0.430314
0x36e3
// 0.203442
0x3283
// 0.010579
0x216b
// 0.593494
0x38bf
// 0.227444
0x3347
// 0.504467
0x3809
// 0.086099
0x2d83
// 0.061914
0x2bed
// 0.091971
0x2de3
// 0.695435
0x3990
// 0.477607
0x37a4
// 0.559673
0x387a
// 0.401697
0x366d
// 0.816674
0x3a89
// 0.417955
0x36b0
// 0.255284
0x3416
// 0.138090
0x306b
// 0.864719
0x3aeb
// 0.830540
0x3aa5
// 1.000000
0x3c00
// 0.264740
0x343c
// 0.256583
0x341b
// 0.512447
0x3819
// 0.017940
0x2498
// 0.361380
0x35c8
// 0.167601
0x315d
// 0.116623
0x2f77
// 0.954834
0x3ba3
// 0.698154
0x3996
// 0.474653
0x3798
// 0.736439
0x39e4
// 0.523479
0x3830
// 0.669148
0x395a
// 0.628036
0x3906
// 0.663049
0x394e
// 0.784101
0x3a46
// 0.150674
0x30d2
// 0.425963
0x36d1
// 0.903916
0x3b3b
// 0.761962
0x3a18
// 0.088827
0x2daf
// 0.175334
0x319c
// 0.094504
0x2e0c
// 0.839851
0x3ab8
// 0.904541
0x3b3c
// 0.611002
0x38e3
// 0.973025
0x3bc9
// 0.375334
0x3601
// 0.408567
0x3689
// 0.275563
0x3469
// 0.336170
0x3561
// 0.684577
0x397a
// 0.701685
0x399d
// 0.879323
0x3b09
// 0.851562
0x3ad0
// 0.687842
0x3981
// 0.432475
0x36eb
// 0.471428
0x378b
// 0.498133
0x37f8
// 0.884369
0x3b13
// 0.540393
0x3853
// 0.690243
0x3986
// 0.406783
0x3682
// 0.119419
0x2fa5
// 0.871600
0x3af9
// 0.590247
0x38b9
// 0.829816
0x3aa3
// 0.026947
0x26e6
// 0.885707
0x3b16
// 0.007491
0x1fac
// 0.019259
0x24ee
// 0.355738
0x35b1
// 0.510329
0x3815
// 0.438521
0x3704
// 0.020706
0x254d
// 0.808353
0x3a78
// 0.556563
0x3874
// 0.168611
0x3165
// 0.640904
0x3921
// 0.929503
0x3b70
// 0.363973
0x35d3
// 0.806832
0x3a74
// 0.228931
0x3353
// 0.006998
0x1f2b
// 0.979839
0x3bd7
// 0.370853
0x35ef
// 0.723556
0x39ca
// 0.328841
0x3543
// 0.096281
0x2e29
// 0.699122
0x3998
// 0.057076
0x2b4e
// 0.321814
0x3526
// 0.781857
0x3a41
// 0.563734
0x3883
// 0.079375
0x2d14
// 0.336694
0x3563
// 0.516908
0x3823
// 0.000134
0x865
// 0.158567
0x3113
// 0.227195
0x3345
// 0.539051
0x3850
// 0.119377
0x2fa4
// 0.085954
0x2d80
// 0.875148
0x3b00
// 0.717698
0x39be
// 0.186023
0x31f4
// 0.260592
0x342b
// 0.066414
0x2c40
// 0.188375
0x3207
// 0.692106
0x3989
// 0.295660
0x34bb
// 0.163717
0x313d
// 0.381374
0x361a
// 0.451327
0x3739
// 0.853639
0x3ad4
// 0.919007
0x3b5a
// 0.515822
0x3820

514
Testing/Patterns/DSP/Support/SupportF16/Samples1_f32.txt
Unescape Escape View File

@ -0,0 +1,514 @@
W
256
// 0.232213
0x3e6dc924
// 0.160670
0x3e2486b6
// 0.314001
0x3ea0c4b0
// 0.360407
0x3eb8873d
// 0.166373
0x3e2a5dcc
// 0.728551
0x3f3a8256
// 0.248761
0x3e7ebb3f
// 0.520383
0x3f0537d7
// 0.394236
0x3ec9d94d
// 0.566054
0x3f10e8eb
// 0.270999
0x3e8ac054
// 0.277125
0x3e8de34d
// 0.720051
0x3f38553f
// 0.143232
0x3e12ab5c
// 0.953418
0x3f741331
// 0.926008
0x3f6d0edf
// 0.298628
0x3e98e5bc
// 0.453645
0x3ee8441e
// 0.854467
0x3f5abe5e
// 0.634962
0x3f228ce2
// 0.020716
0x3ca9b3f0
// 0.201798
0x3e4ea407
// 0.754917
0x3f414244
// 0.160460
0x3e244fbe
// 0.860240
0x3f5c38b0
// 0.456928
0x3ee9f27c
// 0.798465
0x3f4c6833
// 0.606581
0x3f1b48e3
// 0.918952
0x3f6b4071
// 0.840406
0x3f5724df
// 0.882951
0x3f62091b
// 0.788696
0x3f49e803
// 0.872629
0x3f5f64a1
// 0.739226
0x3f3d3de7
// 0.851721
0x3f5a0a5b
// 0.721847
0x3f38caf3
// 0.064343
0x3d83c65c
// 0.155535
0x3e1f44b3
// 0.296368
0x3e97bd96
// 0.602155
0x3f1a26d1
// 0.668798
0x3f2b3656
// 0.567897
0x3f1161b7
// 0.027349
0x3ce00b2d
// 0.208933
0x3e55f2a5
// 0.391116
0x3ec84050
// 0.320529
0x3ea41c61
// 0.239981
0x3e75bd9c
// 0.742395
0x3f3e0d99
// 0.302185
0x3e9ab80e
// 0.297422
0x3e9847ac
// 0.339546
0x3eadd8f5
// 0.606334
0x3f1b38b1
// 0.802948
0x3f4d8e05
// 0.783320
0x3f4887ab
// 0.301217
0x3e9a3928
// 0.392084
0x3ec8bf3b
// 0.906930
0x3f682c8c
// 0.784974
0x3f48f40f
// 0.820630
0x3f5214d5
// 0.555112
0x3f0e1bd0
// 0.249777
0x3e7fc575
// 0.397971
0x3ecbc2d6
// 0.766186
0x3f4424c0
// 0.102160
0x3dd13961
// 0.932833
0x3f6ece1e
// 0.232574
0x3e6e27da
// 0.351984
0x3eb43742
// 0.413864
0x3ed3e600
// 0.649752
0x3f265621
// 0.661229
0x3f294646
// 0.160011
0x3e23da06
// 0.515113
0x3f03de74
// 0.401695
0x3ecdaae9
// 0.639391
0x3f23af22
// 0.184963
0x3e3d66f3
// 0.309950
0x3e9eb1b7
// 0.997266
0x3f7f4ccb
// 0.442989
0x3ee2cf65
// 0.687126
0x3f2fe785
// 0.791793
0x3f4ab2ea
// 0.450806
0x3ee6d007
// 0.857254
0x3f5b7500
// 0.103779
0x3dd48a16
// 0.866772
0x3f5de4c3
// 0.052627
0x3d578efb
// 0.228961
0x3e6a74b3
// 0.479702
0x3ef59b6f
// 0.988195
0x3f7cfa5f
// 0.073056
0x3d959e7c
// 0.716525
0x3f376e35
// 0.346232
0x3eb14546
// 0.040766
0x3d26fa91
// 0.774048
0x3f462803
// 0.484317
0x3ef7f86d
// 0.253514
0x3e81cc9e
// 0.186310
0x3e3ec7f1
// 0.498707
0x3eff5680
// 0.941175
0x3f70f0df
// 0.897112
0x3f65a925
// 0.756706
0x3f41b77f
// 0.510568
0x3f02b49b
// 0.361185
0x3eb8ed41
// 0.924279
0x3f6c9d8d
// 0.213337
0x3e5a750f
// 0.434672
0x3ede8d52
// 0.608576
0x3f1bcba6
// 0.488150
0x3ef9eece
// 0.216525
0x3e5db8a2
// 0.137149
0x3e0c70ea
// 0.659985
0x3f28f4c1
// 0.176793
0x3e350932
// 0.217174
0x3e5e62e1
// 0.622483
0x3f1f5b05
// 0.050904
0x3d50808b
// 0.736709
0x3f3c98fb
// 0.568254
0x3f11791d
// 0.295369
0x3e973a8d
// 0.789799
0x3f4a303f
// 0.756526
0x3f41abaa
// 0.261791
0x3e860968
// 0.779672
0x3f479891
// 0.369407
0x3ebd22dd
// 0.317762
0x3ea2b1a4
// 0.070755
0x3d90e7fd
// 0.570782
0x3f121ec0
// 0.785270
0x3f49077b
// 0.765575
0x3f43fcc1
// 0.093798
0x3dc018fa
// 0.287046
0x3e92f7a8
// 0.164721
0x3e28acbb
// 0.669478
0x3f2b62f0
// 0.270905
0x3e8ab40e
// 0.528716
0x3f0759ef
// 0.229784
0x3e6b4c76
// 0.246877
0x3e7ccd69
// 0.034023
0x3d0b5c0e
// 0.167404
0x3e2b6c0b
// 0.981554
0x3f7b4725
// 0.134720
0x3e09f429
// 0.430314
0x3edc5225
// 0.203442
0x3e5052ff
// 0.010579
0x3c2d5312
// 0.593494
0x3f17ef38
// 0.227444
0x3e68e722
// 0.504467
0x3f0124b8
// 0.086099
0x3db054ad
// 0.061914
0x3d7d99d6
// 0.091971
0x3dbc5b8b
// 0.695435
0x3f320806
// 0.477607
0x3ef488da
// 0.559673
0x3f0f46bb
// 0.401697
0x3ecdab35
// 0.816674
0x3f51118c
// 0.417955
0x3ed5fe3d
// 0.255284
0x3e82b4a4
// 0.138090
0x3e0d677a
// 0.864719
0x3f5d5e34
// 0.830540
0x3f549e4d
// 1.000000
0x3f800000
// 0.264740
0x3e878bf5
// 0.256583
0x3e835ee8
// 0.512447
0x3f032fc2
// 0.017940
0x3c92f727
// 0.361380
0x3eb906cc
// 0.167601
0x3e2b9f88
// 0.116623
0x3deed844
// 0.954834
0x3f747000
// 0.698154
0x3f32ba35
// 0.474653
0x3ef305c4
// 0.736439
0x3f3c8745
// 0.523479
0x3f0602ba
// 0.669148
0x3f2b4d46
// 0.628036
0x3f20c6ff
// 0.663049
0x3f29bd96
// 0.784101
0x3f48bad0
// 0.150674
0x3e1a4a43
// 0.425963
0x3eda17ca
// 0.903916
0x3f676708
// 0.761962
0x3f430ff7
// 0.088827
0x3db5eb23
// 0.175334
0x3e338ac1
// 0.094504
0x3dc18b6d
// 0.839851
0x3f570079
// 0.904541
0x3f678ffc
// 0.611002
0x3f1c6a9f
// 0.973025
0x3f791831
// 0.375334
0x3ec02bb9
// 0.408567
0x3ed12fa1
// 0.275563
0x3e8d1691
// 0.336170
0x3eac1e7c
// 0.684577
0x3f2f4073
// 0.701685
0x3f33a19a
// 0.879323
0x3f611b48
// 0.851562
0x3f59ffff
// 0.687842
0x3f30166e
// 0.432475
0x3edd6d54
// 0.471428
0x3ef15ef6
// 0.498133
0x3eff0b45
// 0.884369
0x3f6265fb
// 0.540393
0x3f0a5736
// 0.690243
0x3f30b3c8
// 0.406783
0x3ed045e9
// 0.119419
0x3df4920d
// 0.871600
0x3f5f212a
// 0.590247
0x3f171a71
// 0.829816
0x3f546ed0
// 0.026947
0x3cdcbfbb
// 0.885707
0x3f62bdb0
// 0.007491
0x3bf57904
// 0.019259
0x3c9dc503
// 0.355738
0x3eb6234c
// 0.510329
0x3f02a4e8
// 0.438521
0x3ee085d6
// 0.020706
0x3ca99f7a
// 0.808353
0x3f4ef040
// 0.556563
0x3f0e7aed
// 0.168611
0x3e2ca85b
// 0.640904
0x3f241250
// 0.929503
0x3f6df3e2
// 0.363973
0x3eba5aab
// 0.806832
0x3f4e8c84
// 0.228931
0x3e6a6d03
// 0.006998
0x3be552df
// 0.979839
0x3f7ad6b8
// 0.370853
0x3ebde06c
// 0.723556
0x3f393af9
// 0.328841
0x3ea85de8
// 0.096281
0x3dc52f10
// 0.699122
0x3f32f9b1
// 0.057076
0x3d69c847
// 0.321814
0x3ea4c4d4
// 0.781857
0x3f4827cc
// 0.563734
0x3f1050e4
// 0.079375
0x3da28f6e
// 0.336694
0x3eac631d
// 0.516908
0x3f04541c
// 0.000134
0x390ca629
// 0.158567
0x3e225f7d
// 0.227195
0x3e68a5b0
// 0.539051
0x3f09ff3f
// 0.119377
0x3df47be2
// 0.085954
0x3db00868
// 0.875148
0x3f6009b6
// 0.717698
0x3f37bb10
// 0.186023
0x3e3e7cc2
// 0.260592
0x3e856c5f
// 0.066414
0x3d880450
// 0.188375
0x3e40e56d
// 0.692106
0x3f312dda
// 0.295660
0x3e9760cd
// 0.163717
0x3e27a550
// 0.381374
0x3ec3437a
// 0.451327
0x3ee71457
// 0.853639
0x3f5a881e
// 0.919007
0x3f6b4411
// 0.515822
0x3f040cf0

514
Testing/Patterns/DSP/Support/SupportF16/Samples3_q15.txt
Unescape Escape View File

@ -0,0 +1,514 @@
H
256
// 0.232213
0x1DB9
// 0.160670
0x1491
// 0.314001
0x2831
// 0.360407
0x2E22
// 0.166373
0x154C
// 0.728551
0x5D41
// 0.248761
0x1FD7
// 0.520383
0x429C
// 0.394236
0x3276
// 0.566054
0x4874
// 0.270999
0x22B0
// 0.277125
0x2379
// 0.720051
0x5C2B
// 0.143232
0x1255
// 0.953418
0x7A0A
// 0.926008
0x7687
// 0.298628
0x2639
// 0.453645
0x3A11
// 0.854467
0x6D5F
// 0.634962
0x5146
// 0.020716
0x02A7
// 0.201798
0x19D5
// 0.754917
0x60A1
// 0.160460
0x148A
// 0.860240
0x6E1C
// 0.456928
0x3A7D
// 0.798465
0x6634
// 0.606581
0x4DA4
// 0.918952
0x75A0
// 0.840406
0x6B92
// 0.882951
0x7105
// 0.788696
0x64F4
// 0.872629
0x6FB2
// 0.739226
0x5E9F
// 0.851721
0x6D05
// 0.721847
0x5C65
// 0.064343
0x083C
// 0.155535
0x13E9
// 0.296368
0x25EF
// 0.602155
0x4D13
// 0.668798
0x559B
// 0.567897
0x48B1
// 0.027349
0x0380
// 0.208933
0x1ABE
// 0.391116
0x3210
// 0.320529
0x2907
// 0.239981
0x1EB8
// 0.742395
0x5F07
// 0.302185
0x26AE
// 0.297422
0x2612
// 0.339546
0x2B76
// 0.606334
0x4D9C
// 0.802948
0x66C7
// 0.783320
0x6444
// 0.301217
0x268E
// 0.392084
0x3230
// 0.906930
0x7416
// 0.784974
0x647A
// 0.820630
0x690A
// 0.555112
0x470E
// 0.249777
0x1FF9
// 0.397971
0x32F1
// 0.766186
0x6212
// 0.102160
0x0D14
// 0.932833
0x7767
// 0.232574
0x1DC5
// 0.351984
0x2D0E
// 0.413864
0x34FA
// 0.649752
0x532B
// 0.661229
0x54A3
// 0.160011
0x147B
// 0.515113
0x41EF
// 0.401695
0x336B
// 0.639391
0x51D8
// 0.184963
0x17AD
// 0.309950
0x27AC
// 0.997266
0x7FA6
// 0.442989
0x38B4
// 0.687126
0x57F4
// 0.791793
0x6559
// 0.450806
0x39B4
// 0.857254
0x6DBB
// 0.103779
0x0D49
// 0.866772
0x6EF2
// 0.052627
0x06BC
// 0.228961
0x1D4F
// 0.479702
0x3D67
// 0.988195
0x7E7D
// 0.073056
0x095A
// 0.716525
0x5BB7
// 0.346232
0x2C51
// 0.040766
0x0538
// 0.774048
0x6314
// 0.484317
0x3DFE
// 0.253514
0x2073
// 0.186310
0x17D9
// 0.498707
0x3FD6
// 0.941175
0x7878
// 0.897112
0x72D5
// 0.756706
0x60DC
// 0.510568
0x415A
// 0.361185
0x2E3B
// 0.924279
0x764F
// 0.213337
0x1B4F
// 0.434672
0x37A3
// 0.608576
0x4DE6
// 0.488150
0x3E7C
// 0.216525
0x1BB7
// 0.137149
0x118E
// 0.659985
0x547A
// 0.176793
0x16A1
// 0.217174
0x1BCC
// 0.622483
0x4FAE
// 0.050904
0x0684
// 0.736709
0x5E4C
// 0.568254
0x48BD
// 0.295369
0x25CF
// 0.789799
0x6518
// 0.756526
0x60D6
// 0.261791
0x2182
// 0.779672
0x63CC
// 0.369407
0x2F49
// 0.317762
0x28AC
// 0.070755
0x090E
// 0.570782
0x490F
// 0.785270
0x6484
// 0.765575
0x61FE
// 0.093798
0x0C02
// 0.287046
0x24BE
// 0.164721
0x1516
// 0.669478
0x55B1
// 0.270905
0x22AD
// 0.528716
0x43AD
// 0.229784
0x1D6A
// 0.246877
0x1F9A
// 0.034023
0x045B
// 0.167404
0x156E
// 0.981554
0x7DA4
// 0.134720
0x113F
// 0.430314
0x3715
// 0.203442
0x1A0A
// 0.010579
0x015B
// 0.593494
0x4BF8
// 0.227444
0x1D1D
// 0.504467
0x4092
// 0.086099
0x0B05
// 0.061914
0x07ED
// 0.091971
0x0BC6
// 0.695435
0x5904
// 0.477607
0x3D22
// 0.559673
0x47A3
// 0.401697
0x336B
// 0.816674
0x6889
// 0.417955
0x3580
// 0.255284
0x20AD
// 0.138090
0x11AD
// 0.864719
0x6EAF
// 0.830540
0x6A4F
// 1.000000
0x7FFF
// 0.264740
0x21E3
// 0.256583
0x20D8
// 0.512447
0x4198
// 0.017940
0x024C
// 0.361380
0x2E42
// 0.167601
0x1574
// 0.116623
0x0EEE
// 0.954834
0x7A38
// 0.698154
0x595D
// 0.474653
0x3CC1
// 0.736439
0x5E44
// 0.523479
0x4301
// 0.669148
0x55A7
// 0.628036
0x5063
// 0.663049
0x54DF
// 0.784101
0x645D
// 0.150674
0x1349
// 0.425963
0x3686
// 0.903916
0x73B4
// 0.761962
0x6188
// 0.088827
0x0B5F
// 0.175334
0x1671
// 0.094504
0x0C19
// 0.839851
0x6B80
// 0.904541
0x73C8
// 0.611002
0x4E35
// 0.973025
0x7C8C
// 0.375334
0x300B
// 0.408567
0x344C
// 0.275563
0x2346
// 0.336170
0x2B08
// 0.684577
0x57A0
// 0.701685
0x59D1
// 0.879323
0x708E
// 0.851562
0x6D00
// 0.687842
0x580B
// 0.432475
0x375B
// 0.471428
0x3C58
// 0.498133
0x3FC3
// 0.884369
0x7133
// 0.540393
0x452C
// 0.690243
0x585A
// 0.406783
0x3411
// 0.119419
0x0F49
// 0.871600
0x6F91
// 0.590247
0x4B8D
// 0.829816
0x6A37
// 0.026947
0x0373
// 0.885707
0x715F
// 0.007491
0x00F5
// 0.019259
0x0277
// 0.355738
0x2D89
// 0.510329
0x4152
// 0.438521
0x3821
// 0.020706
0x02A6
// 0.808353
0x6778
// 0.556563
0x473D
// 0.168611
0x1595
// 0.640904
0x5209
// 0.929503
0x76FA
// 0.363973
0x2E97
// 0.806832
0x6746
// 0.228931
0x1D4E
// 0.006998
0x00E5
// 0.979839
0x7D6B
// 0.370853
0x2F78
// 0.723556
0x5C9D
// 0.328841
0x2A17
// 0.096281
0x0C53
// 0.699122
0x597D
// 0.057076
0x074E
// 0.321814
0x2931
// 0.781857
0x6414
// 0.563734
0x4828
// 0.079375
0x0A29
// 0.336694
0x2B19
// 0.516908
0x422A
// 0.000134
0x0004
// 0.158567
0x144C
// 0.227195
0x1D15
// 0.539051
0x4500
// 0.119377
0x0F48
// 0.085954
0x0B01
// 0.875148
0x7005
// 0.717698
0x5BDE
// 0.186023
0x17D0
// 0.260592
0x215B
// 0.066414
0x0880
// 0.188375
0x181D
// 0.692106
0x5897
// 0.295660
0x25D8
// 0.163717
0x14F5
// 0.381374
0x30D1
// 0.451327
0x39C5
// 0.853639
0x6D44
// 0.919007
0x75A2
// 0.515822
0x4206

102
Testing/Patterns/DSP/Support/SupportF16/Weights6_f16.txt
Unescape Escape View File

@ -0,0 +1,102 @@
H
50
// 0.873606
0x3afd
// 0.005892
0x1e09
// 0.669526
0x395b
// 0.198146
0x3257
// 0.032904
0x2836
// 0.829321
0x3aa2
// 0.044536
0x29b3
// 0.842708
0x3abe
// 0.981319
0x3bda
// 0.274000
0x3462
// 0.509194
0x3813
// 0.994965
0x3bf6
// 0.572766
0x3895
// 0.557596
0x3876
// 0.306704
0x34e8
// 0.983822
0x3bdf
// 0.145555
0x30a8
// 0.539088
0x3850
// 0.527526
0x3838
// 0.501409
0x3803
// 0.249480
0x33fc
// 0.273503
0x3460
// 0.567660
0x388b
// 0.741561
0x39ef
// 0.458026
0x3754
// 0.239162
0x33a7
// 0.731739
0x39db
// 0.662458
0x394d
// 0.024779
0x2658
// 0.086811
0x2d8e
// 0.660991
0x394a
// 0.834424
0x3aad
// 0.163672
0x313d
// 0.120432
0x2fb5
// 0.593488
0x38bf
// 0.973784
0x3bca
// 0.167473
0x315c
// 0.858171
0x3ade
// 0.986637
0x3be5
// 0.223556
0x3327
// 0.382377
0x361e
// 0.757667
0x3a10
// 0.032219
0x2820
// 0.574024
0x3898
// 0.125286
0x3002
// 0.946997
0x3b93
// 0.942443
0x3b8a
// 0.152563
0x30e2
// 0.240567
0x33b3
// 0.160261
0x3121

514
Testing/Patterns/DSP/Support/SupportF32/Samples11_f16.txt
Unescape Escape View File

@ -0,0 +1,514 @@
H
256
// 0.928092
0x3b6d
// 0.368183
0x35e4
// 0.571198
0x3892
// 0.792987
0x3a58
// 0.135043
0x3052
// 0.516565
0x3822
// 0.380247
0x3615
// 0.801799
0x3a6a
// 0.742622
0x39f1
// 0.298445
0x34c6
// 0.766190
0x3a21
// 0.804265
0x3a6f
// 0.564469
0x3884
// 0.081104
0x2d31
// 0.617799
0x38f1
// 0.820545
0x3a90
// 0.593758
0x38c0
// 0.701100
0x399c
// 0.773487
0x3a30
// 0.901279
0x3b36
// 0.159429
0x311a
// 0.334302
0x3559
// 0.501954
0x3804
// 0.996636
0x3bf9
// 0.691333
0x3988
// 0.082747
0x2d4c
// 0.099107
0x2e58
// 0.934495
0x3b7a
// 0.681699
0x3974
// 0.214758
0x32df
// 0.414598
0x36a2
// 0.881974
0x3b0e
// 0.794914
0x3a5c
// 0.233253
0x3377
// 0.225136
0x3334
// 0.285668
0x3492
// 0.980818
0x3bd9
// 0.081656
0x2d3a
// 0.275447
0x3468
// 0.091711
0x2ddf
// 0.305875
0x34e5
// 0.815844
0x3a87
// 0.326304
0x3539
// 0.638931
0x391d
// 0.768513
0x3a26
// 0.202206
0x3278
// 0.922609
0x3b62
// 0.792886
0x3a58
// 0.202354
0x327a
// 0.691668
0x3989
// 0.545673
0x385e
// 0.612396
0x38e6
// 0.496877
0x37f3
// 1.000000
0x3c00
// 0.085321
0x2d76
// 0.508319
0x3811
// 0.618905
0x38f4
// 0.966952
0x3bbc
// 0.149469
0x30c8
// 0.554524
0x3870
// 0.803000
0x3a6d
// 0.123715
0x2feb
// 0.318080
0x3517
// 0.222870
0x3322
// 0.536545
0x384b
// 0.310211
0x34f7
// 0.944334
0x3b8e
// 0.108977
0x2ef9
// 0.667889
0x3958
// 0.697683
0x3995
// 0.782407
0x3a42
// 0.980594
0x3bd8
// 0.746447
0x39f9
// 0.739605
0x39eb
// 0.162644
0x3134
// 0.109875
0x2f08
// 0.073911
0x2cbb
// 0.256218
0x3419
// 0.147305
0x30b7
// 0.798973
0x3a64
// 0.785710
0x3a49
// 0.406120
0x367f
// 0.958986
0x3bac
// 0.743674
0x39f3
// 0.377807
0x360b
// 0.197856
0x3255
// 0.993848
0x3bf3
// 0.305295
0x34e2
// 0.642877
0x3925
// 0.813812
0x3a83
// 0.406699
0x3682
// 0.347775
0x3590
// 0.402117
0x366f
// 0.350357
0x359b
// 0.863235
0x3ae8
// 0.087246
0x2d95
// 0.406586
0x3681
// 0.784430
0x3a47
// 0.088875
0x2db0
// 0.214557
0x32de
// 0.336660
0x3563
// 0.695285
0x3990
// 0.484991
0x37c3
// 0.604672
0x38d6
// 0.887005
0x3b19
// 0.625025
0x3900
// 0.442401
0x3714
// 0.649450
0x3932
// 0.535042
0x3848
// 0.566616
0x3888
// 0.702968
0x39a0
// 0.443387
0x3718
// 0.691643
0x3988
// 0.148938
0x30c4
// 0.422130
0x36c1
// 0.519010
0x3827
// 0.003557
0x1b49
// 0.353880
0x35a9
// 0.191210
0x321e
// 0.222550
0x331f
// 0.151175
0x30d6
// 0.451442
0x3739
// 0.178088
0x31b3
// 0.829812
0x3aa3
// 0.362210
0x35cc
// 0.023579
0x2609
// 0.240655
0x33b3
// 0.281067
0x347f
// 0.292393
0x34ae
// 0.495214
0x37ec
// 0.164700
0x3145
// 0.081812
0x2d3c
// 0.686087
0x397d
// 0.989710
0x3beb
// 0.534037
0x3846
// 0.953629
0x3ba1
// 0.470394
0x3787
// 0.589032
0x38b6
// 0.066748
0x2c46
// 0.591349
0x38bb
// 0.595815
0x38c4
// 0.199585
0x3263
// 0.964677
0x3bb8
// 0.957099
0x3ba8
// 0.314884
0x350a
// 0.363945
0x35d3
// 0.379587
0x3613
// 0.823508
0x3a97
// 0.476943
0x37a2
// 0.576599
0x389d
// 0.976197
0x3bcf
// 0.648911
0x3931
// 0.388403
0x3637
// 0.743286
0x39f2
// 0.651643
0x3937
// 0.582673
0x38a9
// 0.837353
0x3ab3
// 0.737360
0x39e6
// 0.463983
0x376c
// 0.669884
0x395c
// 0.480094
0x37ae
// 0.175549
0x319e
// 0.900248
0x3b34
// 0.901717
0x3b37
// 0.062953
0x2c07
// 0.292839
0x34af
// 0.152965
0x30e5
// 0.493216
0x37e4
// 0.674409
0x3965
// 0.766926
0x3a23
// 0.163727
0x313d
// 0.783660
0x3a45
// 0.774835
0x3a33
// 0.573664
0x3897
// 0.864757
0x3aeb
// 0.323017
0x352b
// 0.140309
0x307d
// 0.906016
0x3b40
// 0.413709
0x369f
// 0.692897
0x398b
// 0.052492
0x2ab8
// 0.775660
0x3a35
// 0.968980
0x3bc0
// 0.827482
0x3a9f
// 0.826842
0x3a9d
// 0.390995
0x3642
// 0.045299
0x29cc
// 0.717154
0x39bd
// 0.857862
0x3add
// 0.949625
0x3b99
// 0.849718
0x3acc
// 0.649719
0x3933
// 0.251719
0x3407
// 0.251616
0x3407
// 0.327955
0x353f
// 0.722739
0x39c8
// 0.975739
0x3bce
// 0.485316
0x37c4
// 0.988757
0x3be9
// 0.222821
0x3321
// 0.495650
0x37ee
// 0.299410
0x34ca
// 0.648484
0x3930
// 0.798967
0x3a64
// 0.168396
0x3163
// 0.921487
0x3b5f
// 0.611067
0x38e3
// 0.392697
0x3648
// 0.733527
0x39de
// 0.272622
0x345d
// 0.922768
0x3b62
// 0.002421
0x18f5
// 0.028643
0x2755
// 0.063584
0x2c12
// 0.646145
0x392b
// 0.825908
0x3a9b
// 0.394134
0x364e
// 0.145785
0x30aa
// 0.887541
0x3b1a
// 0.112269
0x2f2f
// 0.316360
0x3510
// 0.962913
0x3bb4
// 0.613137
0x38e8
// 0.037422
0x28ca
// 0.754094
0x3a08
// 0.655590
0x393f
// 0.505835
0x380c
// 0.101144
0x2e79
// 0.566300
0x3888
// 0.005654
0x1dca
// 0.017671
0x2486
// 0.762087
0x3a19
// 0.279619
0x3479
// 0.528099
0x383a
// 0.054468
0x2af9
// 0.897809
0x3b2f
// 0.279912
0x347b
// 0.092985
0x2df3
// 0.001031
0x1439
// 0.493187
0x37e4
// 0.668156
0x3958
// 0.095851
0x2e22
// 0.074376
0x2cc3
// 0.053116
0x2acd
// 0.086791
0x2d8e
// 0.546554
0x385f
// 0.841710
0x3abc
// 0.920885
0x3b5e
// 0.460475
0x375e
// 0.473652
0x3794
// 0.995239
0x3bf6
// 0.933960
0x3b79
// 0.432443
0x36eb
// 0.068078
0x2c5b
// 0.218448
0x32fe
// 0.882461
0x3b0f

514
Testing/Patterns/DSP/Support/SupportQ15/Samples11_f16.txt
Unescape Escape View File

@ -0,0 +1,514 @@
H
256
// 0.828976
0x3aa2
// 0.701268
0x399c
// 0.851200
0x3acf
// 0.961544
0x3bb1
// 0.473197
0x3792
// 0.101768
0x2e83
// 0.966664
0x3bbc
// 0.071066
0x2c8c
// 0.724660
0x39cc
// 0.657955
0x3943
// 0.781047
0x3a40
// 0.540825
0x3854
// 0.089603
0x2dbc
// 0.386455
0x362f
// 0.267020
0x3446
// 0.024196
0x2632
// 0.177265
0x31ac
// 0.448938
0x372f
// 0.429568
0x36e0
// 0.846378
0x3ac5
// 0.028887
0x2765
// 0.414852
0x36a3
// 0.594031
0x38c1
// 0.915098
0x3b52
// 0.734150
0x39e0
// 0.566120
0x3887
// 0.582418
0x38a9
// 0.333086
0x3554
// 0.794628
0x3a5b
// 0.795664
0x3a5e
// 0.373510
0x35fa
// 0.865132
0x3aec
// 0.647046
0x392d
// 0.660646
0x3949
// 0.669314
0x395b
// 0.149604
0x30ca
// 0.814072
0x3a83
// 0.195463
0x3241
// 0.590355
0x38b9
// 0.610765
0x38e3
// 0.429719
0x36e0
// 0.925605
0x3b68
// 0.465498
0x3773
// 0.282325
0x3484
// 0.921245
0x3b5f
// 0.349939
0x3599
// 0.203195
0x3281
// 0.810807
0x3a7d
// 0.520470
0x382a
// 0.831099
0x3aa6
// 0.182119
0x31d4
// 0.671885
0x3960
// 0.156237
0x3100
// 0.508236
0x3811
// 0.304914
0x34e1
// 0.459547
0x375a
// 0.982341
0x3bdc
// 0.586868
0x38b2
// 0.663244
0x394e
// 0.247314
0x33ea
// 0.381579
0x361b
// 0.963080
0x3bb4
// 0.785647
0x3a49
// 0.694654
0x398f
// 0.176717
0x31a8
// 0.743054
0x39f2
// 0.258432
0x3423
// 0.780450
0x3a3e
// 0.472522
0x378f
// 0.015113
0x23bd
// 0.213243
0x32d3
// 0.825883
0x3a9b
// 0.210115
0x32b9
// 0.317289
0x3514
// 0.885566
0x3b16
// 0.684442
0x397a
// 0.309746
0x34f5
// 0.037463
0x28cc
// 0.446993
0x3727
// 0.962961
0x3bb4
// 0.912866
0x3b4e
// 0.686169
0x397d
// 0.445227
0x3720
// 0.024713
0x2654
// 0.205483
0x3293
// 0.335312
0x355d
// 0.804661
0x3a70
// 0.363307
0x35d0
// 0.393693
0x364d
// 0.207496
0x32a4
// 0.942392
0x3b8a
// 0.178303
0x31b5
// 0.571629
0x3893
// 0.242732
0x33c4
// 0.049779
0x2a5f
// 0.449441
0x3731
// 0.685840
0x397d
// 0.161048
0x3127
// 0.941780
0x3b89
// 0.374247
0x35fd
// 0.644811
0x3929
// 0.536383
0x384b
// 0.605545
0x38d8
// 0.696571
0x3993
// 0.887784
0x3b1a
// 0.746876
0x39fa
// 0.438161
0x3703
// 0.320703
0x3522
// 0.191811
0x3223
// 0.381322
0x361a
// 0.724961
0x39cd
// 0.858548
0x3ade
// 0.608865
0x38df
// 0.705759
0x39a5
// 0.026812
0x26dd
// 0.760236
0x3a15
// 0.781340
0x3a40
// 0.505424
0x380b
// 0.518898
0x3827
// 0.292720
0x34af
// 0.295414
0x34ba
// 0.143398
0x3097
// 0.204531
0x328c
// 0.448830
0x372e
// 0.408056
0x3687
// 0.124796
0x2ffd
// 0.226856
0x3342
// 0.281641
0x3482
// 0.316026
0x350e
// 0.632438
0x390f
// 0.849437
0x3acc
// 0.544719
0x385c
// 0.378390
0x360e
// 0.502774
0x3806
// 0.106363
0x2ecf
// 0.751638
0x3a03
// 0.015356
0x23dd
// 0.652852
0x3939
// 0.884592
0x3b14
// 0.198046
0x3256
// 0.120470
0x2fb6
// 0.281926
0x3483
// 0.382527
0x361f
// 0.554751
0x3870
// 0.444027
0x371b
// 0.471118
0x378a
// 0.957779
0x3baa
// 0.426181
0x36d2
// 0.524349
0x3832
// 0.768101
0x3a25
// 0.147446
0x30b8
// 0.416878
0x36ac
// 0.088127
0x2da4
// 0.448862
0x372f
// 0.524513
0x3832
// 0.832445
0x3aa9
// 0.698128
0x3996
// 0.484999
0x37c3
// 0.902391
0x3b38
// 0.433745
0x36f1
// 0.010281
0x2144
// 0.179654
0x31c0
// 0.936824
0x3b7f
// 0.556005
0x3873
// 0.563006
0x3881
// 0.398727
0x3661
// 0.779867
0x3a3d
// 0.200420
0x326a
// 0.979296
0x3bd6
// 0.698000
0x3996
// 0.897483
0x3b2e
// 0.508605
0x3812
// 0.826625
0x3a9d
// 0.193984
0x3235
// 0.520778
0x382b
// 0.135033
0x3052
// 0.637960
0x391b
// 1.000000
0x3c00
// 0.530107
0x383e
// 0.297845
0x34c4
// 0.618321
0x38f2
// 0.053367
0x2ad5
// 0.938301
0x3b82
// 0.854077
0x3ad5
// 0.640969
0x3921
// 0.902974
0x3b39
// 0.174120
0x3192
// 0.047430
0x2a12
// 0.838782
0x3ab6
// 0.726417
0x39d0
// 0.131666
0x3037
// 0.095405
0x2e1b
// 0.382679
0x361f
// 0.569925
0x388f
// 0.562668
0x3880
// 0.495394
0x37ed
// 0.615876
0x38ed
// 0.629130
0x3908
// 0.048796
0x2a3f
// 0.068318
0x2c5f
// 0.760713
0x3a16
// 0.705848
0x39a6
// 0.850479
0x3ace
// 0.088611
0x2dac
// 0.259089
0x3425
// 0.524642
0x3832
// 0.231038
0x3365
// 0.374284
0x35fd
// 0.092343
0x2de9
// 0.008590
0x2066
// 0.850167
0x3acd
// 0.772895
0x3a2f
// 0.275516
0x3469
// 0.338602
0x356b
// 0.436539
0x36fc
// 0.890658
0x3b20
// 0.642485
0x3924
// 0.905353
0x3b3e
// 0.548387
0x3863
// 0.262145
0x3432
// 0.184135
0x31e4
// 0.093348
0x2df9
// 0.746791
0x39f9
// 0.279910
0x347b
// 0.429754
0x36e0
// 0.317862
0x3516
// 0.646375
0x392c
// 0.022641
0x25cc
// 0.175964
0x31a1
// 0.641328
0x3921
// 0.706863
0x39a8
// 0.387399
0x3633
// 0.882597
0x3b10
// 0.726396
0x39d0
// 0.147333
0x30b7
// 0.638180
0x391b
// 0.127333
0x3013
// 0.662982
0x394e
// 0.566727
0x3889
// 0.939104
0x3b83
// 0.785249
0x3a48
// 0.464104
0x376d
// 0.550282
0x3867
// 0.948345
0x3b96
// 0.221296
0x3315
// 0.403497
0x3675
// 0.230993
0x3364
// 0.917234
0x3b56
// 0.321136
0x3523
// 0.420607
0x36bb
// 0.381449
0x361a
// 0.552719
0x386c
// 0.939476
0x3b84
// 0.100416
0x2e6d
// 0.357449
0x35b8
// 0.316799
0x3512

258
Testing/Patterns/DSP/SupportBarF16/Coefs1_f16.txt
Unescape Escape View File

@ -0,0 +1,258 @@
H
128
// 0.956870
0x3ba8
// 0.496988
0x37f4
// 0.081595
0x2d39
// 0.409254
0x368c
// 0.303503
0x34db
// 0.214610
0x32de
// 0.692067
0x3989
// 0.663186
0x394e
// 0.421168
0x36bd
// 0.565000
0x3885
// 0.848443
0x3aca
// 0.251959
0x3408
// 0.906224
0x3b40
// 0.225606
0x3338
// 0.334127
0x3559
// 0.361348
0x35c8
// 0.538468
0x384f
// 0.566696
0x3889
// 0.782401
0x3a42
// 0.881794
0x3b0e
// 0.666430
0x3955
// 0.911880
0x3b4c
// 0.139435
0x3076
// 0.588459
0x38b5
// 0.780194
0x3a3e
// 0.835910
0x3ab0
// 0.065313
0x2c2e
// 0.619731
0x38f5
// 0.284354
0x348d
// 0.022623
0x25cb
// 0.038803
0x28f7
// 0.946211
0x3b92
// 0.100064
0x2e67
// 0.829055
0x3aa2
// 0.173715
0x318f
// 0.553661
0x386e
// 0.326809
0x353b
// 0.940537
0x3b86
// 0.787262
0x3a4c
// 0.849207
0x3acb
// 0.214522
0x32dd
// 0.289448
0x34a2
// 0.224730
0x3331
// 0.628871
0x3908
// 0.156498
0x3102
// 0.890163
0x3b1f
// 0.009359
0x20cb
// 0.577976
0x38a0
// 0.658599
0x3945
// 0.699156
0x3998
// 0.001193
0x14e3
// 0.314851
0x350a
// 0.192745
0x322b
// 0.301540
0x34d3
// 0.438487
0x3704
// 0.813333
0x3a82
// 0.694723
0x398f
// 0.280421
0x347d
// 0.430809
0x36e5
// 0.419525
0x36b6
// 0.436903
0x36fe
// 0.620851
0x38f8
// 0.321395
0x3524
// 0.604003
0x38d5
// 0.185005
0x31ec
// 0.488674
0x37d2
// 0.650474
0x3934
// 0.869135
0x3af4
// 0.713748
0x39b6
// 0.520951
0x382b
// 0.362701
0x35ce
// 0.699791
0x3999
// 0.427493
0x36d7
// 0.047511
0x2a15
// 0.098553
0x2e4f
// 0.423265
0x36c6
// 0.970148
0x3bc3
// 0.136748
0x3060
// 0.918154
0x3b58
// 0.515897
0x3821
// 0.244997
0x33d7
// 0.369781
0x35eb
// 0.613708
0x38e9
// 0.520651
0x382a
// 0.326945
0x353b
// 0.682006
0x3975
// 0.074692
0x2cc8
// 0.137713
0x3068
// 0.208111
0x32a9
// 0.634047
0x3913
// 0.857670
0x3add
// 0.507829
0x3810
// 0.358574
0x35bd
// 0.376590
0x3607
// 0.297378
0x34c2
// 0.066621
0x2c44
// 0.441345
0x3710
// 0.812919
0x3a81
// 0.443154
0x3717
// 0.122853
0x2fdd
// 0.910393
0x3b48
// 0.586902
0x38b2
// 0.813573
0x3a82
// 0.730396
0x39d8
// 0.558675
0x3878
// 0.494916
0x37eb
// 0.334836
0x355b
// 0.332451
0x3552
// 0.075775
0x2cd9
// 0.659524
0x3947
// 0.026518
0x26ca
// 0.305520
0x34e3
// 0.529187
0x383c
// 0.878764
0x3b08
// 0.419737
0x36b7
// 0.812553
0x3a80
// 0.424012
0x36c9
// 0.129471
0x3025
// 0.931772
0x3b74
// 0.547770
0x3862
// 0.340727
0x3574
// 0.020064
0x2523
// 0.785738
0x3a49
// 0.683353
0x3978
// 0.058463
0x2b7c
// 0.145155
0x30a5
// 0.228796
0x3352
// 0.898074
0x3b2f

44
Testing/Patterns/DSP/SupportBarF16/Dims1_s16.txt
Unescape Escape View File

@ -0,0 +1,44 @@
H
21
// 10
0x000A
// 4
0x0004
// 4
0x0004
// 8
0x0008
// 4
0x0004
// 9
0x0009
// 4
0x0004
// 4
0x0004
// 8
0x0008
// 8
0x0008
// 8
0x0008
// 9
0x0009
// 8
0x0008
// 4
0x0004
// 9
0x0009
// 8
0x0008
// 9
0x0009
// 9
0x0009
// 9
0x0009
// 4
0x0004
// 4
0x0004

916
Testing/Patterns/DSP/SupportBarF16/Inputs1_f16.txt
Unescape Escape View File

@ -0,0 +1,916 @@
H
457
// 0.106532
0x2ed1
// 0.497532
0x37f6
// 0.890575
0x3b20
// 0.103215
0x2e9b
// 0.358456
0x35bc
// 0.854112
0x3ad5
// 0.261257
0x342e
// 0.542976
0x3858
// 0.113934
0x2f4b
// 0.307220
0x34ea
// 0.889834
0x3b1e
// 0.491050
0x37db
// 0.478087
0x37a6
// 0.606903
0x38db
// 0.294450
0x34b6
// 0.782827
0x3a43
// 0.853677
0x3ad4
// 0.997263
0x3bfa
// 0.459460
0x375a
// 0.278292
0x3474
// 0.810761
0x3a7c
// 0.546945
0x3860
// 0.229528
0x3358
// 0.250174
0x3401
// 0.534174
0x3846
// 0.734461
0x39e0
// 0.284537
0x348d
// 0.622315
0x38fb
// 0.331570
0x354e
// 0.098499
0x2e4e
// 0.480378
0x37b0
// 0.149973
0x30cd
// 0.901256
0x3b36
// 0.094658
0x2e0f
// 0.509299
0x3813
// 0.712161
0x39b3
// 0.253065
0x340d
// 0.688482
0x3982
// 0.037197
0x28c3
// 0.216806
0x32f0
// 0.545384
0x385d
// 0.349946
0x3599
// 0.715045
0x39b8
// 0.379354
0x3612
// 0.355904
0x35b2
// 0.459737
0x375b
// 0.646989
0x392d
// 0.992873
0x3bf1
// 0.825026
0x3a9a
// 0.970865
0x3bc4
// 0.503469
0x3807
// 0.727272
0x39d1
// 0.526058
0x3835
// 0.701132
0x399c
// 0.005002
0x1d1f
// 0.119965
0x2fae
// 0.150103
0x30ce
// 0.533007
0x3844
// 0.687298
0x3980
// 0.892531
0x3b24
// 0.374709
0x35ff
// 0.797878
0x3a62
// 0.994900
0x3bf6
// 0.699639
0x3999
// 0.623257
0x38fc
// 0.034240
0x2862
// 0.330431
0x3549
// 0.566860
0x3889
// 0.037405
0x28ca
// 0.987313
0x3be6
// 0.755930
0x3a0c
// 0.171740
0x317f
// 0.051787
0x2aa1
// 0.292910
0x34b0
// 0.555473
0x3872
// 0.704891
0x39a4
// 0.017726
0x248a
// 0.943475
0x3b8c
// 0.339683
0x356f
// 0.755757
0x3a0c
// 0.944164
0x3b8e
// 0.858374
0x3ade
// 0.087285
0x2d96
// 0.801996
0x3a6a
// 0.402872
0x3672
// 0.154085
0x30ee
// 0.342052
0x3579
// 0.548381
0x3863
// 0.703609
0x39a1
// 0.982697
0x3bdd
// 0.927849
0x3b6c
// 0.730443
0x39d8
// 0.804695
0x3a70
// 0.914025
0x3b50
// 0.746629
0x39f9
// 0.656496
0x3941
// 0.177815
0x31b1
// 0.178128
0x31b3
// 0.051356
0x2a93
// 0.419791
0x36b7
// 0.309380
0x34f3
// 0.317794
0x3516
// 0.780728
0x3a3f
// 0.194890
0x323d
// 0.937657
0x3b80
// 0.600412
0x38ce
// 0.084162
0x2d63
// 0.758037
0x3a10
// 0.342404
0x357a
// 0.926317
0x3b69
// 0.658135
0x3944
// 0.320361
0x3520
// 0.132661
0x303f
// 0.880571
0x3b0b
// 0.577278
0x389e
// 0.049056
0x2a47
// 0.326281
0x3538
// 0.144631
0x30a1
// 0.837326
0x3ab3
// 0.156820
0x3105
// 0.294280
0x34b5
// 0.888939
0x3b1d
// 0.444398
0x371c
// 0.656293
0x3940
// 0.115350
0x2f62
// 0.598086
0x38c9
// 0.066242
0x2c3d
// 0.970696
0x3bc4
// 0.107737
0x2ee5
// 0.696892
0x3993
// 0.936636
0x3b7e
// 0.292485
0x34ae
// 0.889192
0x3b1d
// 0.693133
0x398c
// 0.494239
0x37e8
// 0.496147
0x37f0
// 0.863516
0x3ae8
// 0.901431
0x3b36
// 0.241817
0x33bd
// 0.684517
0x397a
// 0.692455
0x398a
// 0.028141
0x2734
// 0.654344
0x393c
// 0.486245
0x37c8
// 0.184763
0x31ea
// 0.995113
0x3bf6
// 0.729885
0x39d7
// 0.524312
0x3832
// 0.714227
0x39b7
// 0.975591
0x3bce
// 0.286107
0x3494
// 0.606811
0x38db
// 0.668256
0x3959
// 0.152148
0x30de
// 0.214849
0x32e0
// 0.545604
0x385d
// 0.258044
0x3421
// 0.549518
0x3865
// 0.841156
0x3abb
// 0.189413
0x3210
// 0.996621
0x3bf9
// 0.287922
0x349b
// 0.221245
0x3314
// 0.344532
0x3583
// 0.993528
0x3bf3
// 0.326025
0x3537
// 0.518455
0x3826
// 0.949073
0x3b98
// 0.605328
0x38d8
// 0.339441
0x356e
// 0.228574
0x3350
// 0.504492
0x3809
// 0.469137
0x3782
// 0.413322
0x369d
// 0.211035
0x32c1
// 0.742830
0x39f1
// 0.136245
0x305c
// 0.662443
0x394d
// 0.783605
0x3a45
// 0.287021
0x3498
// 0.269690
0x3451
// 0.733263
0x39de
// 0.880451
0x3b0b
// 0.149646
0x30ca
// 0.285272
0x3490
// 0.529097
0x383c
// 0.400435
0x3668
// 0.246495
0x33e3
// 0.363495
0x35d1
// 0.961290
0x3bb1
// 0.472452
0x378f
// 0.880793
0x3b0c
// 0.550834
0x3868
// 0.922244
0x3b61
// 0.122864
0x2fdd
// 0.742086
0x39f0
// 0.755626
0x3a0c
// 0.855235
0x3ad8
// 0.545651
0x385d
// 0.449006
0x372f
// 0.949097
0x3b98
// 0.248140
0x33f1
// 0.492785
0x37e2
// 0.174517
0x3196
// 0.584683
0x38ad
// 0.067141
0x2c4c
// 0.705132
0x39a4
// 0.142734
0x3091
// 0.761568
0x3a18
// 0.188330
0x3207
// 0.642043
0x3923
// 0.060400
0x2bbb
// 0.385549
0x362b
// 0.566511
0x3888
// 0.168163
0x3162
// 0.994637
0x3bf5
// 0.416822
0x36ab
// 0.673274
0x3963
// 0.762820
0x3a1a
// 0.834400
0x3aad
// 0.015293
0x23d4
// 0.600474
0x38ce
// 0.887300
0x3b19
// 0.344693
0x3584
// 0.911028
0x3b4a
// 0.002469
0x190f
// 0.023051
0x25e7
// 0.923237
0x3b63
// 0.072783
0x2ca8
// 0.843013
0x3abe
// 0.978769
0x3bd5
// 0.440241
0x370b
// 0.101018
0x2e77
// 0.409853
0x368f
// 0.291902
0x34ac
// 0.358003
0x35ba
// 0.143726
0x3099
// 0.343093
0x357d
// 0.791579
0x3a55
// 0.698913
0x3997
// 0.108603
0x2ef3
// 0.425104
0x36cd
// 0.229301
0x3356
// 0.004892
0x1d02
// 0.122730
0x2fdb
// 0.814980
0x3a85
// 0.699480
0x3999
// 0.933123
0x3b77
// 0.410716
0x3692
// 0.629022
0x3908
// 0.404001
0x3677
// 0.926749
0x3b6a
// 0.846361
0x3ac5
// 0.393694
0x364d
// 0.902288
0x3b38
// 0.877114
0x3b04
// 0.675889
0x3968
// 0.530479
0x383e
// 0.728947
0x39d5
// 0.160219
0x3121
// 0.383383
0x3622
// 0.938769
0x3b83
// 0.663370
0x394f
// 0.130596
0x302e
// 0.260151
0x342a
// 0.459305
0x3759
// 0.994542
0x3bf5
// 0.646101
0x392b
// 0.703211
0x39a0
// 0.473974
0x3795
// 0.318692
0x3519
// 0.548940
0x3864
// 0.779865
0x3a3d
// 0.115493
0x2f64
// 0.764128
0x3a1d
// 0.465078
0x3771
// 0.277470
0x3471
// 0.213156
0x32d2
// 0.711328
0x39b1
// 0.409489
0x368d
// 0.374492
0x35fe
// 0.436086
0x36fa
// 0.755892
0x3a0c
// 0.420576
0x36bb
// 0.102711
0x2e93
// 0.849385
0x3acc
// 0.103311
0x2e9d
// 0.078602
0x2d08
// 0.664105
0x3950
// 0.255307
0x3416
// 0.657774
0x3943
// 0.020228
0x252e
// 0.182071
0x31d4
// 0.094825
0x2e12
// 0.590074
0x38b8
// 0.237071
0x3396
// 0.242629
0x33c4
// 0.157773
0x310c
// 0.209353
0x32b3
// 0.083905
0x2d5f
// 0.146740
0x30b2
// 0.549354
0x3865
// 0.603150
0x38d3
// 0.718786
0x39c0
// 0.660831
0x3949
// 0.126985
0x3010
// 0.248071
0x33f0
// 0.138655
0x3070
// 0.528400
0x383a
// 0.060976
0x2bce
// 0.268160
0x344a
// 0.913489
0x3b4f
// 0.730158
0x39d7
// 0.268330
0x344b
// 0.353510
0x35a8
// 0.517134
0x3823
// 0.893552
0x3b26
// 0.682193
0x3975
// 0.055199
0x2b11
// 0.157574
0x310b
// 0.194217
0x3237
// 0.102369
0x2e8d
// 0.518361
0x3826
// 0.856828
0x3adb
// 0.464607
0x376f
// 0.243317
0x33c9
// 0.242768
0x33c5
// 0.175030
0x319a
// 0.925239
0x3b67
// 0.404016
0x3677
// 0.110742
0x2f16
// 0.253367
0x340e
// 0.166016
0x3150
// 0.188217
0x3206
// 0.155232
0x30f8
// 0.568907
0x388d
// 0.002015
0x1821
// 0.561031
0x387d
// 0.442068
0x3713
// 0.010218
0x213b
// 0.857135
0x3adb
// 0.599827
0x38cc
// 0.484476
0x37c0
// 0.912910
0x3b4e
// 0.451951
0x373b
// 0.774223
0x3a32
// 0.844909
0x3ac2
// 0.830782
0x3aa5
// 0.116712
0x2f78
// 0.021514
0x2582
// 0.056437
0x2b39
// 0.871867
0x3afa
// 0.998460
0x3bfd
// 0.533033
0x3844
// 0.733385
0x39de
// 0.635822
0x3916
// 0.066906
0x2c48
// 0.003334
0x1ad4
// 0.950727
0x3b9b
// 0.890833
0x3b20
// 0.689737
0x3985
// 0.443086
0x3717
// 0.325795
0x3536
// 0.304570
0x34e0
// 0.654455
0x393c
// 0.123053
0x2fe0
// 0.441562
0x3711
// 0.615594
0x38ed
// 0.005671
0x1dcf
// 0.659235
0x3946
// 0.484417
0x37c0
// 0.913067
0x3b4e
// 0.385005
0x3629
// 0.496434
0x37f1
// 0.655609
0x393f
// 0.980828
0x3bd9
// 0.164783
0x3146
// 0.593037
0x38bf
// 0.438637
0x3705
// 0.675532
0x3967
// 0.509535
0x3814
// 0.433838
0x36f1
// 0.671372
0x395f
// 0.097221
0x2e39
// 0.399143
0x3663
// 0.525347
0x3834
// 0.738948
0x39e9
// 0.570479
0x3890
// 0.915263
0x3b52
// 0.429515
0x36df
// 0.163260
0x3139
// 0.469480
0x3783
// 0.527657
0x3839
// 0.645856
0x392b
// 0.727361
0x39d2
// 0.604323
0x38d6
// 0.069401
0x2c71
// 0.509907
0x3814
// 0.294041
0x34b4
// 0.257267
0x341e
// 0.601742
0x38d0
// 0.629847
0x390a
// 0.277914
0x3472
// 0.543382
0x3859
// 0.556401
0x3874
// 0.086856
0x2d8f
// 0.368224
0x35e4
// 0.321791
0x3526
// 0.159132
0x3118
// 0.982855
0x3bdd
// 0.481969
0x37b6
// 0.496734
0x37f3
// 0.454984
0x3748
// 0.606968
0x38db
// 0.712903
0x39b4
// 0.400385
0x3668
// 0.073094
0x2cae
// 0.484467
0x37c0
// 0.858089
0x3add
// 0.417460
0x36ae
// 0.675354
0x3967
// 0.160686
0x3124
// 0.629910
0x390a
// 0.149919
0x30cc
// 0.019615
0x2505
// 0.805168
0x3a71
// 0.935126
0x3b7b
// 0.945230
0x3b90
// 0.542654
0x3857
// 0.970170
0x3bc3
// 0.940751
0x3b87
// 0.105790
0x2ec5
// 0.337515
0x3566
// 0.709871
0x39ae
// 0.798114
0x3a63
// 0.660907
0x394a
// 0.969733
0x3bc2
// 0.809610
0x3a7a
// 0.854374
0x3ad6
// 0.689805
0x3985
// 0.153979
0x30ed
// 0.577720
0x389f
// 0.695944
0x3991
// 0.213619
0x32d6
// 0.215322
0x32e4
// 0.255341
0x3416
// 0.103505
0x2ea0
// 0.120335
0x2fb4
// 0.513636
0x381c
// 0.482140
0x37b7
// 0.450196
0x3734
// 0.658834
0x3945
// 0.768260
0x3a25
// 0.570194
0x3890
// 0.640953
0x3921
// 0.239049
0x33a6
// 0.152443
0x30e1

136
Testing/Patterns/DSP/SupportBarF16/Ref1_f16.txt
Unescape Escape View File

@ -0,0 +1,136 @@
H
67
// 0.327704
0x353e
// 0.665135
0x3952
// 0.448036
0x372b
// 0.515265
0x381f
// 0.551816
0x386a
// 0.551472
0x3869
// 0.439659
0x3709
// 0.502080
0x3804
// 0.295175
0x34b9
// 0.678826
0x396e
// 0.471628
0x378c
// 0.625753
0x3902
// 0.389009
0x3639
// 0.525265
0x3834
// 0.750672
0x3a01
// 0.288296
0x349d
// 0.666572
0x3955
// 0.594229
0x38c1
// 0.178227
0x31b4
// 0.568369
0x388c
// 0.512687
0x381a
// 0.473645
0x3794
// 0.406305
0x3680
// 0.646267
0x392c
// 0.372201
0x35f5
// 0.589026
0x38b6
// 0.538939
0x3850
// 0.451800
0x373b
// 0.255620
0x3417
// 0.604975
0x38d7
// 0.783135
0x3a44
// 0.434926
0x36f5
// 0.500915
0x3802
// 0.385077
0x3629
// 0.329215
0x3544
// 0.445282
0x3720
// 0.515997
0x3821
// 0.488761
0x37d2
// 0.534970
0x3848
// 0.458699
0x3757
// 0.565399
0x3886
// 0.428392
0x36db
// 0.608847
0x38df
// 0.257330
0x341e
// 0.391524
0x3644
// 0.499636
0x37ff
// 0.494076
0x37e8
// 0.519520
0x3828
// 0.187670
0x3201
// 0.448629
0x372e
// 0.318067
0x3517
// 0.260116
0x3429
// 0.522119
0x382d
// 0.505605
0x380b
// 0.358237
0x35bb
// 0.522214
0x382d
// 0.616310
0x38ee
// 0.450732
0x3736
// 0.709664
0x39ad
// 0.591168
0x38bb
// 0.702376
0x399e
// 0.563923
0x3883
// 0.434761
0x36f5
// 0.304614
0x34e0
// 0.188790
0x320b
// 0.161440
0x312b
// 0.491055
0x37db

3842
Testing/Patterns/DSP/SupportBarF16/Samples1_f16.txt
View File

File diff suppressed because it is too large Load Diff

136
Testing/Patterns/DSP/SupportBarF16/Weights1_f16.txt
Unescape Escape View File

@ -0,0 +1,136 @@
H
67
// 0.586587
0x38b1
// 0.967413
0x3bbd
// 0.103899
0x2ea6
// 0.812563
0x3a80
// 0.700588
0x399b
// 0.072419
0x2ca3
// 0.025789
0x269a
// 0.160875
0x3126
// 0.449514
0x3731
// 0.679843
0x3970
// 0.313259
0x3503
// 0.746796
0x39f9
// 0.052101
0x2aab
// 0.758290
0x3a11
// 0.750161
0x3a00
// 0.734067
0x39df
// 0.190501
0x3219
// 0.362815
0x35ce
// 0.926594
0x3b6a
// 0.965030
0x3bb8
// 0.573280
0x3896
// 0.002884
0x19e8
// 0.216499
0x32ee
// 0.960992
0x3bb0
// 0.289942
0x34a4
// 0.734115
0x39df
// 0.773575
0x3a30
// 0.139824
0x3079
// 0.237692
0x339b
// 0.705432
0x39a5
// 0.176470
0x31a6
// 0.608995
0x38df
// 0.946655
0x3b93
// 0.715297
0x39b9
// 0.489275
0x37d4
// 0.142748
0x3091
// 0.927856
0x3b6c
// 0.051195
0x2a8e
// 0.822680
0x3a95
// 0.851382
0x3ad0
// 0.333856
0x3557
// 0.417365
0x36ae
// 0.177323
0x31ad
// 0.381014
0x3619
// 0.684170
0x3979
// 0.794994
0x3a5c
// 0.796380
0x3a5f
// 0.306946
0x34e9
// 0.304410
0x34df
// 0.877385
0x3b05
// 0.547589
0x3861
// 0.583798
0x38ac
// 0.114610
0x2f56
// 0.639137
0x391d
// 0.083052
0x2d51
// 0.854577
0x3ad6
// 0.235748
0x338b
// 0.537383
0x384d
// 0.801044
0x3a69
// 0.237114
0x3396
// 0.050423
0x2a74
// 0.595702
0x38c4
// 0.764289
0x3a1d
// 0.079631
0x2d19
// 0.821178
0x3a92
// 0.054163
0x2aef
// 0.034259
0x2863

67
Testing/Source/Tests/SupportBarTestsF16.cpp
Unescape Escape View File

@ -0,0 +1,67 @@
#include "SupportBarTestsF16.h"
#include <stdio.h>
#include "Error.h"
#include "Test.h"
void SupportBarTestsF16::test_barycenter_f16()
{
const float16_t *inp = input.ptr();
const float16_t *coefsp = coefs.ptr();
const int16_t *dimsp=dims.ptr();
int nbVecs;
int vecDim;
float16_t *outp = output.ptr();
for(int i=0; i < this->nbTests ; i ++)
{
nbVecs = dimsp[2*i+1];
vecDim = dimsp[2*i+2];
arm_barycenter_f16(inp, coefsp,
outp,
nbVecs,
vecDim);
inp += vecDim * nbVecs;
coefsp += nbVecs;
outp += vecDim;
}
ASSERT_NEAR_EQ(output,ref,(float16_t)1e-3);
ASSERT_EMPTY_TAIL(output);
}
void SupportBarTestsF16::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
{
(void)paramsArgs;
dims.reload(SupportBarTestsF16::DIM_S16_ID,mgr);
const int16_t *dimsp=dims.ptr();
this->nbTests=dimsp[0];
switch(id)
{
case TEST_BARYCENTER_F16_1:
input.reload(SupportBarTestsF16::SAMPLES_F16_ID,mgr);
coefs.reload(SupportBarTestsF16::COEFS_F16_ID,mgr);
ref.reload(SupportBarTestsF16::REF_F16_ID,mgr);
output.create(ref.nbSamples(),SupportBarTestsF16::OUT_SAMPLES_F16_ID,mgr);
break;
}
}
void SupportBarTestsF16::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
{
(void)id;
output.dump(mgr);
}

315
Testing/Source/Tests/SupportTestsF16.cpp
Unescape Escape View File

@ -0,0 +1,315 @@
#include "SupportTestsF16.h"
#include <stdlib.h>
#include <stdio.h>
#include "Error.h"
#include "Test.h"
#define SNR_THRESHOLD 120
#define REL_ERROR (1.0e-5)
#define REL_WEIGHTEDSUM_ERROR (2.0e-2)
#define REL_ERROR_F32 (1.0e-3)
#define ABS_Q15_ERROR ((q15_t)10)
#define ABS_Q31_ERROR ((q31_t)80)
#define ABS_Q7_ERROR ((q7_t)10)
void SupportTestsF16::test_weighted_sum_f16()
{
const float16_t *inp = input.ptr();
const float16_t *coefsp = coefs.ptr();
float16_t *refp = ref.ptr();
float16_t *outp = output.ptr();
*outp=arm_weighted_sum_f16(inp, coefsp,this->nbSamples);
ASSERT_REL_ERROR(*outp,refp[this->offset],REL_WEIGHTEDSUM_ERROR);
ASSERT_EMPTY_TAIL(output);
}
void SupportTestsF16::test_copy_f16()
{
const float16_t *inp = input.ptr();
float16_t *outp = output.ptr();
arm_copy_f16(inp, outp,this->nbSamples);
ASSERT_EQ(input,output);
ASSERT_EMPTY_TAIL(output);
}
void SupportTestsF16::test_fill_f16()
{
float16_t *outp = output.ptr();
float16_t val = 1.1;
int i;
arm_fill_f16(val, outp,this->nbSamples);
for(i=0 ; i < this->nbSamples; i++)
{
ASSERT_EQ(val,outp[i]);
}
ASSERT_EMPTY_TAIL(output);
}
void SupportTestsF16::test_f16_q15()
{
const float16_t *inp = input.ptr();
q15_t *outp = outputQ15.ptr();
arm_f16_to_q15(inp, outp,this->nbSamples);
ASSERT_NEAR_EQ(refQ15,outputQ15,ABS_Q15_ERROR);
ASSERT_EMPTY_TAIL(outputQ15);
}
void SupportTestsF16::test_f16_f32()
{
const float16_t *inp = input.ptr();
float32_t *outp = outputF32.ptr();
arm_f16_to_float(inp, outp,this->nbSamples);
ASSERT_REL_ERROR(refF32,outputF32,REL_ERROR_F32);
ASSERT_EMPTY_TAIL(outputF32);
}
void SupportTestsF16::test_q15_f16()
{
const q15_t *inp = inputQ15.ptr();
float16_t *outp = output.ptr();
arm_q15_to_f16(inp, outp,this->nbSamples);
ASSERT_REL_ERROR(ref,output,REL_ERROR);
ASSERT_EMPTY_TAIL(outputF32);
}
void SupportTestsF16::test_f32_f16()
{
const float32_t *inp = inputF32.ptr();
float16_t *outp = output.ptr();
arm_float_to_f16(inp, outp,this->nbSamples);
ASSERT_REL_ERROR(ref,output,REL_ERROR);
ASSERT_EMPTY_TAIL(outputF32);
}
void SupportTestsF16::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
{
(void)paramsArgs;
switch(id)
{
case TEST_WEIGHTED_SUM_F16_1:
this->nbSamples = 3;
input.reload(SupportTestsF16::INPUTS_F16_ID,mgr,this->nbSamples);
coefs.reload(SupportTestsF16::WEIGHTS_F16_ID,mgr,this->nbSamples);
ref.reload(SupportTestsF16::REF_F16_ID,mgr);
output.create(1,SupportTestsF16::OUT_F16_ID,mgr);
this->offset=0;
break;
case TEST_WEIGHTED_SUM_F16_2:
this->nbSamples = 8;
input.reload(SupportTestsF16::INPUTS_F16_ID,mgr,this->nbSamples);
coefs.reload(SupportTestsF16::WEIGHTS_F16_ID,mgr,this->nbSamples);
ref.reload(SupportTestsF16::REF_F16_ID,mgr);
output.create(1,SupportTestsF16::OUT_F16_ID,mgr);
this->offset=1;
break;
case TEST_WEIGHTED_SUM_F16_3:
this->nbSamples = 11;
input.reload(SupportTestsF16::INPUTS_F16_ID,mgr,this->nbSamples);
coefs.reload(SupportTestsF16::WEIGHTS_F16_ID,mgr,this->nbSamples);
ref.reload(SupportTestsF16::REF_F16_ID,mgr);
output.create(1,SupportTestsF16::OUT_F16_ID,mgr);
this->offset=2;
break;
case TEST_COPY_F16_4:
this->nbSamples = 7;
input.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
output.create(input.nbSamples(),SupportTestsF16::OUT_F16_ID,mgr);
break;
case TEST_COPY_F16_5:
this->nbSamples = 16;
input.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
output.create(input.nbSamples(),SupportTestsF16::OUT_F16_ID,mgr);
break;
case TEST_COPY_F16_6:
this->nbSamples = 23;
input.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
output.create(input.nbSamples(),SupportTestsF16::OUT_F16_ID,mgr);
break;
case TEST_FILL_F16_7:
this->nbSamples = 7;
output.create(this->nbSamples,SupportTestsF16::OUT_F16_ID,mgr);
break;
case TEST_FILL_F16_8:
this->nbSamples = 16;
output.create(this->nbSamples,SupportTestsF16::OUT_F16_ID,mgr);
break;
case TEST_FILL_F16_9:
this->nbSamples = 23;
output.create(this->nbSamples,SupportTestsF16::OUT_F16_ID,mgr);
break;
case TEST_F16_Q15_10:
this->nbSamples = 7;
input.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
refQ15.reload(SupportTestsF16::SAMPLES_Q15_ID,mgr,this->nbSamples);
outputQ15.create(this->nbSamples,SupportTestsF16::OUT_Q15_ID,mgr);
break;
case TEST_F16_Q15_11:
this->nbSamples = 16;
input.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
refQ15.reload(SupportTestsF16::SAMPLES_Q15_ID,mgr,this->nbSamples);
outputQ15.create(this->nbSamples,SupportTestsF16::OUT_Q15_ID,mgr);
break;
case TEST_F16_Q15_12:
this->nbSamples = 23;
input.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
refQ15.reload(SupportTestsF16::SAMPLES_Q15_ID,mgr,this->nbSamples);
outputQ15.create(this->nbSamples,SupportTestsF16::OUT_Q15_ID,mgr);
break;
case TEST_F16_F32_13:
this->nbSamples = 7;
input.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
refF32.reload(SupportTestsF16::SAMPLES_F32_ID,mgr,this->nbSamples);
outputF32.create(this->nbSamples,SupportTestsF16::OUT_F32_ID,mgr);
break;
case TEST_F16_F32_14:
this->nbSamples = 16;
input.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
refF32.reload(SupportTestsF16::SAMPLES_F32_ID,mgr,this->nbSamples);
outputF32.create(this->nbSamples,SupportTestsF16::OUT_F32_ID,mgr);
break;
case TEST_F16_F32_15:
this->nbSamples = 23;
input.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
refF32.reload(SupportTestsF16::SAMPLES_F32_ID,mgr,this->nbSamples);
outputF32.create(this->nbSamples,SupportTestsF16::OUT_F32_ID,mgr);
break;
case TEST_Q15_F16_16:
this->nbSamples = 7;
inputQ15.reload(SupportTestsF16::SAMPLES_Q15_ID,mgr,this->nbSamples);
ref.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
output.create(this->nbSamples,SupportTestsF16::OUT_F16_ID,mgr);
break;
case TEST_Q15_F16_17:
this->nbSamples = 16;
inputQ15.reload(SupportTestsF16::SAMPLES_Q15_ID,mgr,this->nbSamples);
ref.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
output.create(this->nbSamples,SupportTestsF16::OUT_F16_ID,mgr);
break;
case TEST_Q15_F16_18:
this->nbSamples = 23;
inputQ15.reload(SupportTestsF16::SAMPLES_Q15_ID,mgr,this->nbSamples);
ref.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
output.create(this->nbSamples,SupportTestsF16::OUT_F16_ID,mgr);
break;
case TEST_F32_F16_19:
this->nbSamples = 3;
inputF32.reload(SupportTestsF16::SAMPLES_F32_ID,mgr,this->nbSamples);
ref.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
output.create(this->nbSamples,SupportTestsF16::OUT_F16_ID,mgr);
break;
case TEST_F32_F16_20:
this->nbSamples = 8;
inputF32.reload(SupportTestsF16::SAMPLES_F32_ID,mgr,this->nbSamples);
ref.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
output.create(this->nbSamples,SupportTestsF16::OUT_F16_ID,mgr);
break;
case TEST_F32_F16_21:
this->nbSamples = 11;
inputF32.reload(SupportTestsF16::SAMPLES_F32_ID,mgr,this->nbSamples);
ref.reload(SupportTestsF16::SAMPLES_F16_ID,mgr,this->nbSamples);
output.create(this->nbSamples,SupportTestsF16::OUT_F16_ID,mgr);
break;
}
}
void SupportTestsF16::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
{
(void)id;
output.dump(mgr);
}

73
Testing/desc_f16.txt
Unescape Escape View File

@ -28,16 +28,16 @@ group Root {
//Pattern INPUT22_F16_ID : Input22_f16.txt
//Pattern DIM22_S16_ID : Dims22_s16.txt
//Pattern REF22_ENTROPY_F16_ID : RefEntropy22_f16.txt
//
//
//Pattern INPUT23_F16_ID : Input23_f16.txt
//Pattern DIM23_S16_ID : Dims23_s16.txt
//Pattern REF23_LOGSUMEXP_F16_ID : RefLogSumExp23_f16.txt
//
//
//Pattern INPUTA24_F16_ID : InputA24_f16.txt
//Pattern INPUTB24_F16_ID : InputB24_f16.txt
//Pattern DIM24_S16_ID : Dims24_s16.txt
//Pattern REF24_KL_F16_ID : RefKL24_f16.txt
//
//
//Pattern INPUTA25_F16_ID : InputA25_f16.txt
//Pattern INPUTB25_F16_ID : InputB25_f16.txt
//Pattern DIM25_S16_ID : Dims25_s16.txt
@ -95,6 +95,73 @@ group Root {
}
}
group Support Tests {
class = SupportTests
folder = Support
suite Support Tests F16 {
class = SupportTestsF16
folder = SupportF16
Pattern INPUTS_F16_ID : Inputs6_f16.txt
Pattern WEIGHTS_F16_ID : Weights6_f16.txt
Pattern REF_F16_ID : Ref6_f16.txt
Pattern SAMPLES_F32_ID : Samples1_f32.txt
Pattern SAMPLES_Q15_ID : Samples3_q15.txt
Pattern SAMPLES_F16_ID : Samples11_f16.txt
Output OUT_F16_ID : Output
Output OUT_Q15_ID : OutputQ15
Output OUT_F32_ID : OutputF32
Functions {
test_weighted_sum_f16 nb=3:test_weighted_sum_f16
test_weighted_sum_f16 nb=4n:test_weighted_sum_f16
test_weighted_sum_f16 nb=4n+1:test_weighted_sum_f16
test_copy_f16 nb=7:test_copy_f16
test_copy_f16 nb=8n:test_copy_f16
test_copy_f16 nb=8n+1:test_copy_f16
test_fill_f16 nb=7:test_fill_f16
test_fill_f16 nb=8n:test_fill_f16
test_fill_f16 nb=8n+1:test_fill_f16
test_f16_q15 nb=7:test_f16_q15
test_f16_q15 nb=8n:test_f16_q15
test_f16_q15 nb=8n+1:test_f16_q15
test_f16_f32 nb=7:test_f16_f32
test_f16_f32 nb=8n:test_f16_f32
test_f16_f32 nb=8n+1:test_f16_f32
test_q15_f16 nb=7:test_q15_f16
test_q15_f16 nb=8n:test_q15_f16
test_q15_f16 nb=8n+1:test_q15_f16
test_f32_f16 nb=3:test_f32_f16
test_f32_f16 nb=4n:test_f32_f16
test_f32_f16 nb=4n+1:test_f32_f16
}
}
}
suite Support Bar Tests F16 {
class = SupportBarTestsF16
folder = SupportBarF16
Pattern SAMPLES_F16_ID : Inputs1_f16.txt
Pattern COEFS_F16_ID : Weights1_f16.txt
Pattern REF_F16_ID : Ref1_f16.txt
Pattern DIM_S16_ID : Dims1_s16.txt
Output OUT_SAMPLES_F16_ID : Output
Functions {
test_barycenter_f16:test_barycenter_f16
}
}
group Interpolation Tests{
class = InterpolationTests

Write Preview
Loading…
Cancel
Save