CMSIS-DSP: Added f16 versions of statistics functions.
diff --git a/ARM.CMSIS.pdsc b/ARM.CMSIS.pdsc
index 0e2a0e6..ba4d497 100644
--- a/ARM.CMSIS.pdsc
+++ b/ARM.CMSIS.pdsc
@@ -3249,6 +3249,7 @@
<file category="source" name="CMSIS/DSP/Source/TransformFunctions/TransformFunctionsF16.c"/>
<file category="source" name="CMSIS/DSP/Source/MatrixFunctions/MatrixFunctionsF16.c"/>
<file category="source" name="CMSIS/DSP/Source/InterpolationFunctions/InterpolationFunctionsF16.c"/>
+ <file category="source" name="CMSIS/DSP/Source/StatisticsFunctions/StatisticsFunctionsF16.c"/>
<!-- Compute Library for Cortex-A -->
<file category="header" name="CMSIS/DSP/ComputeLibrary/Include/NEMath.h" condition="ARMv7-A Device"/>
diff --git a/CMSIS/DSP/Include/dsp/statistics_functions_f16.h b/CMSIS/DSP/Include/dsp/statistics_functions_f16.h
index bc3665c..c891e3f 100755
--- a/CMSIS/DSP/Include/dsp/statistics_functions_f16.h
+++ b/CMSIS/DSP/Include/dsp/statistics_functions_f16.h
@@ -26,12 +26,104 @@
#ifndef _STATISTICS_FUNCTIONS_F16_H_
#define _STATISTICS_FUNCTIONS_F16_H_
+#include "arm_math_types_f16.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+#include "dsp/basic_math_functions_f16.h"
+#include "dsp/fast_math_functions_f16.h"
+
#ifdef __cplusplus
extern "C"
{
#endif
#if defined(ARM_FLOAT16_SUPPORTED)
+
+ /**
+ * @brief Sum of the squares of the elements of a floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output value.
+ */
+ void arm_power_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult);
+
+ /**
+ * @brief Mean value of a floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output value.
+ */
+ void arm_mean_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult);
+
+ /**
+ * @brief Variance of the elements of a floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output value.
+ */
+ void arm_var_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult);
+
+ /**
+ * @brief Root Mean Square of the elements of a floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output value.
+ */
+ void arm_rms_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult);
+
+ /**
+ * @brief Standard deviation of the elements of a floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output value.
+ */
+ void arm_std_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult);
+
+ /**
+ * @brief Minimum value of a floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output pointer
+ * @param[out] pIndex is the array index of the minimum value in the input buffer.
+ */
+ void arm_min_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult,
+ uint32_t * pIndex);
+
+/**
+ * @brief Maximum value of a floating-point vector.
+ * @param[in] pSrc points to the input buffer
+ * @param[in] blockSize length of the input vector
+ * @param[out] pResult maximum value returned here
+ * @param[out] pIndex index of maximum value returned here
+ */
+ void arm_max_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult,
+ uint32_t * pIndex);
+
+
#endif /*defined(ARM_FLOAT16_SUPPORTED)*/
#ifdef __cplusplus
}
diff --git a/CMSIS/DSP/PythonWrapper/setup.py b/CMSIS/DSP/PythonWrapper/setup.py
index 6dc6766..142c759 100644
--- a/CMSIS/DSP/PythonWrapper/setup.py
+++ b/CMSIS/DSP/PythonWrapper/setup.py
@@ -38,6 +38,7 @@
statistics = glob.glob(os.path.join(ROOT,"Source","StatisticsFunctions","*.c"))
statistics.remove(os.path.join(ROOT,"Source","StatisticsFunctions","StatisticsFunctions.c"))
+statistics.remove(os.path.join(ROOT,"Source","StatisticsFunctions","StatisticsFunctionsF16.c"))
complexf = glob.glob(os.path.join(ROOT,"Source","ComplexMathFunctions","*.c"))
complexf.remove(os.path.join(ROOT,"Source","ComplexMathFunctions","ComplexMathFunctions.c"))
diff --git a/CMSIS/DSP/Source/MatrixFunctions/arm_mat_cmplx_mult_f16.c b/CMSIS/DSP/Source/MatrixFunctions/arm_mat_cmplx_mult_f16.c
index 7e009c6..5f400af 100755
--- a/CMSIS/DSP/Source/MatrixFunctions/arm_mat_cmplx_mult_f16.c
+++ b/CMSIS/DSP/Source/MatrixFunctions/arm_mat_cmplx_mult_f16.c
@@ -52,7 +52,6 @@
*/
#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
-#include <stdio.h>
#include "arm_helium_utils.h"
#define DONTCARE 0 /* inactive lane content */
diff --git a/CMSIS/DSP/Source/StatisticsFunctions/CMakeLists.txt b/CMSIS/DSP/Source/StatisticsFunctions/CMakeLists.txt
index 8c3763c..b4310f3 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/CMakeLists.txt
+++ b/CMSIS/DSP/Source/StatisticsFunctions/CMakeLists.txt
@@ -5,9 +5,43 @@
include(configLib)
include(configDsp)
-file(GLOB SRC "./*_*.c")
-add_library(CMSISDSPStatistics STATIC ${SRC})
+
+add_library(CMSISDSPStatistics STATIC)
+
+target_sources(CMSISDSPStatistics PRIVATE arm_entropy_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_entropy_f64.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_kullback_leibler_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_kullback_leibler_f64.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_logsumexp_dot_prod_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_logsumexp_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_max_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_max_no_idx_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_max_q15.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_max_q31.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_max_q7.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_mean_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_mean_q15.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_mean_q31.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_mean_q7.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_min_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_min_q15.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_min_q31.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_min_q7.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_power_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_power_q15.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_power_q31.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_power_q7.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_rms_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_rms_q15.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_rms_q31.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_std_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_std_q15.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_std_q31.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_var_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_var_q15.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_var_q31.c)
+
configLib(CMSISDSPStatistics ${ROOT})
configDsp(CMSISDSPStatistics ${ROOT})
@@ -17,3 +51,12 @@
+if ((NOT ARMAC5) AND (NOT DISABLEFLOAT16))
+target_sources(CMSISDSPStatistics PRIVATE arm_max_f16.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_min_f16.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_mean_f16.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_power_f16.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_rms_f16.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_std_f16.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_var_f16.c)
+endif()
\ No newline at end of file
diff --git a/CMSIS/DSP/Source/StatisticsFunctions/StatisticsFunctionsF16.c b/CMSIS/DSP/Source/StatisticsFunctions/StatisticsFunctionsF16.c
new file mode 100755
index 0000000..b542e97
--- /dev/null
+++ b/CMSIS/DSP/Source/StatisticsFunctions/StatisticsFunctionsF16.c
@@ -0,0 +1,35 @@
+/* ----------------------------------------------------------------------
+ * Project: CMSIS DSP Library
+ * Title: StatisticsFunctions.c
+ * Description: Combination of all statistics 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_max_f16.c"
+#include "arm_min_f16.c"
+#include "arm_mean_f16.c"
+#include "arm_power_f16.c"
+#include "arm_rms_f16.c"
+#include "arm_std_f16.c"
+#include "arm_var_f16.c"
diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_max_f16.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_max_f16.c
new file mode 100755
index 0000000..099f696
--- /dev/null
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_max_f16.c
@@ -0,0 +1,246 @@
+/* ----------------------------------------------------------------------
+ * Project: CMSIS DSP Library
+ * Title: arm_max_f16.c
+ * Description: Maximum value of a floating-point vector
+ *
+ * $Date: 18. March 2020
+ * $Revision: V1.6.0
+ *
+ * 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/statistics_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+#if (defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF)) && !defined(ARM_MATH_AUTOVECTORIZE)
+#include <limits.h>
+#endif
+
+/**
+ @ingroup groupStats
+ */
+
+
+/**
+ @addtogroup Max
+ @{
+ */
+
+/**
+ @brief Maximum value of a floating-point vector.
+ @param[in] pSrc points to the input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult maximum value returned here
+ @param[out] pIndex index of maximum value returned here
+ @return none
+ */
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+void arm_max_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult,
+ uint32_t * pIndex)
+{
+ int32_t blkCnt;
+ f16x8_t vecSrc;
+ f16x8_t curExtremValVec = vdupq_n_f16(F16_MIN);
+ float16_t maxValue = F16_MIN;
+ uint32_t idx = blockSize;
+ uint16x8_t indexVec;
+ uint16x8_t curExtremIdxVec;
+ uint32_t curIdx = 0;
+ mve_pred16_t p0;
+ float16_t tmp;
+
+
+ indexVec = vidupq_wb_u16(&curIdx, 1);
+ curExtremIdxVec = vdupq_n_u16(0);
+
+ /* Compute 4 outputs at a time */
+ blkCnt = blockSize >> 3;
+ while (blkCnt > 0)
+ {
+ vecSrc = vldrhq_f16(pSrc);
+ /*
+ * Get current max per lane and current index per lane
+ * when a max is selected
+ */
+ p0 = vcmpgeq(vecSrc, curExtremValVec);
+ curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
+ curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
+
+ indexVec = vidupq_wb_u16(&curIdx, 1);
+
+ pSrc += 8;
+ /* Decrement the loop counter */
+ blkCnt--;
+ }
+
+
+ /*
+ * Get max value across the vector
+ */
+ maxValue = vmaxnmvq(maxValue, curExtremValVec);
+ /*
+ * set index for lower values to max possible index
+ */
+ p0 = vcmpgeq(curExtremValVec, maxValue);
+ indexVec = vpselq(curExtremIdxVec, vdupq_n_u16(blockSize), p0);
+ /*
+ * Get min index which is thus for a max value
+ */
+ idx = vminvq(idx, indexVec);
+
+ /* Tail */
+ blkCnt = blockSize & 7;
+
+ while (blkCnt > 0)
+ {
+ /* Initialize tmp to the next consecutive values one by one */
+ tmp = *pSrc++;
+
+ /* compare for the maximum value */
+ if (maxValue < tmp)
+ {
+ /* Update the maximum value and it's index */
+ maxValue = tmp;
+ idx = blockSize - blkCnt;
+ }
+
+ /* Decrement loop counter */
+ blkCnt--;
+ }
+
+ /*
+ * Save result
+ */
+ *pIndex = idx;
+ *pResult = maxValue;
+}
+
+#else
+void arm_max_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult,
+ uint32_t * pIndex)
+{
+ float16_t maxVal, out; /* Temporary variables to store the output value. */
+ uint32_t blkCnt, outIndex; /* Loop counter */
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+ uint32_t index; /* index of maximum value */
+#endif
+
+ /* Initialise index value to zero. */
+ outIndex = 0U;
+
+ /* Load first input value that act as reference value for comparision */
+ out = *pSrc++;
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+ /* Initialise index of maximum value. */
+ index = 0U;
+
+ /* Loop unrolling: Compute 4 outputs at a time */
+ blkCnt = (blockSize - 1U) >> 2U;
+
+ while (blkCnt > 0U)
+ {
+ /* Initialize maxVal to next consecutive values one by one */
+ maxVal = *pSrc++;
+
+ /* compare for the maximum value */
+ if (out < maxVal)
+ {
+ /* Update the maximum value and it's index */
+ out = maxVal;
+ outIndex = index + 1U;
+ }
+
+ maxVal = *pSrc++;
+ if (out < maxVal)
+ {
+ out = maxVal;
+ outIndex = index + 2U;
+ }
+
+ maxVal = *pSrc++;
+ if (out < maxVal)
+ {
+ out = maxVal;
+ outIndex = index + 3U;
+ }
+
+ maxVal = *pSrc++;
+ if (out < maxVal)
+ {
+ out = maxVal;
+ outIndex = index + 4U;
+ }
+
+ index += 4U;
+
+ /* Decrement loop counter */
+ blkCnt--;
+ }
+
+ /* Loop unrolling: Compute remaining outputs */
+ blkCnt = (blockSize - 1U) % 4U;
+
+#else
+
+ /* Initialize blkCnt with number of samples */
+ blkCnt = (blockSize - 1U);
+
+#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
+
+ while (blkCnt > 0U)
+ {
+ /* Initialize maxVal to the next consecutive values one by one */
+ maxVal = *pSrc++;
+
+ /* compare for the maximum value */
+ if (out < maxVal)
+ {
+ /* Update the maximum value and it's index */
+ out = maxVal;
+ outIndex = blockSize - blkCnt;
+ }
+
+ /* Decrement loop counter */
+ blkCnt--;
+ }
+
+ /* Store the maximum value and it's index into destination pointers */
+ *pResult = out;
+ *pIndex = outIndex;
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+ @} end of Max group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */
+
diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f16.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f16.c
new file mode 100755
index 0000000..a32f871
--- /dev/null
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f16.c
@@ -0,0 +1,152 @@
+/* ----------------------------------------------------------------------
+ * Project: CMSIS DSP Library
+ * Title: arm_mean_f16.c
+ * Description: Mean value 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/statistics_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+
+/**
+ @ingroup groupStats
+ */
+
+/**
+ @defgroup mean Mean
+
+ Calculates the mean of the input vector. Mean is defined as the average of the elements in the vector.
+ The underlying algorithm is used:
+
+ <pre>
+ Result = (pSrc[0] + pSrc[1] + pSrc[2] + ... + pSrc[blockSize-1]) / blockSize;
+ </pre>
+
+ There are separate functions for floating-point, Q31, Q15, and Q7 data types.
+ */
+
+/**
+ @addtogroup mean
+ @{
+ */
+
+/**
+ @brief Mean value of a floating-point vector.
+ @param[in] pSrc points to the input vector.
+ @param[in] blockSize number of samples in input vector.
+ @param[out] pResult mean value returned here.
+ @return none
+ */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_mean_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult)
+{
+ int32_t blkCnt; /* loop counters */
+ f16x8_t vecSrc;
+ f16x8_t sumVec = vdupq_n_f16(0.0f16);
+
+ blkCnt = blockSize;
+ do {
+ mve_pred16_t p = vctp16q(blkCnt);
+
+ vecSrc = vldrhq_z_f16((float16_t const *) pSrc, p);
+ sumVec = vaddq_m_f16(sumVec, sumVec, vecSrc, p);
+
+ blkCnt -= 8;
+ pSrc += 8;
+ }
+ while (blkCnt > 0);
+
+ *pResult = vecAddAcrossF16Mve(sumVec) / (float16_t) blockSize;
+}
+
+
+#else
+
+void arm_mean_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult)
+{
+ uint32_t blkCnt; /* Loop counter */
+ float16_t sum = 0.0f; /* Temporary result storage */
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+ /* Loop unrolling: Compute 4 outputs at a time */
+ blkCnt = blockSize >> 2U;
+
+ while (blkCnt > 0U)
+ {
+ /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) */
+ sum += *pSrc++;
+
+ sum += *pSrc++;
+
+ sum += *pSrc++;
+
+ sum += *pSrc++;
+
+ /* Decrement the 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[0] + A[1] + A[2] + ... + A[blockSize-1]) */
+ sum += *pSrc++;
+
+ /* Decrement loop counter */
+ blkCnt--;
+ }
+
+ /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) / blockSize */
+ /* Store result to destination */
+ *pResult = (sum / (float16_t)blockSize);
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+ @} end of mean group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */
+
diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f32.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f32.c
index 57ea428..ec7b0dd 100644
--- a/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f32.c
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_mean_f32.c
@@ -32,18 +32,6 @@
@ingroup groupStats
*/
-/**
- @defgroup mean Mean
-
- Calculates the mean of the input vector. Mean is defined as the average of the elements in the vector.
- The underlying algorithm is used:
-
- <pre>
- Result = (pSrc[0] + pSrc[1] + pSrc[2] + ... + pSrc[blockSize-1]) / blockSize;
- </pre>
-
- There are separate functions for floating-point, Q31, Q15, and Q7 data types.
- */
/**
@addtogroup mean
diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_min_f16.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_min_f16.c
new file mode 100755
index 0000000..cb53cab
--- /dev/null
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_min_f16.c
@@ -0,0 +1,240 @@
+/* ----------------------------------------------------------------------
+ * Project: CMSIS DSP Library
+ * Title: arm_min_f16.c
+ * Description: Minimum value 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/statistics_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+
+#if (defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF)) && !defined(ARM_MATH_AUTOVECTORIZE)
+#include <limits.h>
+#endif
+
+
+/**
+ @ingroup groupStats
+ */
+
+/**
+ @addtogroup Min
+ @{
+ */
+
+/**
+ @brief Minimum value of a floating-point vector.
+ @param[in] pSrc points to the input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult minimum value returned here
+ @param[out] pIndex index of minimum value returned here
+ @return none
+ */
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+void arm_min_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult,
+ uint32_t * pIndex)
+{
+ int32_t blkCnt; /* loop counters */
+ f16x8_t vecSrc;
+ float16_t const *pSrcVec;
+ f16x8_t curExtremValVec = vdupq_n_f16(F16_MAX);
+ float16_t minValue = F16_MAX;
+ uint32_t idx = blockSize;
+ uint16x8_t indexVec;
+ uint16x8_t curExtremIdxVec;
+ mve_pred16_t p0;
+
+ indexVec = vidupq_u16((uint32_t)0, 1);
+ curExtremIdxVec = vdupq_n_u16(0);
+
+ pSrcVec = (float16_t const *) pSrc;
+ blkCnt = blockSize >> 3;
+ while (blkCnt > 0)
+ {
+ vecSrc = vldrhq_f16(pSrcVec); pSrcVec += 8;
+ /*
+ * Get current min per lane and current index per lane
+ * when a min is selected
+ */
+ p0 = vcmpleq(vecSrc, curExtremValVec);
+ curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
+ curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
+
+ indexVec = indexVec + 8;
+ /*
+ * Decrement the blockSize loop counter
+ */
+ blkCnt--;
+ }
+ /*
+ * tail
+ * (will be merged thru tail predication)
+ */
+ blkCnt = blockSize & 7;
+ if (blkCnt > 0)
+ {
+ vecSrc = vldrhq_f16(pSrcVec); pSrcVec += 8;
+ p0 = vctp16q(blkCnt);
+ /*
+ * Get current min per lane and current index per lane
+ * when a min is selected
+ */
+ p0 = vcmpleq_m(vecSrc, curExtremValVec, p0);
+ curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
+ curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
+ }
+ /*
+ * Get min value across the vector
+ */
+ minValue = vminnmvq(minValue, curExtremValVec);
+ /*
+ * set index for lower values to min possible index
+ */
+ p0 = vcmpleq(curExtremValVec, minValue);
+ indexVec = vpselq(curExtremIdxVec, vdupq_n_u16(blockSize), p0);
+ /*
+ * Get min index which is thus for a min value
+ */
+ idx = vminvq(idx, indexVec);
+ /*
+ * Save result
+ */
+ *pIndex = idx;
+ *pResult = minValue;
+}
+
+#else
+
+void arm_min_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult,
+ uint32_t * pIndex)
+{
+ float16_t minVal, out; /* Temporary variables to store the output value. */
+ uint32_t blkCnt, outIndex; /* Loop counter */
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+ uint32_t index; /* index of maximum value */
+#endif
+
+ /* Initialise index value to zero. */
+ outIndex = 0U;
+
+ /* Load first input value that act as reference value for comparision */
+ out = *pSrc++;
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+ /* Initialise index of maximum value. */
+ index = 0U;
+
+ /* Loop unrolling: Compute 4 outputs at a time */
+ blkCnt = (blockSize - 1U) >> 2U;
+
+ while (blkCnt > 0U)
+ {
+ /* Initialize minVal to next consecutive values one by one */
+ minVal = *pSrc++;
+
+ /* compare for the minimum value */
+ if (out > minVal)
+ {
+ /* Update the minimum value and it's index */
+ out = minVal;
+ outIndex = index + 1U;
+ }
+
+ minVal = *pSrc++;
+ if (out > minVal)
+ {
+ out = minVal;
+ outIndex = index + 2U;
+ }
+
+ minVal = *pSrc++;
+ if (out > minVal)
+ {
+ out = minVal;
+ outIndex = index + 3U;
+ }
+
+ minVal = *pSrc++;
+ if (out > minVal)
+ {
+ out = minVal;
+ outIndex = index + 4U;
+ }
+
+ index += 4U;
+
+ /* Decrement loop counter */
+ blkCnt--;
+ }
+
+ /* Loop unrolling: Compute remaining outputs */
+ blkCnt = (blockSize - 1U) % 4U;
+
+#else
+
+ /* Initialize blkCnt with number of samples */
+ blkCnt = (blockSize - 1U);
+
+#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
+
+ while (blkCnt > 0U)
+ {
+ /* Initialize minVal to the next consecutive values one by one */
+ minVal = *pSrc++;
+
+ /* compare for the minimum value */
+ if (out > minVal)
+ {
+ /* Update the minimum value and it's index */
+ out = minVal;
+ outIndex = blockSize - blkCnt;
+ }
+
+ /* Decrement loop counter */
+ blkCnt--;
+ }
+
+ /* Store the minimum value and it's index into destination pointers */
+ *pResult = out;
+ *pIndex = outIndex;
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+ @} end of Min group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */
+
diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_power_f16.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_power_f16.c
new file mode 100755
index 0000000..e40bc52
--- /dev/null
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_power_f16.c
@@ -0,0 +1,152 @@
+/* ----------------------------------------------------------------------
+ * Project: CMSIS DSP Library
+ * Title: arm_power_f16.c
+ * Description: Sum of the squares of 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/statistics_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+
+/**
+ @ingroup groupStats
+ */
+
+
+
+/**
+ @addtogroup power
+ @{
+ */
+
+/**
+ @brief Sum of the squares of the elements of a floating-point vector.
+ @param[in] pSrc points to the input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult sum of the squares value returned here
+ @return none
+ */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_power_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult)
+{
+ int32_t blkCnt; /* loop counters */
+ f16x8_t vecSrc;
+ f16x8_t sumVec = vdupq_n_f16(0.0f);
+
+
+ blkCnt = blockSize;
+ do {
+ mve_pred16_t p = vctp16q(blkCnt);
+
+ vecSrc = vldrhq_z_f16((float16_t const *) pSrc, p);
+ /*
+ * sum lanes
+ */
+ sumVec = vfmaq_m(sumVec, vecSrc, vecSrc, p);
+
+ blkCnt -= 8;
+ pSrc += 8;
+ }
+ while (blkCnt > 0);
+
+ *pResult = vecAddAcrossF16Mve(sumVec);
+}
+#else
+
+void arm_power_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult)
+{
+ uint32_t blkCnt; /* Loop counter */
+ float16_t sum = 0.0f; /* Temporary result storage */
+ float16_t in; /* Temporary variable to store input value */
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+ /* Loop unrolling: Compute 4 outputs at a time */
+ blkCnt = blockSize >> 2U;
+
+ while (blkCnt > 0U)
+ {
+ /* C = A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1] */
+
+ /* Compute Power and store result in a temporary variable, sum. */
+ in = *pSrc++;
+ sum += in * in;
+
+ in = *pSrc++;
+ sum += in * in;
+
+ in = *pSrc++;
+ sum += in * in;
+
+ in = *pSrc++;
+ sum += in * in;
+
+ /* 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[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1] */
+
+ /* Compute Power and store result in a temporary variable, sum. */
+ in = *pSrc++;
+ sum += in * in;
+
+ /* Decrement loop counter */
+ blkCnt--;
+ }
+
+ /* Store result to destination */
+ *pResult = sum;
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+ @} end of power group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */
+
diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_f16.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_f16.c
new file mode 100755
index 0000000..15f1a47
--- /dev/null
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_rms_f16.c
@@ -0,0 +1,147 @@
+/* ----------------------------------------------------------------------
+ * Project: CMSIS DSP Library
+ * Title: arm_rms_f16.c
+ * Description: Root mean square value of 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/statistics_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+
+/**
+ @ingroup groupStats
+ */
+
+/**
+ @defgroup RMS Root mean square (RMS)
+
+ Calculates the Root Mean Square of the elements in the input vector.
+ The underlying algorithm is used:
+
+ <pre>
+ Result = sqrt(((pSrc[0] * pSrc[0] + pSrc[1] * pSrc[1] + ... + pSrc[blockSize-1] * pSrc[blockSize-1]) / blockSize));
+ </pre>
+
+ There are separate functions for floating point, Q31, and Q15 data types.
+ */
+
+/**
+ @addtogroup RMS
+ @{
+ */
+
+/**
+ @brief Root Mean Square of the elements of a floating-point vector.
+ @param[in] pSrc points to the input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult root mean square value returned here
+ @return none
+ */
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+void arm_rms_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult)
+{
+ float16_t pow = 0.0f;
+
+ arm_power_f16(pSrc, blockSize, &pow);
+
+ /* Compute Rms and store the result in the destination */
+ arm_sqrt_f16(pow / (float16_t) blockSize, pResult);
+}
+#else
+
+void arm_rms_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult)
+{
+ uint32_t blkCnt; /* Loop counter */
+ float16_t sum = 0.0f; /* Temporary result storage */
+ float16_t in; /* Temporary variable to store input value */
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+ /* Loop unrolling: Compute 4 outputs at a time */
+ blkCnt = blockSize >> 2U;
+
+ while (blkCnt > 0U)
+ {
+ /* C = A[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1] */
+
+ in = *pSrc++;
+ /* Compute sum of squares and store result in a temporary variable, sum. */
+ sum += in * in;
+
+ in = *pSrc++;
+ sum += in * in;
+
+ in = *pSrc++;
+ sum += in * in;
+
+ in = *pSrc++;
+ sum += in * in;
+
+ /* 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[0] * A[0] + A[1] * A[1] + ... + A[blockSize-1] * A[blockSize-1] */
+
+ in = *pSrc++;
+ /* Compute sum of squares and store result in a temporary variable. */
+ sum += ( in * in);
+
+ /* Decrement loop counter */
+ blkCnt--;
+ }
+
+ /* Compute Rms and store result in destination */
+ arm_sqrt_f16(sum / (float16_t) blockSize, pResult);
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+ @} end of RMS group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */
+
diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_std_f16.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_std_f16.c
new file mode 100755
index 0000000..953838e
--- /dev/null
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_std_f16.c
@@ -0,0 +1,67 @@
+/* ----------------------------------------------------------------------
+ * Project: CMSIS DSP Library
+ * Title: arm_std_f16.c
+ * Description: Standard deviation of 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/statistics_functions_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+
+/**
+ @ingroup groupStats
+ */
+
+
+
+/**
+ @addtogroup STD
+ @{
+ */
+
+/**
+ @brief Standard deviation of the elements of a floating-point vector.
+ @param[in] pSrc points to the input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult standard deviation value returned here
+ @return none
+ */
+void arm_std_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult)
+{
+ float16_t var;
+ arm_var_f16(pSrc,blockSize,&var);
+ arm_sqrt_f16(var, pResult);
+}
+
+/**
+ @} end of STD group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */
+
diff --git a/CMSIS/DSP/Source/StatisticsFunctions/arm_var_f16.c b/CMSIS/DSP/Source/StatisticsFunctions/arm_var_f16.c
new file mode 100755
index 0000000..727a594
--- /dev/null
+++ b/CMSIS/DSP/Source/StatisticsFunctions/arm_var_f16.c
@@ -0,0 +1,221 @@
+/* ----------------------------------------------------------------------
+ * Project: CMSIS DSP Library
+ * Title: arm_var_f16.c
+ * Description: Variance of 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/statistics_functions_f16.h"
+
+#include <stdio.h>
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+
+/**
+ @ingroup groupStats
+ */
+
+
+/**
+ @addtogroup variance
+ @{
+ */
+
+/**
+ @brief Variance of the elements of a floating-point vector.
+ @param[in] pSrc points to the input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult variance value returned here
+ @return none
+ */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+
+void arm_var_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult)
+{
+ int32_t blkCnt; /* loop counters */
+ f16x8_t vecSrc;
+ f16x8_t sumVec = vdupq_n_f16((float16_t) 0.0);
+ float16_t fMean;
+
+ if (blockSize <= 1U) {
+ *pResult = 0;
+ return;
+ }
+
+
+ arm_mean_f16(pSrc, blockSize, &fMean);
+
+/* 6.14 bug */
+#if defined(SDCOMP_xxx)
+#if defined (__ARMCC_VERSION) && (__ARMCC_VERSION >= 6100100)
+ __asm volatile(
+ " vmov.i32 %[acc], #0 \n"
+ : [acc] "+t"(sumVec)
+ :
+ : );
+#endif
+#endif
+
+ blkCnt = blockSize;
+ do {
+ mve_pred16_t p = vctp16q(blkCnt);
+
+ vecSrc = vldrhq_z_f16((float16_t const *) pSrc, p);
+ /*
+ * sum lanes
+ */
+ vecSrc = vsubq_m(vuninitializedq_f16(), vecSrc, fMean, p);
+ sumVec = vfmaq_m(sumVec, vecSrc, vecSrc, p);
+
+ blkCnt -= 8;
+ pSrc += 8;
+ }
+ while (blkCnt > 0);
+
+ /* Variance */
+ *pResult = vecAddAcrossF16Mve(sumVec) / (float16_t) (blockSize - 1.0f);
+}
+#else
+
+void arm_var_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult)
+{
+ uint32_t blkCnt; /* Loop counter */
+ _Float16 sum = 0.0f; /* Temporary result storage */
+ _Float16 fSum = 0.0f;
+ _Float16 fMean, fValue;
+ const float16_t * pInput = pSrc;
+
+ if (blockSize <= 1U)
+ {
+ *pResult = 0;
+ return;
+ }
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+ /* Loop unrolling: Compute 4 outputs at a time */
+ blkCnt = blockSize >> 2U;
+
+ while (blkCnt > 0U)
+ {
+ /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) */
+
+ sum += *pInput++;
+ sum += *pInput++;
+ sum += *pInput++;
+ sum += *pInput++;
+
+
+ /* 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[0] + A[1] + A[2] + ... + A[blockSize-1]) */
+
+ sum += *pInput++;
+
+ /* Decrement loop counter */
+ blkCnt--;
+ }
+
+ /* C = (A[0] + A[1] + A[2] + ... + A[blockSize-1]) / blockSize */
+ fMean = sum / (float16_t) blockSize;
+
+ pInput = pSrc;
+
+#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+ /* Loop unrolling: Compute 4 outputs at a time */
+ blkCnt = blockSize >> 2U;
+
+ while (blkCnt > 0U)
+ {
+ fValue = *pInput++ - fMean;
+ fSum += fValue * fValue;
+
+ fValue = *pInput++ - fMean;
+ fSum += fValue * fValue;
+
+ fValue = *pInput++ - fMean;
+ fSum += fValue * fValue;
+
+ fValue = *pInput++ - fMean;
+ fSum += fValue * fValue;
+
+ /* 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)
+ {
+ fValue = *pInput++ - fMean;
+ fSum += fValue * fValue;
+
+ /* Decrement loop counter */
+ blkCnt--;
+ }
+
+ /* Variance */
+ *pResult = fSum / (float16_t)(blockSize - 1.0f);
+}
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+ @} end of variance group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */
+
diff --git a/CMSIS/DSP/Testing/CMakeLists.txt b/CMSIS/DSP/Testing/CMakeLists.txt
index 51b1665..d277a6a 100644
--- a/CMSIS/DSP/Testing/CMakeLists.txt
+++ b/CMSIS/DSP/Testing/CMakeLists.txt
@@ -329,6 +329,7 @@
Source/Tests/BasicTestsF16.cpp
Source/Tests/ComplexTestsF16.cpp
Source/Tests/InterpolationTestsF16.cpp
+ Source/Tests/StatsTestsF16.cpp
Source/Tests/FIRF16.cpp
Source/Tests/BIQUADF16.cpp
Source/Tests/MISCF16.cpp
diff --git a/CMSIS/DSP/Testing/Include/Tests/StatsTestsF16.h b/CMSIS/DSP/Testing/Include/Tests/StatsTestsF16.h
new file mode 100755
index 0000000..790633b
--- /dev/null
+++ b/CMSIS/DSP/Testing/Include/Tests/StatsTestsF16.h
@@ -0,0 +1,35 @@
+#include "Test.h"
+#include "Pattern.h"
+
+#include "dsp/statistics_functions_f16.h"
+
+class StatsTestsF16:public Client::Suite
+ {
+ public:
+ StatsTestsF16(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 "StatsTestsF16_decl.h"
+
+ Client::Pattern<float16_t> inputA;
+ Client::Pattern<float16_t> inputB;
+ Client::Pattern<int16_t> dims;
+
+ Client::LocalPattern<float16_t> output;
+ Client::LocalPattern<int16_t> index;
+ Client::LocalPattern<float16_t> tmp;
+
+ // Reference patterns are not loaded when we are in dump mode
+ Client::RefPattern<float16_t> ref;
+ Client::Pattern<int16_t> maxIndexes;
+ Client::Pattern<int16_t> minIndexes;
+
+ int nbPatterns;
+ int vecDim;
+
+ int refOffset;
+
+
+
+ };
diff --git a/CMSIS/DSP/Testing/PatternGeneration/Stats.py b/CMSIS/DSP/Testing/PatternGeneration/Stats.py
index 09d30bc..e0610eb 100755
--- a/CMSIS/DSP/Testing/PatternGeneration/Stats.py
+++ b/CMSIS/DSP/Testing/PatternGeneration/Stats.py
@@ -343,6 +343,7 @@
PARAMDIR = os.path.join("Parameters","DSP","Stats","Stats")
configf32=Tools.Config(PATTERNDIR,PARAMDIR,"f32")
+ configf16=Tools.Config(PATTERNDIR,PARAMDIR,"f16")
configf64=Tools.Config(PATTERNDIR,PARAMDIR,"f64")
configq31=Tools.Config(PATTERNDIR,PARAMDIR,"q31")
configq15=Tools.Config(PATTERNDIR,PARAMDIR,"q15")
@@ -355,5 +356,7 @@
writeTests(configq15,1,15)
writeTests(configq7,1,7)
+ nb=writeTests(configf16,1,16)
+
if __name__ == '__main__':
generatePatterns()
diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/Input1_f16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/Input1_f16.txt
new file mode 100755
index 0000000..5758d35
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/Input1_f16.txt
@@ -0,0 +1,602 @@
+H
+300
+// -0.181541
+0xb1cf
+// -0.169745
+0xb16f
+// 0.237867
+0x339d
+// 0.280697
+0x347e
+// 0.111340
+0x2f20
+// -0.281630
+0xb482
+// 0.426820
+0x36d4
+// -0.147220
+0xb0b6
+// -0.301289
+0xb4d2
+// 0.085008
+0x2d71
+// -0.096822
+0xae32
+// 0.118322
+0x2f93
+// 0.026424
+0x26c4
+// -0.105946
+0xaec8
+// 0.411642
+0x3696
+// 0.136448
+0x305e
+// -0.335485
+0xb55e
+// -0.202068
+0xb277
+// -0.361403
+0xb5c8
+// -0.478874
+0xb7a9
+// -0.554829
+0xb870
+// -0.725607
+0xb9ce
+// -0.397848
+0xb65e
+// 0.081577
+0x2d39
+// 0.376096
+0x3604
+// 0.619949
+0x38f6
+// 0.035635
+0x2890
+// -0.045637
+0xa9d7
+// -0.168639
+0xb165
+// 0.170281
+0x3173
+// -0.077000
+0xacee
+// 0.167346
+0x315b
+// -0.189246
+0xb20e
+// 0.327278
+0x353d
+// -0.125620
+0xb005
+// -0.302179
+0xb4d6
+// 0.324256
+0x3530
+// -0.115925
+0xaf6b
+// 0.023388
+0x25fd
+// 0.213505
+0x32d5
+// -0.249834
+0xb3ff
+// 0.230302
+0x335f
+// 0.052223
+0x2aaf
+// -0.118431
+0xaf94
+// 0.237972
+0x339d
+// 0.167228
+0x315a
+// 0.500285
+0x3801
+// 0.396042
+0x3656
+// 0.287551
+0x349a
+// 0.363907
+0x35d3
+// -0.285888
+0xb493
+// -0.298927
+0xb4c8
+// 0.384334
+0x3626
+// -0.214899
+0xb2e0
+// -0.256566
+0xb41b
+// 0.438213
+0x3703
+// -0.057463
+0xab5b
+// 0.099164
+0x2e59
+// -0.337406
+0xb566
+// -0.602355
+0xb8d2
+// -0.003762
+0x9bb4
+// -0.270555
+0xb454
+// -0.351693
+0xb5a1
+// 0.279530
+0x3479
+// -0.365779
+0xb5da
+// 0.133551
+0x3046
+// 0.059872
+0x2baa
+// -0.286309
+0xb495
+// 0.246533
+0x33e4
+// 0.171805
+0x317f
+// -0.341557
+0xb577
+// 0.024636
+0x264f
+// 0.191050
+0x321d
+// 0.093971
+0x2e04
+// -0.077312
+0xacf3
+// -0.628921
+0xb908
+// 0.057062
+0x2b4e
+// 0.004234
+0x1c56
+// 0.702554
+0x399f
+// 0.070054
+0x2c7c
+// -0.126315
+0xb00b
+// -0.114205
+0xaf4f
+// 0.174413
+0x3195
+// -0.323334
+0xb52c
+// -0.419826
+0xb6b8
+// -0.092743
+0xadf0
+// 0.023260
+0x25f4
+// 0.169239
+0x316a
+// -0.112398
+0xaf32
+// -0.530023
+0xb83d
+// 0.057968
+0x2b6b
+// 0.099520
+0x2e5f
+// 0.249493
+0x33fc
+// -0.158562
+0xb113
+// 0.442311
+0x3714
+// -0.375796
+0xb603
+// 0.262720
+0x3434
+// -0.068077
+0xac5b
+// -0.338289
+0xb56a
+// 0.158634
+0x3114
+// 0.292740
+0x34af
+// 0.255336
+0x3416
+// 0.163457
+0x313b
+// -0.642740
+0xb924
+// -0.303784
+0xb4dc
+// 0.290379
+0x34a5
+// -0.139732
+0xb079
+// -0.531862
+0xb841
+// -0.109192
+0xaefd
+// -0.051034
+0xaa88
+// -0.845953
+0xbac5
+// 0.370689
+0x35ee
+// -0.224557
+0xb330
+// 0.087760
+0x2d9e
+// 0.044607
+0x29b6
+// -0.176383
+0xb1a5
+// -0.054776
+0xab03
+// -0.340220
+0xb572
+// -0.437922
+0xb702
+// -0.336270
+0xb561
+// 0.267078
+0x3446
+// 0.069067
+0x2c6c
+// -0.058832
+0xab88
+// -0.331618
+0xb54e
+// -0.029930
+0xa7a9
+// 0.609125
+0x38df
+// -0.251916
+0xb408
+// -0.122801
+0xafdc
+// 0.387843
+0x3635
+// 0.112303
+0x2f30
+// -0.407489
+0xb685
+// 0.316717
+0x3511
+// -0.076934
+0xacec
+// 0.299806
+0x34cc
+// -0.123522
+0xafe8
+// 0.221139
+0x3314
+// -0.012030
+0xa229
+// -0.330032
+0xb548
+// 0.043511
+0x2992
+// -0.790171
+0xba52
+// 0.119824
+0x2fab
+// -0.009153
+0xa0b0
+// 0.212885
+0x32d0
+// 0.430953
+0x36e5
+// 0.169799
+0x316f
+// -0.264303
+0xb43b
+// -0.075679
+0xacd8
+// -0.062243
+0xabf8
+// -0.322429
+0xb529
+// -0.229378
+0xb357
+// 0.020636
+0x2548
+// 0.474186
+0x3796
+// -0.149192
+0xb0c6
+// 0.159253
+0x3119
+// -0.418241
+0xb6b1
+// -0.220744
+0xb310
+// -0.332685
+0xb553
+// 0.078293
+0x2d03
+// 0.284063
+0x348c
+// 0.109206
+0x2efd
+// 0.069842
+0x2c78
+// -0.054476
+0xaaf9
+// -0.018401
+0xa4b6
+// 0.077888
+0x2cfc
+// 0.219216
+0x3304
+// 0.174853
+0x3198
+// 0.218507
+0x32fe
+// 0.208197
+0x32aa
+// -0.057710
+0xab63
+// -0.231653
+0xb36a
+// -0.213055
+0xb2d1
+// -0.174800
+0xb198
+// -0.099992
+0xae66
+// 0.081162
+0x2d32
+// -0.150392
+0xb0d0
+// -0.448191
+0xb72c
+// 0.200164
+0x3268
+// 0.020702
+0x254d
+// -0.249379
+0xb3fb
+// 0.079454
+0x2d16
+// 0.215899
+0x32e9
+// 0.415424
+0x36a6
+// -0.369649
+0xb5ea
+// 0.007064
+0x1f3c
+// -0.536642
+0xb84b
+// -0.106107
+0xaeca
+// -0.074443
+0xacc4
+// 0.087497
+0x2d9a
+// 0.543513
+0x3859
+// -0.090931
+0xadd2
+// -0.197363
+0xb251
+// -0.452118
+0xb73c
+// 0.139166
+0x3074
+// 0.054687
+0x2b00
+// -0.274367
+0xb464
+// -0.153652
+0xb0eb
+// -0.458440
+0xb756
+// -0.159573
+0xb11b
+// -0.014334
+0xa357
+// -0.138766
+0xb071
+// -0.285817
+0xb493
+// 0.166074
+0x3150
+// -0.007518
+0x9fb3
+// -0.287886
+0xb49b
+// 0.040596
+0x2932
+// 0.024333
+0x263b
+// -0.711750
+0xb9b2
+// -0.111767
+0xaf27
+// 0.123774
+0x2fec
+// -0.405266
+0xb67c
+// -0.291294
+0xb4a9
+// 0.165725
+0x314e
+// -0.390727
+0xb640
+// 0.037912
+0x28da
+// 0.067118
+0x2c4c
+// -0.020696
+0xa54c
+// 0.469622
+0x3784
+// -0.268572
+0xb44c
+// -0.365714
+0xb5da
+// 0.359382
+0x35c0
+// -0.351236
+0xb59f
+// 0.003563
+0x1b4c
+// -0.055833
+0xab26
+// 0.185036
+0x31ec
+// 0.220537
+0x330f
+// 0.142509
+0x308f
+// -0.131898
+0xb039
+// -0.040169
+0xa924
+// 0.340507
+0x3573
+// -0.443301
+0xb718
+// -0.504501
+0xb809
+// -0.143797
+0xb09a
+// -0.224534
+0xb32f
+// 0.413910
+0x369f
+// -0.304571
+0xb4e0
+// -0.546099
+0xb85e
+// 0.298548
+0x34c7
+// -0.075447
+0xacd4
+// -0.397018
+0xb65a
+// -0.706257
+0xb9a6
+// -0.326503
+0xb539
+// 0.027824
+0x271f
+// -0.067521
+0xac52
+// 0.132370
+0x303c
+// -0.119409
+0xafa4
+// 0.417147
+0x36ad
+// -0.053274
+0xaad2
+// 0.215552
+0x32e6
+// 0.555113
+0x3871
+// 0.132507
+0x303d
+// -0.112059
+0xaf2c
+// -0.438044
+0xb702
+// -0.061994
+0xabef
+// 0.420391
+0x36ba
+// -0.511288
+0xb817
+// -0.169411
+0xb16c
+// 0.455896
+0x374b
+// -0.037098
+0xa8c0
+// 0.097329
+0x2e3b
+// -0.510351
+0xb815
+// 0.031878
+0x2815
+// 0.451849
+0x373b
+// -0.005921
+0x9e10
+// 0.522571
+0x382e
+// -0.795109
+0xba5c
+// -0.063013
+0xac08
+// -0.395304
+0xb653
+// 0.044986
+0x29c2
+// 0.439022
+0x3706
+// 0.151798
+0x30dc
+// 1.000000
+0x3c00
+// 0.151786
+0x30db
+// 0.096127
+0x2e27
+// -0.079173
+0xad11
+// -0.182049
+0xb1d3
+// 0.381454
+0x361a
+// 0.370677
+0x35ee
+// -0.187572
+0xb201
+// 0.183005
+0x31db
+// -0.588512
+0xb8b5
+// -0.118559
+0xaf96
+// 0.200334
+0x3269
+// 0.120477
+0x2fb6
+// 0.423841
+0x36c8
+// -0.482627
+0xb7b9
+// 0.069639
+0x2c75
+// 0.179386
+0x31be
+// -0.066133
+0xac3c
+// 0.042963
+0x2980
+// -0.106336
+0xaece
+// -0.125617
+0xb005
+// -0.464414
+0xb76e
+// 0.132390
+0x303d
+// -0.202302
+0xb279
+// -0.703952
+0xb9a2
+// -0.128242
+0xb01b
+// 0.437213
+0x36ff
+// 0.160378
+0x3122
+// -0.112012
+0xaf2b
+// -0.038690
+0xa8f4
diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/Input2_f16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/Input2_f16.txt
new file mode 100755
index 0000000..7e79907
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/Input2_f16.txt
@@ -0,0 +1,602 @@
+H
+300
+// 0.181541
+0x31cf
+// 0.169745
+0x316f
+// 0.237867
+0x339d
+// 0.280697
+0x347e
+// 0.111340
+0x2f20
+// 0.281630
+0x3482
+// 0.426820
+0x36d4
+// 0.147220
+0x30b6
+// 0.301289
+0x34d2
+// 0.085008
+0x2d71
+// 0.096822
+0x2e32
+// 0.118322
+0x2f93
+// 0.026424
+0x26c4
+// 0.105946
+0x2ec8
+// 0.411642
+0x3696
+// 0.136448
+0x305e
+// 0.335485
+0x355e
+// 0.202068
+0x3277
+// 0.361403
+0x35c8
+// 0.478874
+0x37a9
+// 0.554829
+0x3870
+// 0.725607
+0x39ce
+// 0.397848
+0x365e
+// 0.081577
+0x2d39
+// 0.376096
+0x3604
+// 0.619949
+0x38f6
+// 0.035635
+0x2890
+// 0.045637
+0x29d7
+// 0.168639
+0x3165
+// 0.170281
+0x3173
+// 0.077000
+0x2cee
+// 0.167346
+0x315b
+// 0.189246
+0x320e
+// 0.327278
+0x353d
+// 0.125620
+0x3005
+// 0.302179
+0x34d6
+// 0.324256
+0x3530
+// 0.115925
+0x2f6b
+// 0.023388
+0x25fd
+// 0.213505
+0x32d5
+// 0.249834
+0x33ff
+// 0.230302
+0x335f
+// 0.052223
+0x2aaf
+// 0.118431
+0x2f94
+// 0.237972
+0x339d
+// 0.167228
+0x315a
+// 0.500285
+0x3801
+// 0.396042
+0x3656
+// 0.287551
+0x349a
+// 0.363907
+0x35d3
+// 0.285888
+0x3493
+// 0.298927
+0x34c8
+// 0.384334
+0x3626
+// 0.214899
+0x32e0
+// 0.256566
+0x341b
+// 0.438213
+0x3703
+// 0.057463
+0x2b5b
+// 0.099164
+0x2e59
+// 0.337406
+0x3566
+// 0.602355
+0x38d2
+// 0.003762
+0x1bb4
+// 0.270555
+0x3454
+// 0.351693
+0x35a1
+// 0.279530
+0x3479
+// 0.365779
+0x35da
+// 0.133551
+0x3046
+// 0.059872
+0x2baa
+// 0.286309
+0x3495
+// 0.246533
+0x33e4
+// 0.171805
+0x317f
+// 0.341557
+0x3577
+// 0.024636
+0x264f
+// 0.191050
+0x321d
+// 0.093971
+0x2e04
+// 0.077312
+0x2cf3
+// 0.628921
+0x3908
+// 0.057062
+0x2b4e
+// 0.004234
+0x1c56
+// 0.702554
+0x399f
+// 0.070054
+0x2c7c
+// 0.126315
+0x300b
+// 0.114205
+0x2f4f
+// 0.174413
+0x3195
+// 0.323334
+0x352c
+// 0.419826
+0x36b8
+// 0.092743
+0x2df0
+// 0.023260
+0x25f4
+// 0.169239
+0x316a
+// 0.112398
+0x2f32
+// 0.530023
+0x383d
+// 0.057968
+0x2b6b
+// 0.099520
+0x2e5f
+// 0.249493
+0x33fc
+// 0.158562
+0x3113
+// 0.442311
+0x3714
+// 0.375796
+0x3603
+// 0.262720
+0x3434
+// 0.068077
+0x2c5b
+// 0.338289
+0x356a
+// 0.158634
+0x3114
+// 0.292740
+0x34af
+// 0.255336
+0x3416
+// 0.163457
+0x313b
+// 0.642740
+0x3924
+// 0.303784
+0x34dc
+// 0.290379
+0x34a5
+// 0.139732
+0x3079
+// 0.531862
+0x3841
+// 0.109192
+0x2efd
+// 0.051034
+0x2a88
+// 0.845953
+0x3ac5
+// 0.370689
+0x35ee
+// 0.224557
+0x3330
+// 0.087760
+0x2d9e
+// 0.044607
+0x29b6
+// 0.176383
+0x31a5
+// 0.054776
+0x2b03
+// 0.340220
+0x3572
+// 0.437922
+0x3702
+// 0.336270
+0x3561
+// 0.267078
+0x3446
+// 0.069067
+0x2c6c
+// 0.058832
+0x2b88
+// 0.331618
+0x354e
+// 0.029930
+0x27a9
+// 0.609125
+0x38df
+// 0.251916
+0x3408
+// 0.122801
+0x2fdc
+// 0.387843
+0x3635
+// 0.112303
+0x2f30
+// 0.407489
+0x3685
+// 0.316717
+0x3511
+// 0.076934
+0x2cec
+// 0.299806
+0x34cc
+// 0.123522
+0x2fe8
+// 0.221139
+0x3314
+// 0.012030
+0x2229
+// 0.330032
+0x3548
+// 0.043511
+0x2992
+// 0.790171
+0x3a52
+// 0.119824
+0x2fab
+// 0.009153
+0x20b0
+// 0.212885
+0x32d0
+// 0.430953
+0x36e5
+// 0.169799
+0x316f
+// 0.264303
+0x343b
+// 0.075679
+0x2cd8
+// 0.062243
+0x2bf8
+// 0.322429
+0x3529
+// 0.229378
+0x3357
+// 0.020636
+0x2548
+// 0.474186
+0x3796
+// 0.149192
+0x30c6
+// 0.159253
+0x3119
+// 0.418241
+0x36b1
+// 0.220744
+0x3310
+// 0.332685
+0x3553
+// 0.078293
+0x2d03
+// 0.284063
+0x348c
+// 0.109206
+0x2efd
+// 0.069842
+0x2c78
+// 0.054476
+0x2af9
+// 0.018401
+0x24b6
+// 0.077888
+0x2cfc
+// 0.219216
+0x3304
+// 0.174853
+0x3198
+// 0.218507
+0x32fe
+// 0.208197
+0x32aa
+// 0.057710
+0x2b63
+// 0.231653
+0x336a
+// 0.213055
+0x32d1
+// 0.174800
+0x3198
+// 0.099992
+0x2e66
+// 0.081162
+0x2d32
+// 0.150392
+0x30d0
+// 0.448191
+0x372c
+// 0.200164
+0x3268
+// 0.020702
+0x254d
+// 0.249379
+0x33fb
+// 0.079454
+0x2d16
+// 0.215899
+0x32e9
+// 0.415424
+0x36a6
+// 0.369649
+0x35ea
+// 0.007064
+0x1f3c
+// 0.536642
+0x384b
+// 0.106107
+0x2eca
+// 0.074443
+0x2cc4
+// 0.087497
+0x2d9a
+// 0.543513
+0x3859
+// 0.090931
+0x2dd2
+// 0.197363
+0x3251
+// 0.452118
+0x373c
+// 0.139166
+0x3074
+// 0.054687
+0x2b00
+// 0.274367
+0x3464
+// 0.153652
+0x30eb
+// 0.458440
+0x3756
+// 0.159573
+0x311b
+// 0.014334
+0x2357
+// 0.138766
+0x3071
+// 0.285817
+0x3493
+// 0.166074
+0x3150
+// 0.007518
+0x1fb3
+// 0.287886
+0x349b
+// 0.040596
+0x2932
+// 0.024333
+0x263b
+// 0.711750
+0x39b2
+// 0.111767
+0x2f27
+// 0.123774
+0x2fec
+// 0.405266
+0x367c
+// 0.291294
+0x34a9
+// 0.165725
+0x314e
+// 0.390727
+0x3640
+// 0.037912
+0x28da
+// 0.067118
+0x2c4c
+// 0.020696
+0x254c
+// 0.469622
+0x3784
+// 0.268572
+0x344c
+// 0.365714
+0x35da
+// 0.359382
+0x35c0
+// 0.351236
+0x359f
+// 0.003563
+0x1b4c
+// 0.055833
+0x2b26
+// 0.185036
+0x31ec
+// 0.220537
+0x330f
+// 0.142509
+0x308f
+// 0.131898
+0x3039
+// 0.040169
+0x2924
+// 0.340507
+0x3573
+// 0.443301
+0x3718
+// 0.504501
+0x3809
+// 0.143797
+0x309a
+// 0.224534
+0x332f
+// 0.413910
+0x369f
+// 0.304571
+0x34e0
+// 0.546099
+0x385e
+// 0.298548
+0x34c7
+// 0.075447
+0x2cd4
+// 0.397018
+0x365a
+// 0.706257
+0x39a6
+// 0.326503
+0x3539
+// 0.027824
+0x271f
+// 0.067521
+0x2c52
+// 0.132370
+0x303c
+// 0.119409
+0x2fa4
+// 0.417147
+0x36ad
+// 0.053274
+0x2ad2
+// 0.215552
+0x32e6
+// 0.555113
+0x3871
+// 0.132507
+0x303d
+// 0.112059
+0x2f2c
+// 0.438044
+0x3702
+// 0.061994
+0x2bef
+// 0.420391
+0x36ba
+// 0.511288
+0x3817
+// 0.169411
+0x316c
+// 0.455896
+0x374b
+// 0.037098
+0x28c0
+// 0.097329
+0x2e3b
+// 0.510351
+0x3815
+// 0.031878
+0x2815
+// 0.451849
+0x373b
+// 0.005921
+0x1e10
+// 0.522571
+0x382e
+// 0.795109
+0x3a5c
+// 0.063013
+0x2c08
+// 0.395304
+0x3653
+// 0.044986
+0x29c2
+// 0.439022
+0x3706
+// 0.151798
+0x30dc
+// 1.000000
+0x3c00
+// 0.151786
+0x30db
+// 0.096127
+0x2e27
+// 0.079173
+0x2d11
+// 0.182049
+0x31d3
+// 0.381454
+0x361a
+// 0.370677
+0x35ee
+// 0.187572
+0x3201
+// 0.183005
+0x31db
+// 0.588512
+0x38b5
+// 0.118559
+0x2f96
+// 0.200334
+0x3269
+// 0.120477
+0x2fb6
+// 0.423841
+0x36c8
+// 0.482627
+0x37b9
+// 0.069639
+0x2c75
+// 0.179386
+0x31be
+// 0.066133
+0x2c3c
+// 0.042963
+0x2980
+// 0.106336
+0x2ece
+// 0.125617
+0x3005
+// 0.464414
+0x376e
+// 0.132390
+0x303d
+// 0.202302
+0x3279
+// 0.703952
+0x39a2
+// 0.128242
+0x301b
+// 0.437213
+0x36ff
+// 0.160378
+0x3122
+// 0.112012
+0x2f2b
+// 0.038690
+0x28f4
diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MaxIndexes1_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MaxIndexes1_s16.txt
new file mode 100755
index 0000000..2f82b16
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MaxIndexes1_s16.txt
@@ -0,0 +1,8 @@
+H
+3
+// 6
+0x0006
+// 6
+0x0006
+// 6
+0x0006
diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MaxVals1_f16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MaxVals1_f16.txt
new file mode 100755
index 0000000..5ae652f
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MaxVals1_f16.txt
@@ -0,0 +1,8 @@
+H
+3
+// 0.426820
+0x36d4
+// 0.426820
+0x36d4
+// 0.426820
+0x36d4
diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MeanVals2_f16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MeanVals2_f16.txt
new file mode 100755
index 0000000..b32fb52
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MeanVals2_f16.txt
@@ -0,0 +1,10 @@
+H
+4
+// 0.241377
+0x33b9
+// 0.194923
+0x323d
+// 0.268473
+0x344c
+// 0.237753
+0x339c
diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MinIndexes3_s16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MinIndexes3_s16.txt
new file mode 100755
index 0000000..5af71b9
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MinIndexes3_s16.txt
@@ -0,0 +1,8 @@
+H
+3
+// 5
+0x0005
+// 8
+0x0008
+// 21
+0x0015
diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MinVals3_f16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MinVals3_f16.txt
new file mode 100755
index 0000000..452e2aa
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/MinVals3_f16.txt
@@ -0,0 +1,8 @@
+H
+3
+// -0.281630
+0xb482
+// -0.301289
+0xb4d2
+// -0.725607
+0xb9ce
diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/PowerVals4_f16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/PowerVals4_f16.txt
new file mode 100755
index 0000000..b4a756e
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/PowerVals4_f16.txt
@@ -0,0 +1,8 @@
+H
+3
+// 0.471030
+0x3789
+// 0.814069
+0x3a83
+// 2.320008
+0x40a4
diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/RmsVals5_f16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/RmsVals5_f16.txt
new file mode 100755
index 0000000..1fffea7
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/RmsVals5_f16.txt
@@ -0,0 +1,10 @@
+H
+4
+// 0.259403
+0x3427
+// 0.225564
+0x3338
+// 0.317600
+0x3515
+// 0.288172
+0x349c
diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/StdVals6_f16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/StdVals6_f16.txt
new file mode 100755
index 0000000..74d5c2e
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/StdVals6_f16.txt
@@ -0,0 +1,10 @@
+H
+4
+// 0.272449
+0x345c
+// 0.230237
+0x335e
+// 0.305035
+0x34e1
+// 0.289078
+0x34a0
diff --git a/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/VarVals7_f16.txt b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/VarVals7_f16.txt
new file mode 100755
index 0000000..05554e2
--- /dev/null
+++ b/CMSIS/DSP/Testing/Patterns/DSP/Stats/StatsF16/VarVals7_f16.txt
@@ -0,0 +1,10 @@
+H
+4
+// 0.074228
+0x2cc0
+// 0.053009
+0x2ac9
+// 0.093046
+0x2df4
+// 0.083566
+0x2d59
diff --git a/CMSIS/DSP/Testing/Source/Tests/StatsTestsF16.cpp b/CMSIS/DSP/Testing/Source/Tests/StatsTestsF16.cpp
new file mode 100755
index 0000000..909651d
--- /dev/null
+++ b/CMSIS/DSP/Testing/Source/Tests/StatsTestsF16.cpp
@@ -0,0 +1,749 @@
+#include "StatsTestsF16.h"
+#include <stdio.h>
+#include "Error.h"
+#include "Test.h"
+
+
+#define SNR_THRESHOLD 50
+/*
+
+Reference patterns are generated with
+a double precision computation.
+
+*/
+#define REL_ERROR (3.0e-3)
+
+ void StatsTestsF16::test_max_f16()
+ {
+ const float16_t *inp = inputA.ptr();
+
+ float16_t result;
+ uint32_t indexval;
+
+ float16_t *refp = ref.ptr();
+ int16_t *refind = maxIndexes.ptr();
+
+ float16_t *outp = output.ptr();
+ int16_t *ind = index.ptr();
+
+ arm_max_f16(inp,
+ inputA.nbSamples(),
+ &result,
+ &indexval);
+
+ outp[0] = result;
+ ind[0] = indexval;
+
+ ASSERT_EQ(result,refp[this->refOffset]);
+ ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);
+
+ }
+
+#if 0
+ void StatsTestsF16::test_max_no_idx_f16()
+ {
+ const float16_t *inp = inputA.ptr();
+
+ float16_t result;
+
+ float16_t *refp = ref.ptr();
+
+ float16_t *outp = output.ptr();
+
+ arm_max_no_idx_f16(inp,
+ inputA.nbSamples(),
+ &result);
+
+ outp[0] = result;
+
+ ASSERT_EQ(result,refp[this->refOffset]);
+
+ }
+#endif
+
+ void StatsTestsF16::test_min_f16()
+ {
+ const float16_t *inp = inputA.ptr();
+
+ float16_t result;
+ uint32_t indexval;
+
+ float16_t *refp = ref.ptr();
+ int16_t *refind = minIndexes.ptr();
+
+ float16_t *outp = output.ptr();
+ int16_t *ind = index.ptr();
+
+ arm_min_f16(inp,
+ inputA.nbSamples(),
+ &result,
+ &indexval);
+
+ outp[0] = result;
+ ind[0] = indexval;
+
+ ASSERT_EQ(result,refp[this->refOffset]);
+ ASSERT_EQ((int16_t)indexval,refind[this->refOffset]);
+
+ }
+
+ void StatsTestsF16::test_mean_f16()
+ {
+ const float16_t *inp = inputA.ptr();
+
+ float16_t result;
+
+ float16_t *refp = ref.ptr();
+
+ float16_t *outp = output.ptr();
+
+ arm_mean_f16(inp,
+ inputA.nbSamples(),
+ &result);
+
+ outp[0] = result;
+
+ ASSERT_SNR(result,refp[this->refOffset],(float16_t)SNR_THRESHOLD);
+
+ ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);
+
+ }
+
+ void StatsTestsF16::test_power_f16()
+ {
+ const float16_t *inp = inputA.ptr();
+
+ float16_t result;
+
+ float16_t *refp = ref.ptr();
+
+ float16_t *outp = output.ptr();
+
+ arm_power_f16(inp,
+ inputA.nbSamples(),
+ &result);
+
+ outp[0] = result;
+
+ ASSERT_SNR(result,refp[this->refOffset],(float16_t)SNR_THRESHOLD);
+
+ ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);
+
+ }
+
+ void StatsTestsF16::test_rms_f16()
+ {
+ const float16_t *inp = inputA.ptr();
+
+ float16_t result;
+
+ float16_t *refp = ref.ptr();
+
+ float16_t *outp = output.ptr();
+
+ arm_rms_f16(inp,
+ inputA.nbSamples(),
+ &result);
+
+ outp[0] = result;
+
+ ASSERT_SNR(result,refp[this->refOffset],(float16_t)SNR_THRESHOLD);
+
+ ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);
+
+ }
+
+ void StatsTestsF16::test_std_f16()
+ {
+ const float16_t *inp = inputA.ptr();
+
+ float16_t result;
+
+ float16_t *refp = ref.ptr();
+
+ float16_t *outp = output.ptr();
+
+ arm_std_f16(inp,
+ inputA.nbSamples(),
+ &result);
+
+ outp[0] = result;
+
+ ASSERT_SNR(result,refp[this->refOffset],(float16_t)SNR_THRESHOLD);
+
+ ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);
+
+ }
+
+ void StatsTestsF16::test_var_f16()
+ {
+ const float16_t *inp = inputA.ptr();
+
+ float16_t result;
+
+ float16_t *refp = ref.ptr();
+
+ float16_t *outp = output.ptr();
+
+ arm_var_f16(inp,
+ inputA.nbSamples(),
+ &result);
+
+ outp[0] = result;
+
+ ASSERT_SNR(result,refp[this->refOffset],(float16_t)SNR_THRESHOLD);
+
+ ASSERT_REL_ERROR(result,refp[this->refOffset],REL_ERROR);
+
+ }
+
+
+ void StatsTestsF16::test_std_stability_f16()
+ {
+ /*
+
+ With the textbook algorithm, those values will produce a negative
+ value for the variance.
+
+ The CMSIS-DSP variance algorithm is the two pass one so will work
+ with those values.
+
+ So, it should be possible to compute the square root for the standard
+ deviation.
+
+ */
+ float16_t in[4]={4.0f, 7.0f, 13.0f, 16.0f};
+ float16_t result;
+ int i;
+
+ /*
+
+ Add bigger offset so that average is much bigger than standard deviation.
+
+ */
+ for(i=0 ; i < 4; i++)
+ {
+ in[i] += 3.0e3f;
+ }
+
+ arm_std_f16(in,4,&result);
+
+ /*
+
+ If variance is giving a negative value, the square root
+ should return zero.
+
+ We check it is not happening here.
+
+
+ */
+ ASSERT_TRUE(fabs(5.47723f - result) < 0.32f);
+
+ }
+
+#if 0
+ void StatsTestsF16::test_entropy_f16()
+ {
+ const float16_t *inp = inputA.ptr();
+ const int16_t *dimsp = dims.ptr();
+
+ float16_t *outp = output.ptr();
+
+ for(int i=0;i < this->nbPatterns; i++)
+ {
+ *outp = arm_entropy_f16(inp,dimsp[i+1]);
+ outp++;
+ inp += dimsp[i+1];
+ }
+
+ ASSERT_SNR(ref,output,(float16_t)SNR_THRESHOLD);
+
+ ASSERT_REL_ERROR(ref,output,REL_ERROR);
+
+ }
+
+ void StatsTestsF16::test_logsumexp_f16()
+ {
+ const float16_t *inp = inputA.ptr();
+ const int16_t *dimsp = dims.ptr();
+
+ float16_t *outp = output.ptr();
+
+ for(int i=0;i < this->nbPatterns; i++)
+ {
+ *outp = arm_logsumexp_f16(inp,dimsp[i+1]);
+ outp++;
+ inp += dimsp[i+1];
+ }
+
+ ASSERT_SNR(ref,output,(float16_t)SNR_THRESHOLD);
+
+ ASSERT_REL_ERROR(ref,output,REL_ERROR);
+ }
+
+
+ void StatsTestsF16::test_kullback_leibler_f16()
+ {
+ const float16_t *inpA = inputA.ptr();
+ const float16_t *inpB = inputB.ptr();
+ const int16_t *dimsp = dims.ptr();
+
+ float16_t *outp = output.ptr();
+
+ for(int i=0;i < this->nbPatterns; i++)
+ {
+ *outp = arm_kullback_leibler_f16(inpA,inpB,dimsp[i+1]);
+ outp++;
+ inpA += dimsp[i+1];
+ inpB += dimsp[i+1];
+ }
+
+ ASSERT_SNR(ref,output,(float16_t)SNR_THRESHOLD);
+
+ ASSERT_REL_ERROR(ref,output,REL_ERROR);
+ }
+
+ void StatsTestsF16::test_logsumexp_dot_prod_f16()
+ {
+ const float16_t *inpA = inputA.ptr();
+ const float16_t *inpB = inputB.ptr();
+ const int16_t *dimsp = dims.ptr();
+
+ float16_t *outp = output.ptr();
+ float16_t *tmpp = tmp.ptr();
+
+ for(int i=0;i < this->nbPatterns; i++)
+ {
+ *outp = arm_logsumexp_dot_prod_f16(inpA,inpB,dimsp[i+1],tmpp);
+ outp++;
+ inpA += dimsp[i+1];
+ inpB += dimsp[i+1];
+ }
+
+ ASSERT_SNR(ref,output,(float16_t)SNR_THRESHOLD);
+
+ ASSERT_REL_ERROR(ref,output,REL_ERROR);
+ }
+
+ #endif
+
+ void StatsTestsF16::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
+ {
+ (void)paramsArgs;
+ switch(id)
+ {
+ case StatsTestsF16::TEST_MAX_F16_1:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,7);
+
+ maxIndexes.reload(StatsTestsF16::MAXINDEXES_S16_ID,mgr);
+ ref.reload(StatsTestsF16::MAXVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+ index.create(1,StatsTestsF16::OUT_S16_ID,mgr);
+
+ refOffset = 0;
+ }
+ break;
+
+ case StatsTestsF16::TEST_MAX_F16_2:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,16);
+
+ maxIndexes.reload(StatsTestsF16::MAXINDEXES_S16_ID,mgr);
+ ref.reload(StatsTestsF16::MAXVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+ index.create(1,StatsTestsF16::OUT_S16_ID,mgr);
+
+ refOffset = 1;
+ }
+ break;
+
+ case StatsTestsF16::TEST_MAX_F16_3:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,23);
+
+ maxIndexes.reload(StatsTestsF16::MAXINDEXES_S16_ID,mgr);
+ ref.reload(StatsTestsF16::MAXVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+ index.create(1,StatsTestsF16::OUT_S16_ID,mgr);
+
+ refOffset = 2;
+ }
+ break;
+
+ case StatsTestsF16::TEST_MEAN_F16_4:
+ {
+ inputA.reload(StatsTestsF16::INPUT2_F16_ID,mgr,7);
+
+ ref.reload(StatsTestsF16::MEANVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 0;
+ }
+ break;
+
+ case StatsTestsF16::TEST_MEAN_F16_5:
+ {
+ inputA.reload(StatsTestsF16::INPUT2_F16_ID,mgr,16);
+
+ ref.reload(StatsTestsF16::MEANVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 1;
+ }
+ break;
+
+ case StatsTestsF16::TEST_MEAN_F16_6:
+ {
+ inputA.reload(StatsTestsF16::INPUT2_F16_ID,mgr,23);
+
+ ref.reload(StatsTestsF16::MEANVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 2;
+ }
+ break;
+
+ case StatsTestsF16::TEST_MIN_F16_7:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,7);
+
+ minIndexes.reload(StatsTestsF16::MININDEXES_S16_ID,mgr);
+ ref.reload(StatsTestsF16::MINVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+ index.create(1,StatsTestsF16::OUT_S16_ID,mgr);
+
+ refOffset = 0;
+ }
+ break;
+
+ case StatsTestsF16::TEST_MIN_F16_8:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,16);
+
+ minIndexes.reload(StatsTestsF16::MININDEXES_S16_ID,mgr);
+ ref.reload(StatsTestsF16::MINVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+ index.create(1,StatsTestsF16::OUT_S16_ID,mgr);
+
+ refOffset = 1;
+ }
+ break;
+
+ case StatsTestsF16::TEST_MIN_F16_9:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,23);
+
+ minIndexes.reload(StatsTestsF16::MININDEXES_S16_ID,mgr);
+ ref.reload(StatsTestsF16::MINVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+ index.create(1,StatsTestsF16::OUT_S16_ID,mgr);
+
+ refOffset = 2;
+ }
+ break;
+
+ case StatsTestsF16::TEST_POWER_F16_10:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,7);
+
+ ref.reload(StatsTestsF16::POWERVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 0;
+ }
+ break;
+
+ case StatsTestsF16::TEST_POWER_F16_11:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,16);
+
+ ref.reload(StatsTestsF16::POWERVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 1;
+ }
+ break;
+
+ case StatsTestsF16::TEST_POWER_F16_12:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,23);
+
+ ref.reload(StatsTestsF16::POWERVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 2;
+ }
+ break;
+
+ case StatsTestsF16::TEST_RMS_F16_13:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,7);
+
+ ref.reload(StatsTestsF16::RMSVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 0;
+ }
+ break;
+
+ case StatsTestsF16::TEST_RMS_F16_14:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,16);
+
+ ref.reload(StatsTestsF16::RMSVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 1;
+ }
+ break;
+
+ case StatsTestsF16::TEST_RMS_F16_15:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,23);
+
+ ref.reload(StatsTestsF16::RMSVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 2;
+ }
+ break;
+
+ case StatsTestsF16::TEST_STD_F16_16:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,7);
+
+ ref.reload(StatsTestsF16::STDVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 0;
+ }
+ break;
+
+ case StatsTestsF16::TEST_STD_F16_17:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,16);
+
+ ref.reload(StatsTestsF16::STDVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 1;
+ }
+ break;
+
+ case StatsTestsF16::TEST_STD_F16_18:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,23);
+
+ ref.reload(StatsTestsF16::STDVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 2;
+ }
+ break;
+
+ case StatsTestsF16::TEST_VAR_F16_19:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,7);
+
+ ref.reload(StatsTestsF16::VARVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 0;
+ }
+ break;
+
+ case StatsTestsF16::TEST_VAR_F16_20:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,16);
+
+ ref.reload(StatsTestsF16::VARVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 1;
+ }
+ break;
+
+ case StatsTestsF16::TEST_VAR_F16_21:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,23);
+
+ ref.reload(StatsTestsF16::VARVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 2;
+ }
+ break;
+#if 0
+ case StatsTestsF16::TEST_ENTROPY_F16_22:
+ {
+ inputA.reload(StatsTestsF16::INPUT22_F16_ID,mgr);
+ dims.reload(StatsTestsF16::DIM22_S16_ID,mgr);
+ ref.reload(StatsTestsF16::REF22_ENTROPY_F16_ID,mgr);
+ output.create(ref.nbSamples(),StatsTestsF16::OUT_F16_ID,mgr);
+
+ const int16_t *dimsp = dims.ptr();
+ this->nbPatterns=dimsp[0];
+ }
+ break;
+
+ case StatsTestsF16::TEST_LOGSUMEXP_F16_23:
+ {
+ inputA.reload(StatsTestsF16::INPUT23_F16_ID,mgr);
+ dims.reload(StatsTestsF16::DIM23_S16_ID,mgr);
+ ref.reload(StatsTestsF16::REF23_LOGSUMEXP_F16_ID,mgr);
+ output.create(ref.nbSamples(),StatsTestsF16::OUT_F16_ID,mgr);
+
+ const int16_t *dimsp = dims.ptr();
+ this->nbPatterns=dimsp[0];
+ }
+ break;
+
+ case StatsTestsF16::TEST_KULLBACK_LEIBLER_F16_24:
+ {
+ inputA.reload(StatsTestsF16::INPUTA24_F16_ID,mgr);
+ inputB.reload(StatsTestsF16::INPUTB24_F16_ID,mgr);
+ dims.reload(StatsTestsF16::DIM24_S16_ID,mgr);
+ ref.reload(StatsTestsF16::REF24_KL_F16_ID,mgr);
+ output.create(ref.nbSamples(),StatsTestsF16::OUT_F16_ID,mgr);
+
+ const int16_t *dimsp = dims.ptr();
+ this->nbPatterns=dimsp[0];
+ }
+ break;
+
+ case StatsTestsF16::TEST_LOGSUMEXP_DOT_PROD_F16_25:
+ {
+ inputA.reload(StatsTestsF16::INPUTA25_F16_ID,mgr);
+ inputB.reload(StatsTestsF16::INPUTB25_F16_ID,mgr);
+ dims.reload(StatsTestsF16::DIM25_S16_ID,mgr);
+ ref.reload(StatsTestsF16::REF25_LOGSUMEXP_DOT_F16_ID,mgr);
+ output.create(ref.nbSamples(),StatsTestsF16::OUT_F16_ID,mgr);
+
+ const int16_t *dimsp = dims.ptr();
+ this->nbPatterns=dimsp[0];
+
+ /* 12 is max vecDim as defined in Python script generating the data */
+ tmp.create(12,StatsTestsF16::TMP_F16_ID,mgr);
+ }
+ break;
+
+ case StatsTestsF16::TEST_MAX_NO_IDX_F16_26:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,3);
+
+ ref.reload(StatsTestsF16::MAXVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 0;
+ }
+ break;
+
+ case StatsTestsF16::TEST_MAX_NO_IDX_F16_27:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,8);
+
+ ref.reload(StatsTestsF16::MAXVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 1;
+ }
+ break;
+
+ case StatsTestsF16::TEST_MAX_NO_IDX_F16_28:
+ {
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,11);
+
+ ref.reload(StatsTestsF16::MAXVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 2;
+ }
+ break;
+#endif
+ case TEST_MEAN_F16_29:
+ inputA.reload(StatsTestsF16::INPUT2_F16_ID,mgr,100);
+
+ ref.reload(StatsTestsF16::MEANVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 3;
+ break;
+
+ case TEST_RMS_F16_30:
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,100);
+
+ ref.reload(StatsTestsF16::RMSVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 3;
+ break;
+
+ case TEST_STD_F16_31:
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,100);
+
+ ref.reload(StatsTestsF16::STDVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 3;
+ break;
+
+ case TEST_VAR_F16_32:
+ inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,100);
+
+ ref.reload(StatsTestsF16::VARVALS_F16_ID,mgr);
+
+ output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+ refOffset = 3;
+ break;
+ }
+
+ }
+
+ void StatsTestsF16::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
+ {
+ (void)id;
+ switch(id)
+ {
+ case StatsTestsF16::TEST_MAX_F16_1:
+ case StatsTestsF16::TEST_MAX_F16_2:
+ case StatsTestsF16::TEST_MAX_F16_3:
+ case StatsTestsF16::TEST_MIN_F16_7:
+ case StatsTestsF16::TEST_MIN_F16_8:
+ case StatsTestsF16::TEST_MIN_F16_9:
+ index.dump(mgr);
+ output.dump(mgr);
+ break;
+
+ default:
+ output.dump(mgr);
+ }
+ }
diff --git a/CMSIS/DSP/Testing/desc_f16.txt b/CMSIS/DSP/Testing/desc_f16.txt
index 08101bd..e126261 100755
--- a/CMSIS/DSP/Testing/desc_f16.txt
+++ b/CMSIS/DSP/Testing/desc_f16.txt
@@ -5,6 +5,97 @@
class = DSPTests
folder = DSP
+ group Statistics Tests {
+ class = StatsTests
+ folder = Stats
+
+ suite Statistics Tests F16 {
+ class = StatsTestsF16
+ folder = StatsF16
+
+ Pattern INPUT1_F16_ID : Input1_f16.txt
+ Pattern INPUT2_F16_ID : Input2_f16.txt
+ Pattern MAXINDEXES_S16_ID : MaxIndexes1_s16.txt
+ Pattern MAXVALS_F16_ID : MaxVals1_f16.txt
+ Pattern MEANVALS_F16_ID : MeanVals2_f16.txt
+ Pattern MININDEXES_S16_ID : MinIndexes3_s16.txt
+ Pattern MINVALS_F16_ID : MinVals3_f16.txt
+ Pattern POWERVALS_F16_ID : PowerVals4_f16.txt
+ Pattern RMSVALS_F16_ID : RmsVals5_f16.txt
+ Pattern STDVALS_F16_ID : StdVals6_f16.txt
+ Pattern VARVALS_F16_ID : VarVals7_f16.txt
+
+ //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
+ //Pattern REF25_LOGSUMEXP_DOT_F16_ID : RefLogSumExpDot25_f16.txt
+
+ Output OUT_F16_ID : Output
+ Output OUT_S16_ID : Index
+ Output TMP_F16_ID : Temp
+
+ Functions {
+ Test nb=7 arm_max_f16:test_max_f16
+ Test nb=8n arm_max_f16:test_max_f16
+ Test nb=8n+1 arm_max_f16:test_max_f16
+
+ Test nb=7 arm_mean_f16:test_mean_f16
+ Test nb=8n arm_mean_f16:test_mean_f16
+ Test nb=8n+1 arm_mean_f16:test_mean_f16
+
+ Test nb=7 arm_min_f16:test_min_f16
+ Test nb=8n arm_min_f16:test_min_f16
+ Test nb=8n+1 arm_min_f16:test_min_f16
+
+ Test nb=7 arm_power_f16:test_power_f16
+ Test nb=8n arm_power_f16:test_power_f16
+ Test nb=8n+1 arm_power_f16:test_power_f16
+
+ Test nb=7 arm_rms_f16:test_rms_f16
+ Test nb=8n arm_rms_f16:test_rms_f16
+ Test nb=8n+1 arm_rms_f16:test_rms_f16
+
+ Test nb=7 arm_std_f16:test_std_f16
+ Test nb=8n arm_std_f16:test_std_f16
+ Test nb=8n+1 arm_std_f16:test_std_f16
+
+ Test nb=7 arm_var_f16:test_var_f16
+ Test nb=8n arm_var_f16:test_var_f16
+ Test nb=8n+1 arm_var_f16:test_var_f16
+
+ disabled{arm_entropy_f16:test_entropy_f16}
+ disabled{arm_logsumexp_f16:test_logsumexp_f16}
+ disabled{arm_kullback_leibler_f16:test_kullback_leibler_f16}
+ disabled{arm_logsumexp_dot_prod_f16:test_logsumexp_dot_prod_f16}
+
+ disabled{Test nb=7 arm_max_no_idx_f16:test_max_no_idx_f16}
+ disabled{Test nb=8n arm_max_no_idx_f16:test_max_no_idx_f16}
+ disabled{Test nb=8n+1 arm_max_no_idx_f16:test_max_no_idx_f16}
+
+ Test long arm_mean_f16:test_mean_f16
+ Test long arm_rms_f16:test_rms_f16
+ Test long arm_std_f16:test_std_f16
+ Test long arm_var_f16:test_var_f16
+
+ Test stability arm_std_f16:test_std_stability_f16
+ }
+ }
+ }
+
+
group Interpolation Tests{
class = InterpolationTests
folder = Interpolation