+#endif
+
+ /**
+ * @brief Macros required for SINE and COSINE Fast math approximations
+ */
+
+#define FAST_MATH_TABLE_SIZE 512
+#define FAST_MATH_Q31_SHIFT (32 - 10)
+#define FAST_MATH_Q15_SHIFT (16 - 10)
+
+#ifndef PI
+ #define PI 3.14159265358979f
+#endif
+
+#ifndef PI_F64
+ #define PI_F64 3.14159265358979323846
+#endif
+
+
+
+/**
+ * @defgroup groupFastMath Fast Math Functions
+ * This set of functions provides a fast approximation to sine, cosine, and square root.
+ * As compared to most of the other functions in the CMSIS math library, the fast math functions
+ * operate on individual values and not arrays.
+ * There are separate functions for Q15, Q31, and floating-point data.
+ *
+ */
+
+
+ /**
+ * @brief Fast approximation to the trigonometric sine function for floating-point data.
+ * @param[in] x input value in radians.
+ * @return sin(x).
+ */
+ float32_t arm_sin_f32(
+ float32_t x);
+
+
+ /**
+ * @brief Fast approximation to the trigonometric sine function for Q31 data.
+ * @param[in] x Scaled input value in radians.
+ * @return sin(x).
+ */
+ q31_t arm_sin_q31(
+ q31_t x);
+
+ /**
+ * @brief Fast approximation to the trigonometric sine function for Q15 data.
+ * @param[in] x Scaled input value in radians.
+ * @return sin(x).
+ */
+ q15_t arm_sin_q15(
+ q15_t x);
+
+
+ /**
+ * @brief Fast approximation to the trigonometric cosine function for floating-point data.
+ * @param[in] x input value in radians.
+ * @return cos(x).
+ */
+ float32_t arm_cos_f32(
+ float32_t x);
+
+
+ /**
+ * @brief Fast approximation to the trigonometric cosine function for Q31 data.
+ * @param[in] x Scaled input value in radians.
+ * @return cos(x).
+ */
+ q31_t arm_cos_q31(
+ q31_t x);
+
+
+ /**
+ * @brief Fast approximation to the trigonometric cosine function for Q15 data.
+ * @param[in] x Scaled input value in radians.
+ * @return cos(x).
+ */
+ q15_t arm_cos_q15(
+ q15_t x);
+
+
+/**
+ @brief Floating-point vector of log values.
+ @param[in] pSrc points to the input vector
+ @param[out] pDst points to the output vector
+ @param[in] blockSize number of samples in each vector
+ */
+ void arm_vlog_f32(
+ const float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+
+/**
+ @brief Floating-point vector of log values.
+ @param[in] pSrc points to the input vector
+ @param[out] pDst points to the output vector
+ @param[in] blockSize number of samples in each vector
+ */
+ void arm_vlog_f64(
+ const float64_t * pSrc,
+ float64_t * pDst,
+ uint32_t blockSize);
+
+
+
+ /**
+ * @brief q31 vector of log values.
+ * @param[in] pSrc points to the input vector in q31
+ * @param[out] pDst points to the output vector in q5.26
+ * @param[in] blockSize number of samples in each vector
+ */
+ void arm_vlog_q31(const q31_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief q15 vector of log values.
+ * @param[in] pSrc points to the input vector in q15
+ * @param[out] pDst points to the output vector in q4.11
+ * @param[in] blockSize number of samples in each vector
+ */
+ void arm_vlog_q15(const q15_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+
+
+/**
+ @brief Floating-point vector of exp values.
+ @param[in] pSrc points to the input vector
+ @param[out] pDst points to the output vector
+ @param[in] blockSize number of samples in each vector
+ */
+ void arm_vexp_f32(
+ const float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+
+/**
+ @brief Floating-point vector of exp values.
+ @param[in] pSrc points to the input vector
+ @param[out] pDst points to the output vector
+ @param[in] blockSize number of samples in each vector
+ */
+ void arm_vexp_f64(
+ const float64_t * pSrc,
+ float64_t * pDst,
+ uint32_t blockSize);
+
+
+
+ /**
+ * @defgroup SQRT Square Root
+ *
+ * Computes the square root of a number.
+ * There are separate functions for Q15, Q31, and floating-point data types.
+ * The square root function is computed using the Newton-Raphson algorithm.
+ * This is an iterative algorithm of the form:
+ *
+ * x1 = x0 - f(x0)/f'(x0)
+ *
+ * where x1 is the current estimate,
+ * x0 is the previous estimate, and
+ * f'(x0) is the derivative of f() evaluated at x0.
+ * For the square root function, the algorithm reduces to:
+ *
+ * x0 = in/2 [initial guess]
+ * x1 = 1/2 * ( x0 + in / x0) [each iteration]
+ *
+ */
+
+
+ /**
+ * @addtogroup SQRT
+ * @{
+ */
+
+/**
+ @brief Floating-point square root function.
+ @param[in] in input value
+ @param[out] pOut square root of input value
+ @return execution status
+ - \ref ARM_MATH_SUCCESS : input value is positive
+ - \ref ARM_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0
+ */
+__STATIC_FORCEINLINE arm_status arm_sqrt_f32(
+ const float32_t in,
+ float32_t * pOut)
+ {
+ if (in >= 0.0f)
+ {
+#if defined ( __CC_ARM )
+ #if defined __TARGET_FPU_VFP
+ *pOut = __sqrtf(in);
+ #else
+ *pOut = sqrtf(in);
+ #endif
+
+#elif defined ( __ICCARM__ )
+ #if defined __ARMVFP__
+ __ASM("VSQRT.F32 %0,%1" : "=t"(*pOut) : "t"(in));
+ #else
+ *pOut = sqrtf(in);
+ #endif
+
+#elif defined ( __ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 )
+ *pOut = _sqrtf(in);
+#elif defined(__GNUC_PYTHON__)
+ *pOut = sqrtf(in);
+#elif defined ( __GNUC__ )
+ #if defined (__VFP_FP__) && !defined(__SOFTFP__)
+ __ASM("VSQRT.F32 %0,%1" : "=t"(*pOut) : "t"(in));
+ #else
+ *pOut = sqrtf(in);
+ #endif
+#else
+ *pOut = sqrtf(in);
+#endif
+
+ return (ARM_MATH_SUCCESS);
+ }
+ else
+ {
+ *pOut = 0.0f;
+ return (ARM_MATH_ARGUMENT_ERROR);
+ }
+ }
+
+
+/**
+ @brief Q31 square root function.
+ @param[in] in input value. The range of the input value is [0 +1) or 0x00000000 to 0x7FFFFFFF
+ @param[out] pOut points to square root of input value
+ @return execution status
+ - \ref ARM_MATH_SUCCESS : input value is positive
+ - \ref ARM_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0
+ */
+arm_status arm_sqrt_q31(
+ q31_t in,
+ q31_t * pOut);
+
+
+/**
+ @brief Q15 square root function.
+ @param[in] in input value. The range of the input value is [0 +1) or 0x0000 to 0x7FFF
+ @param[out] pOut points to square root of input value
+ @return execution status
+ - \ref ARM_MATH_SUCCESS : input value is positive
+ - \ref ARM_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0
+ */
+arm_status arm_sqrt_q15(
+ q15_t in,
+ q15_t * pOut);
+
+
+
+ /**
+ * @} end of SQRT group
+ */
+
+ /**
+ @brief Fixed point division
+ @param[in] numerator Numerator
+ @param[in] denominator Denominator
+ @param[out] quotient Quotient value normalized between -1.0 and 1.0
+ @param[out] shift Shift left value to get the unnormalized quotient
+ @return error status
+
+ When dividing by 0, an error ARM_MATH_NANINF is returned. And the quotient is forced
+ to the saturated negative or positive value.
+ */
+
+arm_status arm_divide_q15(q15_t numerator,
+ q15_t denominator,
+ q15_t *quotient,
+ int16_t *shift);
+
+ /**
+ @brief Fixed point division
+ @param[in] numerator Numerator
+ @param[in] denominator Denominator
+ @param[out] quotient Quotient value normalized between -1.0 and 1.0
+ @param[out] shift Shift left value to get the unnormalized quotient
+ @return error status
+
+ When dividing by 0, an error ARM_MATH_NANINF is returned. And the quotient is forced
+ to the saturated negative or positive value.
+ */
+
+arm_status arm_divide_q31(q31_t numerator,
+ q31_t denominator,
+ q31_t *quotient,
+ int16_t *shift);
+
+
+
+ /**
+ @brief Arc tangent in radian of y/x using sign of x and y to determine right quadrant.
+ @param[in] y y coordinate
+ @param[in] x x coordinate
+ @param[out] result Result
+ @return error status.
+ */
+ arm_status arm_atan2_f32(float32_t y,float32_t x,float32_t *result);
+
+
+ /**
+ @brief Arc tangent in radian of y/x using sign of x and y to determine right quadrant.
+ @param[in] y y coordinate
+ @param[in] x x coordinate
+ @param[out] result Result in Q2.29
+ @return error status.
+ */
+ arm_status arm_atan2_q31(q31_t y,q31_t x,q31_t *result);
+
+ /**
+ @brief Arc tangent in radian of y/x using sign of x and y to determine right quadrant.
+ @param[in] y y coordinate
+ @param[in] x x coordinate
+ @param[out] result Result in Q2.13
+ @return error status.
+ */
+ arm_status arm_atan2_q15(q15_t y,q15_t x,q15_t *result);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _FAST_MATH_FUNCTIONS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/fast_math_functions_f16.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/fast_math_functions_f16.h
new file mode 100755
index 0000000..1fa45a8
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/fast_math_functions_f16.h
@@ -0,0 +1,122 @@
+/******************************************************************************
+ * @file fast_math_functions_f16.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ * 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.
+ */
+
+
+#ifndef FAST_MATH_FUNCTIONS_F16_H_
+#define FAST_MATH_FUNCTIONS_F16_H_
+
+#include "arm_math_types_f16.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+/* For sqrt_f32 */
+#include "dsp/fast_math_functions.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+ /**
+ * @addtogroup SQRT
+ * @{
+ */
+
+/**
+ @brief Floating-point square root function.
+ @param[in] in input value
+ @param[out] pOut square root of input value
+ @return execution status
+ - \ref ARM_MATH_SUCCESS : input value is positive
+ - \ref ARM_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0
+ */
+__STATIC_FORCEINLINE arm_status arm_sqrt_f16(
+ float16_t in,
+ float16_t * pOut)
+ {
+ float32_t r;
+ arm_status status;
+ status=arm_sqrt_f32((float32_t)in,&r);
+ *pOut=(float16_t)r;
+ return(status);
+ }
+
+
+/**
+ @} end of SQRT group
+ */
+
+/**
+ @brief Floating-point vector of log values.
+ @param[in] pSrc points to the input vector
+ @param[out] pDst points to the output vector
+ @param[in] blockSize number of samples in each vector
+ */
+ void arm_vlog_f16(
+ const float16_t * pSrc,
+ float16_t * pDst,
+ uint32_t blockSize);
+
+/**
+ @brief Floating-point vector of exp values.
+ @param[in] pSrc points to the input vector
+ @param[out] pDst points to the output vector
+ @param[in] blockSize number of samples in each vector
+ */
+ void arm_vexp_f16(
+ const float16_t * pSrc,
+ float16_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ @brief Floating-point vector of inverse values.
+ @param[in] pSrc points to the input vector
+ @param[out] pDst points to the output vector
+ @param[in] blockSize number of samples in each vector
+ */
+ void arm_vinverse_f16(
+ const float16_t * pSrc,
+ float16_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ @brief Arc tangent in radian of y/x using sign of x and y to determine right quadrant.
+ @param[in] y y coordinate
+ @param[in] x x coordinate
+ @param[out] result Result
+ @return error status.
+ */
+ arm_status arm_atan2_f16(float16_t y,float16_t x,float16_t *result);
+
+#endif /*defined(ARM_FLOAT16_SUPPORTED)*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _FAST_MATH_FUNCTIONS_F16_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/filtering_functions.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/filtering_functions.h
new file mode 100755
index 0000000..98b2168
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/filtering_functions.h
@@ -0,0 +1,2570 @@
+/******************************************************************************
+ * @file filtering_functions.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ * 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.
+ */
+
+
+#ifndef FILTERING_FUNCTIONS_H_
+#define FILTERING_FUNCTIONS_H_
+
+#include "arm_math_types.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+#include "dsp/support_functions.h"
+#include "dsp/fast_math_functions.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+
+#define DELTA_Q31 ((q31_t)(0x100))
+#define DELTA_Q15 ((q15_t)0x5)
+
+/**
+ * @defgroup groupFilters Filtering Functions
+ */
+
+ /**
+ * @brief Instance structure for the Q7 FIR filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of filter coefficients in the filter. */
+ q7_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ const q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
+ } arm_fir_instance_q7;
+
+ /**
+ * @brief Instance structure for the Q15 FIR filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of filter coefficients in the filter. */
+ q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ const q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
+ } arm_fir_instance_q15;
+
+ /**
+ * @brief Instance structure for the Q31 FIR filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of filter coefficients in the filter. */
+ q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ const q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
+ } arm_fir_instance_q31;
+
+ /**
+ * @brief Instance structure for the floating-point FIR filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of filter coefficients in the filter. */
+ float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ const float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
+ } arm_fir_instance_f32;
+
+ /**
+ * @brief Instance structure for the floating-point FIR filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of filter coefficients in the filter. */
+ float64_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ const float64_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
+ } arm_fir_instance_f64;
+
+ /**
+ * @brief Processing function for the Q7 FIR filter.
+ * @param[in] S points to an instance of the Q7 FIR filter structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_fir_q7(
+ const arm_fir_instance_q7 * S,
+ const q7_t * pSrc,
+ q7_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Initialization function for the Q7 FIR filter.
+ * @param[in,out] S points to an instance of the Q7 FIR structure.
+ * @param[in] numTaps Number of filter coefficients in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] blockSize number of samples that are processed.
+ *
+ * For the MVE version, the coefficient length must be a multiple of 16.
+ * You can pad with zeros if you have less coefficients.
+ */
+ void arm_fir_init_q7(
+ arm_fir_instance_q7 * S,
+ uint16_t numTaps,
+ const q7_t * pCoeffs,
+ q7_t * pState,
+ uint32_t blockSize);
+
+ /**
+ * @brief Processing function for the Q15 FIR filter.
+ * @param[in] S points to an instance of the Q15 FIR structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_fir_q15(
+ const arm_fir_instance_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Processing function for the fast Q15 FIR filter (fast version).
+ * @param[in] S points to an instance of the Q15 FIR filter structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_fir_fast_q15(
+ const arm_fir_instance_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Initialization function for the Q15 FIR filter.
+ * @param[in,out] S points to an instance of the Q15 FIR filter structure.
+ * @param[in] numTaps Number of filter coefficients in the filter. Must be even and greater than or equal to 4.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] blockSize number of samples that are processed at a time.
+ * @return The function returns either
+ * ARM_MATH_SUCCESS if initialization was successful or
+ * ARM_MATH_ARGUMENT_ERROR if numTaps is not a supported value.
+ *
+ * For the MVE version, the coefficient length must be a multiple of 8.
+ * You can pad with zeros if you have less coefficients.
+ *
+ */
+ arm_status arm_fir_init_q15(
+ arm_fir_instance_q15 * S,
+ uint16_t numTaps,
+ const q15_t * pCoeffs,
+ q15_t * pState,
+ uint32_t blockSize);
+
+ /**
+ * @brief Processing function for the Q31 FIR filter.
+ * @param[in] S points to an instance of the Q31 FIR filter structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_fir_q31(
+ const arm_fir_instance_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Processing function for the fast Q31 FIR filter (fast version).
+ * @param[in] S points to an instance of the Q31 FIR filter structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_fir_fast_q31(
+ const arm_fir_instance_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Initialization function for the Q31 FIR filter.
+ * @param[in,out] S points to an instance of the Q31 FIR structure.
+ * @param[in] numTaps Number of filter coefficients in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] blockSize number of samples that are processed at a time.
+ *
+ * For the MVE version, the coefficient length must be a multiple of 4.
+ * You can pad with zeros if you have less coefficients.
+ */
+ void arm_fir_init_q31(
+ arm_fir_instance_q31 * S,
+ uint16_t numTaps,
+ const q31_t * pCoeffs,
+ q31_t * pState,
+ uint32_t blockSize);
+
+ /**
+ * @brief Processing function for the floating-point FIR filter.
+ * @param[in] S points to an instance of the floating-point FIR structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_fir_f32(
+ const arm_fir_instance_f32 * S,
+ const float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Processing function for the floating-point FIR filter.
+ * @param[in] S points to an instance of the floating-point FIR structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_fir_f64(
+ const arm_fir_instance_f64 * S,
+ const float64_t * pSrc,
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Initialization function for the floating-point FIR filter.
+ * @param[in,out] S points to an instance of the floating-point FIR filter structure.
+ * @param[in] numTaps Number of filter coefficients in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] blockSize number of samples that are processed at a time.
+ */
+ void arm_fir_init_f32(
+ arm_fir_instance_f32 * S,
+ uint16_t numTaps,
+ const float32_t * pCoeffs,
+ float32_t * pState,
+ uint32_t blockSize);
+
+ /**
+ * @brief Initialization function for the floating-point FIR filter.
+ * @param[in,out] S points to an instance of the floating-point FIR filter structure.
+ * @param[in] numTaps Number of filter coefficients in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] blockSize number of samples that are processed at a time.
+ */
+ void arm_fir_init_f64(
+ arm_fir_instance_f64 * S,
+ uint16_t numTaps,
+ const float64_t * pCoeffs,
+ float64_t * pState,
+ uint32_t blockSize);
+
+ /**
+ * @brief Instance structure for the Q15 Biquad cascade filter.
+ */
+ typedef struct
+ {
+ int8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
+ q15_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */
+ const q15_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */
+ int8_t postShift; /**< Additional shift, in bits, applied to each output sample. */
+ } arm_biquad_casd_df1_inst_q15;
+
+ /**
+ * @brief Instance structure for the Q31 Biquad cascade filter.
+ */
+ typedef struct
+ {
+ uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
+ q31_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */
+ const q31_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */
+ uint8_t postShift; /**< Additional shift, in bits, applied to each output sample. */
+ } arm_biquad_casd_df1_inst_q31;
+
+ /**
+ * @brief Instance structure for the floating-point Biquad cascade filter.
+ */
+ typedef struct
+ {
+ uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
+ float32_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */
+ const float32_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */
+ } arm_biquad_casd_df1_inst_f32;
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+ /**
+ * @brief Instance structure for the modified Biquad coefs required by vectorized code.
+ */
+ typedef struct
+ {
+ float32_t coeffs[8][4]; /**< Points to the array of modified coefficients. The array is of length 32. There is one per stage */
+ } arm_biquad_mod_coef_f32;
+#endif
+
+ /**
+ * @brief Processing function for the Q15 Biquad cascade filter.
+ * @param[in] S points to an instance of the Q15 Biquad cascade structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cascade_df1_q15(
+ const arm_biquad_casd_df1_inst_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Initialization function for the Q15 Biquad cascade filter.
+ * @param[in,out] S points to an instance of the Q15 Biquad cascade structure.
+ * @param[in] numStages number of 2nd order stages in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format
+ */
+ void arm_biquad_cascade_df1_init_q15(
+ arm_biquad_casd_df1_inst_q15 * S,
+ uint8_t numStages,
+ const q15_t * pCoeffs,
+ q15_t * pState,
+ int8_t postShift);
+
+ /**
+ * @brief Fast but less precise processing function for the Q15 Biquad cascade filter for Cortex-M3 and Cortex-M4.
+ * @param[in] S points to an instance of the Q15 Biquad cascade structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cascade_df1_fast_q15(
+ const arm_biquad_casd_df1_inst_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Processing function for the Q31 Biquad cascade filter
+ * @param[in] S points to an instance of the Q31 Biquad cascade structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cascade_df1_q31(
+ const arm_biquad_casd_df1_inst_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Fast but less precise processing function for the Q31 Biquad cascade filter for Cortex-M3 and Cortex-M4.
+ * @param[in] S points to an instance of the Q31 Biquad cascade structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cascade_df1_fast_q31(
+ const arm_biquad_casd_df1_inst_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Initialization function for the Q31 Biquad cascade filter.
+ * @param[in,out] S points to an instance of the Q31 Biquad cascade structure.
+ * @param[in] numStages number of 2nd order stages in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] postShift Shift to be applied to the output. Varies according to the coefficients format
+ */
+ void arm_biquad_cascade_df1_init_q31(
+ arm_biquad_casd_df1_inst_q31 * S,
+ uint8_t numStages,
+ const q31_t * pCoeffs,
+ q31_t * pState,
+ int8_t postShift);
+
+ /**
+ * @brief Processing function for the floating-point Biquad cascade filter.
+ * @param[in] S points to an instance of the floating-point Biquad cascade structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cascade_df1_f32(
+ const arm_biquad_casd_df1_inst_f32 * S,
+ const float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Initialization function for the floating-point Biquad cascade filter.
+ * @param[in,out] S points to an instance of the floating-point Biquad cascade structure.
+ * @param[in] numStages number of 2nd order stages in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pCoeffsMod points to the modified filter coefficients (only MVE version).
+ * @param[in] pState points to the state buffer.
+ */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+ void arm_biquad_cascade_df1_mve_init_f32(
+ arm_biquad_casd_df1_inst_f32 * S,
+ uint8_t numStages,
+ const float32_t * pCoeffs,
+ arm_biquad_mod_coef_f32 * pCoeffsMod,
+ float32_t * pState);
+#endif
+
+ void arm_biquad_cascade_df1_init_f32(
+ arm_biquad_casd_df1_inst_f32 * S,
+ uint8_t numStages,
+ const float32_t * pCoeffs,
+ float32_t * pState);
+
+
+/**
+ * @brief Convolution of floating-point sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the location where the output result is written. Length srcALen+srcBLen-1.
+ */
+ void arm_conv_f32(
+ const float32_t * pSrcA,
+ uint32_t srcALen,
+ const float32_t * pSrcB,
+ uint32_t srcBLen,
+ float32_t * pDst);
+
+
+ /**
+ * @brief Convolution of Q15 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
+ * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+ * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen).
+ */
+ void arm_conv_opt_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst,
+ q15_t * pScratch1,
+ q15_t * pScratch2);
+
+
+/**
+ * @brief Convolution of Q15 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the location where the output result is written. Length srcALen+srcBLen-1.
+ */
+ void arm_conv_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst);
+
+
+ /**
+ * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
+ */
+ void arm_conv_fast_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst);
+
+
+ /**
+ * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
+ * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+ * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen).
+ */
+ void arm_conv_fast_opt_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst,
+ q15_t * pScratch1,
+ q15_t * pScratch2);
+
+
+ /**
+ * @brief Convolution of Q31 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
+ */
+ void arm_conv_q31(
+ const q31_t * pSrcA,
+ uint32_t srcALen,
+ const q31_t * pSrcB,
+ uint32_t srcBLen,
+ q31_t * pDst);
+
+
+ /**
+ * @brief Convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
+ */
+ void arm_conv_fast_q31(
+ const q31_t * pSrcA,
+ uint32_t srcALen,
+ const q31_t * pSrcB,
+ uint32_t srcBLen,
+ q31_t * pDst);
+
+
+ /**
+ * @brief Convolution of Q7 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
+ * @param[in] pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+ * @param[in] pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).
+ */
+ void arm_conv_opt_q7(
+ const q7_t * pSrcA,
+ uint32_t srcALen,
+ const q7_t * pSrcB,
+ uint32_t srcBLen,
+ q7_t * pDst,
+ q15_t * pScratch1,
+ q15_t * pScratch2);
+
+
+ /**
+ * @brief Convolution of Q7 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length srcALen+srcBLen-1.
+ */
+ void arm_conv_q7(
+ const q7_t * pSrcA,
+ uint32_t srcALen,
+ const q7_t * pSrcB,
+ uint32_t srcBLen,
+ q7_t * pDst);
+
+
+ /**
+ * @brief Partial convolution of floating-point sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data
+ * @param[in] firstIndex is the first output sample to start with.
+ * @param[in] numPoints is the number of output points to be computed.
+ * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+ */
+ arm_status arm_conv_partial_f32(
+ const float32_t * pSrcA,
+ uint32_t srcALen,
+ const float32_t * pSrcB,
+ uint32_t srcBLen,
+ float32_t * pDst,
+ uint32_t firstIndex,
+ uint32_t numPoints);
+
+
+ /**
+ * @brief Partial convolution of Q15 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data
+ * @param[in] firstIndex is the first output sample to start with.
+ * @param[in] numPoints is the number of output points to be computed.
+ * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+ * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen).
+ * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+ */
+ arm_status arm_conv_partial_opt_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst,
+ uint32_t firstIndex,
+ uint32_t numPoints,
+ q15_t * pScratch1,
+ q15_t * pScratch2);
+
+
+ /**
+ * @brief Partial convolution of Q15 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data
+ * @param[in] firstIndex is the first output sample to start with.
+ * @param[in] numPoints is the number of output points to be computed.
+ * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+ */
+ arm_status arm_conv_partial_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst,
+ uint32_t firstIndex,
+ uint32_t numPoints);
+
+
+ /**
+ * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data
+ * @param[in] firstIndex is the first output sample to start with.
+ * @param[in] numPoints is the number of output points to be computed.
+ * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+ */
+ arm_status arm_conv_partial_fast_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst,
+ uint32_t firstIndex,
+ uint32_t numPoints);
+
+
+ /**
+ * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data
+ * @param[in] firstIndex is the first output sample to start with.
+ * @param[in] numPoints is the number of output points to be computed.
+ * @param[in] pScratch1 points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+ * @param[in] pScratch2 points to scratch buffer of size min(srcALen, srcBLen).
+ * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+ */
+ arm_status arm_conv_partial_fast_opt_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst,
+ uint32_t firstIndex,
+ uint32_t numPoints,
+ q15_t * pScratch1,
+ q15_t * pScratch2);
+
+
+ /**
+ * @brief Partial convolution of Q31 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data
+ * @param[in] firstIndex is the first output sample to start with.
+ * @param[in] numPoints is the number of output points to be computed.
+ * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+ */
+ arm_status arm_conv_partial_q31(
+ const q31_t * pSrcA,
+ uint32_t srcALen,
+ const q31_t * pSrcB,
+ uint32_t srcBLen,
+ q31_t * pDst,
+ uint32_t firstIndex,
+ uint32_t numPoints);
+
+
+ /**
+ * @brief Partial convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data
+ * @param[in] firstIndex is the first output sample to start with.
+ * @param[in] numPoints is the number of output points to be computed.
+ * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+ */
+ arm_status arm_conv_partial_fast_q31(
+ const q31_t * pSrcA,
+ uint32_t srcALen,
+ const q31_t * pSrcB,
+ uint32_t srcBLen,
+ q31_t * pDst,
+ uint32_t firstIndex,
+ uint32_t numPoints);
+
+
+ /**
+ * @brief Partial convolution of Q7 sequences
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data
+ * @param[in] firstIndex is the first output sample to start with.
+ * @param[in] numPoints is the number of output points to be computed.
+ * @param[in] pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+ * @param[in] pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).
+ * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+ */
+ arm_status arm_conv_partial_opt_q7(
+ const q7_t * pSrcA,
+ uint32_t srcALen,
+ const q7_t * pSrcB,
+ uint32_t srcBLen,
+ q7_t * pDst,
+ uint32_t firstIndex,
+ uint32_t numPoints,
+ q15_t * pScratch1,
+ q15_t * pScratch2);
+
+
+/**
+ * @brief Partial convolution of Q7 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data
+ * @param[in] firstIndex is the first output sample to start with.
+ * @param[in] numPoints is the number of output points to be computed.
+ * @return Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+ */
+ arm_status arm_conv_partial_q7(
+ const q7_t * pSrcA,
+ uint32_t srcALen,
+ const q7_t * pSrcB,
+ uint32_t srcBLen,
+ q7_t * pDst,
+ uint32_t firstIndex,
+ uint32_t numPoints);
+
+
+ /**
+ * @brief Instance structure for the Q15 FIR decimator.
+ */
+ typedef struct
+ {
+ uint8_t M; /**< decimation factor. */
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ const q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
+ q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ } arm_fir_decimate_instance_q15;
+
+ /**
+ * @brief Instance structure for the Q31 FIR decimator.
+ */
+ typedef struct
+ {
+ uint8_t M; /**< decimation factor. */
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ const q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
+ q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ } arm_fir_decimate_instance_q31;
+
+/**
+ @brief Instance structure for single precision floating-point FIR decimator.
+ */
+typedef struct
+ {
+ uint8_t M; /**< decimation factor. */
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ const float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
+ float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ } arm_fir_decimate_instance_f32;
+
+ /**
+ @brief Instance structure for double precision floating-point FIR decimator.
+ */
+ typedef struct
+ {
+ uint8_t M; /**< decimation factor. */
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ const float64_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
+ float64_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ } arm_fir_decimate_instance_f64;
+
+ /**
+ @brief Processing function for floating-point FIR decimator.
+ @param[in] S points to an instance of the floating-point FIR decimator structure
+ @param[in] pSrc points to the block of input data
+ @param[out] pDst points to the block of output data
+ @param[in] blockSize number of samples to process
+ */
+ void arm_fir_decimate_f64(
+ const arm_fir_decimate_instance_f64 * S,
+ const float64_t * pSrc,
+ float64_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ @brief Initialization function for the floating-point FIR decimator.
+ @param[in,out] S points to an instance of the floating-point FIR decimator structure
+ @param[in] numTaps number of coefficients in the filter
+ @param[in] M decimation factor
+ @param[in] pCoeffs points to the filter coefficients
+ @param[in] pState points to the state buffer
+ @param[in] blockSize number of input samples to process per call
+ @return execution status
+ - \ref ARM_MATH_SUCCESS : Operation successful
+ - \ref ARM_MATH_LENGTH_ERROR : blockSize is not a multiple of M
+ */
+ arm_status arm_fir_decimate_init_f64(
+ arm_fir_decimate_instance_f64 * S,
+ uint16_t numTaps,
+ uint8_t M,
+ const float64_t * pCoeffs,
+ float64_t * pState,
+ uint32_t blockSize);
+
+
+ /**
+ @brief Processing function for floating-point FIR decimator.
+ @param[in] S points to an instance of the floating-point FIR decimator structure
+ @param[in] pSrc points to the block of input data
+ @param[out] pDst points to the block of output data
+ @param[in] blockSize number of samples to process
+ */
+void arm_fir_decimate_f32(
+ const arm_fir_decimate_instance_f32 * S,
+ const float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+/**
+ @brief Initialization function for the floating-point FIR decimator.
+ @param[in,out] S points to an instance of the floating-point FIR decimator structure
+ @param[in] numTaps number of coefficients in the filter
+ @param[in] M decimation factor
+ @param[in] pCoeffs points to the filter coefficients
+ @param[in] pState points to the state buffer
+ @param[in] blockSize number of input samples to process per call
+ @return execution status
+ - \ref ARM_MATH_SUCCESS : Operation successful
+ - \ref ARM_MATH_LENGTH_ERROR : blockSize is not a multiple of M
+ */
+arm_status arm_fir_decimate_init_f32(
+ arm_fir_decimate_instance_f32 * S,
+ uint16_t numTaps,
+ uint8_t M,
+ const float32_t * pCoeffs,
+ float32_t * pState,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the Q15 FIR decimator.
+ * @param[in] S points to an instance of the Q15 FIR decimator structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of input samples to process per call.
+ */
+ void arm_fir_decimate_q15(
+ const arm_fir_decimate_instance_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the Q15 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4.
+ * @param[in] S points to an instance of the Q15 FIR decimator structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of input samples to process per call.
+ */
+ void arm_fir_decimate_fast_q15(
+ const arm_fir_decimate_instance_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the Q15 FIR decimator.
+ * @param[in,out] S points to an instance of the Q15 FIR decimator structure.
+ * @param[in] numTaps number of coefficients in the filter.
+ * @param[in] M decimation factor.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] blockSize number of input samples to process per call.
+ * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
+ * blockSize is not a multiple of M.
+ */
+ arm_status arm_fir_decimate_init_q15(
+ arm_fir_decimate_instance_q15 * S,
+ uint16_t numTaps,
+ uint8_t M,
+ const q15_t * pCoeffs,
+ q15_t * pState,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the Q31 FIR decimator.
+ * @param[in] S points to an instance of the Q31 FIR decimator structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of input samples to process per call.
+ */
+ void arm_fir_decimate_q31(
+ const arm_fir_decimate_instance_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Processing function for the Q31 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4.
+ * @param[in] S points to an instance of the Q31 FIR decimator structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of input samples to process per call.
+ */
+ void arm_fir_decimate_fast_q31(
+ const arm_fir_decimate_instance_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the Q31 FIR decimator.
+ * @param[in,out] S points to an instance of the Q31 FIR decimator structure.
+ * @param[in] numTaps number of coefficients in the filter.
+ * @param[in] M decimation factor.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] blockSize number of input samples to process per call.
+ * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
+ * blockSize is not a multiple of M.
+ */
+ arm_status arm_fir_decimate_init_q31(
+ arm_fir_decimate_instance_q31 * S,
+ uint16_t numTaps,
+ uint8_t M,
+ const q31_t * pCoeffs,
+ q31_t * pState,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Instance structure for the Q15 FIR interpolator.
+ */
+ typedef struct
+ {
+ uint8_t L; /**< upsample factor. */
+ uint16_t phaseLength; /**< length of each polyphase filter component. */
+ const q15_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */
+ q15_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */
+ } arm_fir_interpolate_instance_q15;
+
+ /**
+ * @brief Instance structure for the Q31 FIR interpolator.
+ */
+ typedef struct
+ {
+ uint8_t L; /**< upsample factor. */
+ uint16_t phaseLength; /**< length of each polyphase filter component. */
+ const q31_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */
+ q31_t *pState; /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */
+ } arm_fir_interpolate_instance_q31;
+
+ /**
+ * @brief Instance structure for the floating-point FIR interpolator.
+ */
+ typedef struct
+ {
+ uint8_t L; /**< upsample factor. */
+ uint16_t phaseLength; /**< length of each polyphase filter component. */
+ const float32_t *pCoeffs; /**< points to the coefficient array. The array is of length L*phaseLength. */
+ float32_t *pState; /**< points to the state variable array. The array is of length phaseLength+numTaps-1. */
+ } arm_fir_interpolate_instance_f32;
+
+
+ /**
+ * @brief Processing function for the Q15 FIR interpolator.
+ * @param[in] S points to an instance of the Q15 FIR interpolator structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of input samples to process per call.
+ */
+ void arm_fir_interpolate_q15(
+ const arm_fir_interpolate_instance_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the Q15 FIR interpolator.
+ * @param[in,out] S points to an instance of the Q15 FIR interpolator structure.
+ * @param[in] L upsample factor.
+ * @param[in] numTaps number of filter coefficients in the filter.
+ * @param[in] pCoeffs points to the filter coefficient buffer.
+ * @param[in] pState points to the state buffer.
+ * @param[in] blockSize number of input samples to process per call.
+ * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
+ * the filter length numTaps is not a multiple of the interpolation factor L.
+ */
+ arm_status arm_fir_interpolate_init_q15(
+ arm_fir_interpolate_instance_q15 * S,
+ uint8_t L,
+ uint16_t numTaps,
+ const q15_t * pCoeffs,
+ q15_t * pState,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the Q31 FIR interpolator.
+ * @param[in] S points to an instance of the Q15 FIR interpolator structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of input samples to process per call.
+ */
+ void arm_fir_interpolate_q31(
+ const arm_fir_interpolate_instance_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the Q31 FIR interpolator.
+ * @param[in,out] S points to an instance of the Q31 FIR interpolator structure.
+ * @param[in] L upsample factor.
+ * @param[in] numTaps number of filter coefficients in the filter.
+ * @param[in] pCoeffs points to the filter coefficient buffer.
+ * @param[in] pState points to the state buffer.
+ * @param[in] blockSize number of input samples to process per call.
+ * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
+ * the filter length numTaps is not a multiple of the interpolation factor L.
+ */
+ arm_status arm_fir_interpolate_init_q31(
+ arm_fir_interpolate_instance_q31 * S,
+ uint8_t L,
+ uint16_t numTaps,
+ const q31_t * pCoeffs,
+ q31_t * pState,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the floating-point FIR interpolator.
+ * @param[in] S points to an instance of the floating-point FIR interpolator structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of input samples to process per call.
+ */
+ void arm_fir_interpolate_f32(
+ const arm_fir_interpolate_instance_f32 * S,
+ const float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the floating-point FIR interpolator.
+ * @param[in,out] S points to an instance of the floating-point FIR interpolator structure.
+ * @param[in] L upsample factor.
+ * @param[in] numTaps number of filter coefficients in the filter.
+ * @param[in] pCoeffs points to the filter coefficient buffer.
+ * @param[in] pState points to the state buffer.
+ * @param[in] blockSize number of input samples to process per call.
+ * @return The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
+ * the filter length numTaps is not a multiple of the interpolation factor L.
+ */
+ arm_status arm_fir_interpolate_init_f32(
+ arm_fir_interpolate_instance_f32 * S,
+ uint8_t L,
+ uint16_t numTaps,
+ const float32_t * pCoeffs,
+ float32_t * pState,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Instance structure for the high precision Q31 Biquad cascade filter.
+ */
+ typedef struct
+ {
+ uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
+ q63_t *pState; /**< points to the array of state coefficients. The array is of length 4*numStages. */
+ const q31_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */
+ uint8_t postShift; /**< additional shift, in bits, applied to each output sample. */
+ } arm_biquad_cas_df1_32x64_ins_q31;
+
+
+ /**
+ * @param[in] S points to an instance of the high precision Q31 Biquad cascade filter structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cas_df1_32x64_q31(
+ const arm_biquad_cas_df1_32x64_ins_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @param[in,out] S points to an instance of the high precision Q31 Biquad cascade filter structure.
+ * @param[in] numStages number of 2nd order stages in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] postShift shift to be applied to the output. Varies according to the coefficients format
+ */
+ void arm_biquad_cas_df1_32x64_init_q31(
+ arm_biquad_cas_df1_32x64_ins_q31 * S,
+ uint8_t numStages,
+ const q31_t * pCoeffs,
+ q63_t * pState,
+ uint8_t postShift);
+
+
+ /**
+ * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.
+ */
+ typedef struct
+ {
+ uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
+ float32_t *pState; /**< points to the array of state coefficients. The array is of length 2*numStages. */
+ const float32_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */
+ } arm_biquad_cascade_df2T_instance_f32;
+
+ /**
+ * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.
+ */
+ typedef struct
+ {
+ uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
+ float32_t *pState; /**< points to the array of state coefficients. The array is of length 4*numStages. */
+ const float32_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */
+ } arm_biquad_cascade_stereo_df2T_instance_f32;
+
+ /**
+ * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.
+ */
+ typedef struct
+ {
+ uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
+ float64_t *pState; /**< points to the array of state coefficients. The array is of length 2*numStages. */
+ const float64_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */
+ } arm_biquad_cascade_df2T_instance_f64;
+
+
+ /**
+ * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter.
+ * @param[in] S points to an instance of the filter data structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cascade_df2T_f32(
+ const arm_biquad_cascade_df2T_instance_f32 * S,
+ const float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. 2 channels
+ * @param[in] S points to an instance of the filter data structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cascade_stereo_df2T_f32(
+ const arm_biquad_cascade_stereo_df2T_instance_f32 * S,
+ const float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter.
+ * @param[in] S points to an instance of the filter data structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cascade_df2T_f64(
+ const arm_biquad_cascade_df2T_instance_f64 * S,
+ const float64_t * pSrc,
+ float64_t * pDst,
+ uint32_t blockSize);
+
+
+#if (defined(ARM_MATH_NEON) || defined(DOXYGEN))
+/**
+ @brief Compute new coefficient arrays for use in vectorized filter (Neon only).
+ @param[in] numStages number of 2nd order stages in the filter.
+ @param[in] pCoeffs points to the original filter coefficients.
+ @param[in] pComputedCoeffs points to the new computed coefficients for the vectorized version.
+*/
+void arm_biquad_cascade_df2T_compute_coefs_f32(
+ uint8_t numStages,
+ const float32_t * pCoeffs,
+ float32_t * pComputedCoeffs);
+#endif
+ /**
+ * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter.
+ * @param[in,out] S points to an instance of the filter data structure.
+ * @param[in] numStages number of 2nd order stages in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ */
+ void arm_biquad_cascade_df2T_init_f32(
+ arm_biquad_cascade_df2T_instance_f32 * S,
+ uint8_t numStages,
+ const float32_t * pCoeffs,
+ float32_t * pState);
+
+
+ /**
+ * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter.
+ * @param[in,out] S points to an instance of the filter data structure.
+ * @param[in] numStages number of 2nd order stages in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ */
+ void arm_biquad_cascade_stereo_df2T_init_f32(
+ arm_biquad_cascade_stereo_df2T_instance_f32 * S,
+ uint8_t numStages,
+ const float32_t * pCoeffs,
+ float32_t * pState);
+
+
+ /**
+ * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter.
+ * @param[in,out] S points to an instance of the filter data structure.
+ * @param[in] numStages number of 2nd order stages in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ */
+ void arm_biquad_cascade_df2T_init_f64(
+ arm_biquad_cascade_df2T_instance_f64 * S,
+ uint8_t numStages,
+ const float64_t * pCoeffs,
+ float64_t * pState);
+
+
+ /**
+ * @brief Instance structure for the Q15 FIR lattice filter.
+ */
+ typedef struct
+ {
+ uint16_t numStages; /**< number of filter stages. */
+ q15_t *pState; /**< points to the state variable array. The array is of length numStages. */
+ const q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */
+ } arm_fir_lattice_instance_q15;
+
+ /**
+ * @brief Instance structure for the Q31 FIR lattice filter.
+ */
+ typedef struct
+ {
+ uint16_t numStages; /**< number of filter stages. */
+ q31_t *pState; /**< points to the state variable array. The array is of length numStages. */
+ const q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */
+ } arm_fir_lattice_instance_q31;
+
+ /**
+ * @brief Instance structure for the floating-point FIR lattice filter.
+ */
+ typedef struct
+ {
+ uint16_t numStages; /**< number of filter stages. */
+ float32_t *pState; /**< points to the state variable array. The array is of length numStages. */
+ const float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numStages. */
+ } arm_fir_lattice_instance_f32;
+
+
+ /**
+ * @brief Initialization function for the Q15 FIR lattice filter.
+ * @param[in] S points to an instance of the Q15 FIR lattice structure.
+ * @param[in] numStages number of filter stages.
+ * @param[in] pCoeffs points to the coefficient buffer. The array is of length numStages.
+ * @param[in] pState points to the state buffer. The array is of length numStages.
+ */
+ void arm_fir_lattice_init_q15(
+ arm_fir_lattice_instance_q15 * S,
+ uint16_t numStages,
+ const q15_t * pCoeffs,
+ q15_t * pState);
+
+
+ /**
+ * @brief Processing function for the Q15 FIR lattice filter.
+ * @param[in] S points to an instance of the Q15 FIR lattice structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_fir_lattice_q15(
+ const arm_fir_lattice_instance_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the Q31 FIR lattice filter.
+ * @param[in] S points to an instance of the Q31 FIR lattice structure.
+ * @param[in] numStages number of filter stages.
+ * @param[in] pCoeffs points to the coefficient buffer. The array is of length numStages.
+ * @param[in] pState points to the state buffer. The array is of length numStages.
+ */
+ void arm_fir_lattice_init_q31(
+ arm_fir_lattice_instance_q31 * S,
+ uint16_t numStages,
+ const q31_t * pCoeffs,
+ q31_t * pState);
+
+
+ /**
+ * @brief Processing function for the Q31 FIR lattice filter.
+ * @param[in] S points to an instance of the Q31 FIR lattice structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_fir_lattice_q31(
+ const arm_fir_lattice_instance_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+
+/**
+ * @brief Initialization function for the floating-point FIR lattice filter.
+ * @param[in] S points to an instance of the floating-point FIR lattice structure.
+ * @param[in] numStages number of filter stages.
+ * @param[in] pCoeffs points to the coefficient buffer. The array is of length numStages.
+ * @param[in] pState points to the state buffer. The array is of length numStages.
+ */
+ void arm_fir_lattice_init_f32(
+ arm_fir_lattice_instance_f32 * S,
+ uint16_t numStages,
+ const float32_t * pCoeffs,
+ float32_t * pState);
+
+
+ /**
+ * @brief Processing function for the floating-point FIR lattice filter.
+ * @param[in] S points to an instance of the floating-point FIR lattice structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_fir_lattice_f32(
+ const arm_fir_lattice_instance_f32 * S,
+ const float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Instance structure for the Q15 IIR lattice filter.
+ */
+ typedef struct
+ {
+ uint16_t numStages; /**< number of stages in the filter. */
+ q15_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */
+ q15_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */
+ q15_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */
+ } arm_iir_lattice_instance_q15;
+
+ /**
+ * @brief Instance structure for the Q31 IIR lattice filter.
+ */
+ typedef struct
+ {
+ uint16_t numStages; /**< number of stages in the filter. */
+ q31_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */
+ q31_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */
+ q31_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */
+ } arm_iir_lattice_instance_q31;
+
+ /**
+ * @brief Instance structure for the floating-point IIR lattice filter.
+ */
+ typedef struct
+ {
+ uint16_t numStages; /**< number of stages in the filter. */
+ float32_t *pState; /**< points to the state variable array. The array is of length numStages+blockSize. */
+ float32_t *pkCoeffs; /**< points to the reflection coefficient array. The array is of length numStages. */
+ float32_t *pvCoeffs; /**< points to the ladder coefficient array. The array is of length numStages+1. */
+ } arm_iir_lattice_instance_f32;
+
+
+ /**
+ * @brief Processing function for the floating-point IIR lattice filter.
+ * @param[in] S points to an instance of the floating-point IIR lattice structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_iir_lattice_f32(
+ const arm_iir_lattice_instance_f32 * S,
+ const float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the floating-point IIR lattice filter.
+ * @param[in] S points to an instance of the floating-point IIR lattice structure.
+ * @param[in] numStages number of stages in the filter.
+ * @param[in] pkCoeffs points to the reflection coefficient buffer. The array is of length numStages.
+ * @param[in] pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1.
+ * @param[in] pState points to the state buffer. The array is of length numStages+blockSize-1.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_iir_lattice_init_f32(
+ arm_iir_lattice_instance_f32 * S,
+ uint16_t numStages,
+ float32_t * pkCoeffs,
+ float32_t * pvCoeffs,
+ float32_t * pState,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the Q31 IIR lattice filter.
+ * @param[in] S points to an instance of the Q31 IIR lattice structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_iir_lattice_q31(
+ const arm_iir_lattice_instance_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the Q31 IIR lattice filter.
+ * @param[in] S points to an instance of the Q31 IIR lattice structure.
+ * @param[in] numStages number of stages in the filter.
+ * @param[in] pkCoeffs points to the reflection coefficient buffer. The array is of length numStages.
+ * @param[in] pvCoeffs points to the ladder coefficient buffer. The array is of length numStages+1.
+ * @param[in] pState points to the state buffer. The array is of length numStages+blockSize.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_iir_lattice_init_q31(
+ arm_iir_lattice_instance_q31 * S,
+ uint16_t numStages,
+ q31_t * pkCoeffs,
+ q31_t * pvCoeffs,
+ q31_t * pState,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the Q15 IIR lattice filter.
+ * @param[in] S points to an instance of the Q15 IIR lattice structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_iir_lattice_q15(
+ const arm_iir_lattice_instance_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+
+/**
+ * @brief Initialization function for the Q15 IIR lattice filter.
+ * @param[in] S points to an instance of the fixed-point Q15 IIR lattice structure.
+ * @param[in] numStages number of stages in the filter.
+ * @param[in] pkCoeffs points to reflection coefficient buffer. The array is of length numStages.
+ * @param[in] pvCoeffs points to ladder coefficient buffer. The array is of length numStages+1.
+ * @param[in] pState points to state buffer. The array is of length numStages+blockSize.
+ * @param[in] blockSize number of samples to process per call.
+ */
+ void arm_iir_lattice_init_q15(
+ arm_iir_lattice_instance_q15 * S,
+ uint16_t numStages,
+ q15_t * pkCoeffs,
+ q15_t * pvCoeffs,
+ q15_t * pState,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Instance structure for the floating-point LMS filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
+ float32_t mu; /**< step size that controls filter coefficient updates. */
+ } arm_lms_instance_f32;
+
+
+ /**
+ * @brief Processing function for floating-point LMS filter.
+ * @param[in] S points to an instance of the floating-point LMS filter structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[in] pRef points to the block of reference data.
+ * @param[out] pOut points to the block of output data.
+ * @param[out] pErr points to the block of error data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_lms_f32(
+ const arm_lms_instance_f32 * S,
+ const float32_t * pSrc,
+ float32_t * pRef,
+ float32_t * pOut,
+ float32_t * pErr,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for floating-point LMS filter.
+ * @param[in] S points to an instance of the floating-point LMS filter structure.
+ * @param[in] numTaps number of filter coefficients.
+ * @param[in] pCoeffs points to the coefficient buffer.
+ * @param[in] pState points to state buffer.
+ * @param[in] mu step size that controls filter coefficient updates.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_lms_init_f32(
+ arm_lms_instance_f32 * S,
+ uint16_t numTaps,
+ float32_t * pCoeffs,
+ float32_t * pState,
+ float32_t mu,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Instance structure for the Q15 LMS filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
+ q15_t mu; /**< step size that controls filter coefficient updates. */
+ uint32_t postShift; /**< bit shift applied to coefficients. */
+ } arm_lms_instance_q15;
+
+
+ /**
+ * @brief Initialization function for the Q15 LMS filter.
+ * @param[in] S points to an instance of the Q15 LMS filter structure.
+ * @param[in] numTaps number of filter coefficients.
+ * @param[in] pCoeffs points to the coefficient buffer.
+ * @param[in] pState points to the state buffer.
+ * @param[in] mu step size that controls filter coefficient updates.
+ * @param[in] blockSize number of samples to process.
+ * @param[in] postShift bit shift applied to coefficients.
+ */
+ void arm_lms_init_q15(
+ arm_lms_instance_q15 * S,
+ uint16_t numTaps,
+ q15_t * pCoeffs,
+ q15_t * pState,
+ q15_t mu,
+ uint32_t blockSize,
+ uint32_t postShift);
+
+
+ /**
+ * @brief Processing function for Q15 LMS filter.
+ * @param[in] S points to an instance of the Q15 LMS filter structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[in] pRef points to the block of reference data.
+ * @param[out] pOut points to the block of output data.
+ * @param[out] pErr points to the block of error data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_lms_q15(
+ const arm_lms_instance_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pRef,
+ q15_t * pOut,
+ q15_t * pErr,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Instance structure for the Q31 LMS filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
+ q31_t mu; /**< step size that controls filter coefficient updates. */
+ uint32_t postShift; /**< bit shift applied to coefficients. */
+ } arm_lms_instance_q31;
+
+
+ /**
+ * @brief Processing function for Q31 LMS filter.
+ * @param[in] S points to an instance of the Q15 LMS filter structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[in] pRef points to the block of reference data.
+ * @param[out] pOut points to the block of output data.
+ * @param[out] pErr points to the block of error data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_lms_q31(
+ const arm_lms_instance_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pRef,
+ q31_t * pOut,
+ q31_t * pErr,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for Q31 LMS filter.
+ * @param[in] S points to an instance of the Q31 LMS filter structure.
+ * @param[in] numTaps number of filter coefficients.
+ * @param[in] pCoeffs points to coefficient buffer.
+ * @param[in] pState points to state buffer.
+ * @param[in] mu step size that controls filter coefficient updates.
+ * @param[in] blockSize number of samples to process.
+ * @param[in] postShift bit shift applied to coefficients.
+ */
+ void arm_lms_init_q31(
+ arm_lms_instance_q31 * S,
+ uint16_t numTaps,
+ q31_t * pCoeffs,
+ q31_t * pState,
+ q31_t mu,
+ uint32_t blockSize,
+ uint32_t postShift);
+
+
+ /**
+ * @brief Instance structure for the floating-point normalized LMS filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ float32_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
+ float32_t mu; /**< step size that control filter coefficient updates. */
+ float32_t energy; /**< saves previous frame energy. */
+ float32_t x0; /**< saves previous input sample. */
+ } arm_lms_norm_instance_f32;
+
+
+ /**
+ * @brief Processing function for floating-point normalized LMS filter.
+ * @param[in] S points to an instance of the floating-point normalized LMS filter structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[in] pRef points to the block of reference data.
+ * @param[out] pOut points to the block of output data.
+ * @param[out] pErr points to the block of error data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_lms_norm_f32(
+ arm_lms_norm_instance_f32 * S,
+ const float32_t * pSrc,
+ float32_t * pRef,
+ float32_t * pOut,
+ float32_t * pErr,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for floating-point normalized LMS filter.
+ * @param[in] S points to an instance of the floating-point LMS filter structure.
+ * @param[in] numTaps number of filter coefficients.
+ * @param[in] pCoeffs points to coefficient buffer.
+ * @param[in] pState points to state buffer.
+ * @param[in] mu step size that controls filter coefficient updates.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_lms_norm_init_f32(
+ arm_lms_norm_instance_f32 * S,
+ uint16_t numTaps,
+ float32_t * pCoeffs,
+ float32_t * pState,
+ float32_t mu,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Instance structure for the Q31 normalized LMS filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ q31_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
+ q31_t mu; /**< step size that controls filter coefficient updates. */
+ uint8_t postShift; /**< bit shift applied to coefficients. */
+ const q31_t *recipTable; /**< points to the reciprocal initial value table. */
+ q31_t energy; /**< saves previous frame energy. */
+ q31_t x0; /**< saves previous input sample. */
+ } arm_lms_norm_instance_q31;
+
+
+ /**
+ * @brief Processing function for Q31 normalized LMS filter.
+ * @param[in] S points to an instance of the Q31 normalized LMS filter structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[in] pRef points to the block of reference data.
+ * @param[out] pOut points to the block of output data.
+ * @param[out] pErr points to the block of error data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_lms_norm_q31(
+ arm_lms_norm_instance_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pRef,
+ q31_t * pOut,
+ q31_t * pErr,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for Q31 normalized LMS filter.
+ * @param[in] S points to an instance of the Q31 normalized LMS filter structure.
+ * @param[in] numTaps number of filter coefficients.
+ * @param[in] pCoeffs points to coefficient buffer.
+ * @param[in] pState points to state buffer.
+ * @param[in] mu step size that controls filter coefficient updates.
+ * @param[in] blockSize number of samples to process.
+ * @param[in] postShift bit shift applied to coefficients.
+ */
+ void arm_lms_norm_init_q31(
+ arm_lms_norm_instance_q31 * S,
+ uint16_t numTaps,
+ q31_t * pCoeffs,
+ q31_t * pState,
+ q31_t mu,
+ uint32_t blockSize,
+ uint8_t postShift);
+
+
+ /**
+ * @brief Instance structure for the Q15 normalized LMS filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< Number of coefficients in the filter. */
+ q15_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
+ q15_t mu; /**< step size that controls filter coefficient updates. */
+ uint8_t postShift; /**< bit shift applied to coefficients. */
+ const q15_t *recipTable; /**< Points to the reciprocal initial value table. */
+ q15_t energy; /**< saves previous frame energy. */
+ q15_t x0; /**< saves previous input sample. */
+ } arm_lms_norm_instance_q15;
+
+
+ /**
+ * @brief Processing function for Q15 normalized LMS filter.
+ * @param[in] S points to an instance of the Q15 normalized LMS filter structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[in] pRef points to the block of reference data.
+ * @param[out] pOut points to the block of output data.
+ * @param[out] pErr points to the block of error data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_lms_norm_q15(
+ arm_lms_norm_instance_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pRef,
+ q15_t * pOut,
+ q15_t * pErr,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for Q15 normalized LMS filter.
+ * @param[in] S points to an instance of the Q15 normalized LMS filter structure.
+ * @param[in] numTaps number of filter coefficients.
+ * @param[in] pCoeffs points to coefficient buffer.
+ * @param[in] pState points to state buffer.
+ * @param[in] mu step size that controls filter coefficient updates.
+ * @param[in] blockSize number of samples to process.
+ * @param[in] postShift bit shift applied to coefficients.
+ */
+ void arm_lms_norm_init_q15(
+ arm_lms_norm_instance_q15 * S,
+ uint16_t numTaps,
+ q15_t * pCoeffs,
+ q15_t * pState,
+ q15_t mu,
+ uint32_t blockSize,
+ uint8_t postShift);
+
+
+ /**
+ * @brief Correlation of floating-point sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
+ */
+ void arm_correlate_f32(
+ const float32_t * pSrcA,
+ uint32_t srcALen,
+ const float32_t * pSrcB,
+ uint32_t srcBLen,
+ float32_t * pDst);
+
+
+ /**
+ * @brief Correlation of floating-point sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
+ */
+ void arm_correlate_f64(
+ const float64_t * pSrcA,
+ uint32_t srcALen,
+ const float64_t * pSrcB,
+ uint32_t srcBLen,
+ float64_t * pDst);
+
+
+/**
+ @brief Correlation of Q15 sequences
+ @param[in] pSrcA points to the first input sequence
+ @param[in] srcALen length of the first input sequence
+ @param[in] pSrcB points to the second input sequence
+ @param[in] srcBLen length of the second input sequence
+ @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
+ @param[in] pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+*/
+void arm_correlate_opt_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst,
+ q15_t * pScratch);
+
+
+/**
+ @brief Correlation of Q15 sequences.
+ @param[in] pSrcA points to the first input sequence
+ @param[in] srcALen length of the first input sequence
+ @param[in] pSrcB points to the second input sequence
+ @param[in] srcBLen length of the second input sequence
+ @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
+ */
+ void arm_correlate_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst);
+
+
+/**
+ @brief Correlation of Q15 sequences (fast version).
+ @param[in] pSrcA points to the first input sequence
+ @param[in] srcALen length of the first input sequence
+ @param[in] pSrcB points to the second input sequence
+ @param[in] srcBLen length of the second input sequence
+ @param[out] pDst points to the location where the output result is written. Length 2 * max(srcALen, srcBLen) - 1.
+ */
+void arm_correlate_fast_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst);
+
+
+/**
+ @brief Correlation of Q15 sequences (fast version).
+ @param[in] pSrcA points to the first input sequence.
+ @param[in] srcALen length of the first input sequence.
+ @param[in] pSrcB points to the second input sequence.
+ @param[in] srcBLen length of the second input sequence.
+ @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
+ @param[in] pScratch points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+ */
+void arm_correlate_fast_opt_q15(
+ const q15_t * pSrcA,
+ uint32_t srcALen,
+ const q15_t * pSrcB,
+ uint32_t srcBLen,
+ q15_t * pDst,
+ q15_t * pScratch);
+
+
+ /**
+ * @brief Correlation of Q31 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
+ */
+ void arm_correlate_q31(
+ const q31_t * pSrcA,
+ uint32_t srcALen,
+ const q31_t * pSrcB,
+ uint32_t srcBLen,
+ q31_t * pDst);
+
+
+/**
+ @brief Correlation of Q31 sequences (fast version).
+ @param[in] pSrcA points to the first input sequence
+ @param[in] srcALen length of the first input sequence
+ @param[in] pSrcB points to the second input sequence
+ @param[in] srcBLen length of the second input sequence
+ @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
+ */
+void arm_correlate_fast_q31(
+ const q31_t * pSrcA,
+ uint32_t srcALen,
+ const q31_t * pSrcB,
+ uint32_t srcBLen,
+ q31_t * pDst);
+
+
+ /**
+ * @brief Correlation of Q7 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
+ * @param[in] pScratch1 points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+ * @param[in] pScratch2 points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).
+ */
+ void arm_correlate_opt_q7(
+ const q7_t * pSrcA,
+ uint32_t srcALen,
+ const q7_t * pSrcB,
+ uint32_t srcBLen,
+ q7_t * pDst,
+ q15_t * pScratch1,
+ q15_t * pScratch2);
+
+
+ /**
+ * @brief Correlation of Q7 sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
+ */
+ void arm_correlate_q7(
+ const q7_t * pSrcA,
+ uint32_t srcALen,
+ const q7_t * pSrcB,
+ uint32_t srcBLen,
+ q7_t * pDst);
+
+
+ /**
+ * @brief Instance structure for the floating-point sparse FIR filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */
+ float32_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
+ const float32_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
+ uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */
+ int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */
+ } arm_fir_sparse_instance_f32;
+
+ /**
+ * @brief Instance structure for the Q31 sparse FIR filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */
+ q31_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
+ const q31_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
+ uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */
+ int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */
+ } arm_fir_sparse_instance_q31;
+
+ /**
+ * @brief Instance structure for the Q15 sparse FIR filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */
+ q15_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
+ const q15_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
+ uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */
+ int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */
+ } arm_fir_sparse_instance_q15;
+
+ /**
+ * @brief Instance structure for the Q7 sparse FIR filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of coefficients in the filter. */
+ uint16_t stateIndex; /**< state buffer index. Points to the oldest sample in the state buffer. */
+ q7_t *pState; /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
+ const q7_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps.*/
+ uint16_t maxDelay; /**< maximum offset specified by the pTapDelay array. */
+ int32_t *pTapDelay; /**< points to the array of delay values. The array is of length numTaps. */
+ } arm_fir_sparse_instance_q7;
+
+
+ /**
+ * @brief Processing function for the floating-point sparse FIR filter.
+ * @param[in] S points to an instance of the floating-point sparse FIR structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] pScratchIn points to a temporary buffer of size blockSize.
+ * @param[in] blockSize number of input samples to process per call.
+ */
+ void arm_fir_sparse_f32(
+ arm_fir_sparse_instance_f32 * S,
+ const float32_t * pSrc,
+ float32_t * pDst,
+ float32_t * pScratchIn,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the floating-point sparse FIR filter.
+ * @param[in,out] S points to an instance of the floating-point sparse FIR structure.
+ * @param[in] numTaps number of nonzero coefficients in the filter.
+ * @param[in] pCoeffs points to the array of filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] pTapDelay points to the array of offset times.
+ * @param[in] maxDelay maximum offset time supported.
+ * @param[in] blockSize number of samples that will be processed per block.
+ */
+ void arm_fir_sparse_init_f32(
+ arm_fir_sparse_instance_f32 * S,
+ uint16_t numTaps,
+ const float32_t * pCoeffs,
+ float32_t * pState,
+ int32_t * pTapDelay,
+ uint16_t maxDelay,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the Q31 sparse FIR filter.
+ * @param[in] S points to an instance of the Q31 sparse FIR structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] pScratchIn points to a temporary buffer of size blockSize.
+ * @param[in] blockSize number of input samples to process per call.
+ */
+ void arm_fir_sparse_q31(
+ arm_fir_sparse_instance_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ q31_t * pScratchIn,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the Q31 sparse FIR filter.
+ * @param[in,out] S points to an instance of the Q31 sparse FIR structure.
+ * @param[in] numTaps number of nonzero coefficients in the filter.
+ * @param[in] pCoeffs points to the array of filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] pTapDelay points to the array of offset times.
+ * @param[in] maxDelay maximum offset time supported.
+ * @param[in] blockSize number of samples that will be processed per block.
+ */
+ void arm_fir_sparse_init_q31(
+ arm_fir_sparse_instance_q31 * S,
+ uint16_t numTaps,
+ const q31_t * pCoeffs,
+ q31_t * pState,
+ int32_t * pTapDelay,
+ uint16_t maxDelay,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the Q15 sparse FIR filter.
+ * @param[in] S points to an instance of the Q15 sparse FIR structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] pScratchIn points to a temporary buffer of size blockSize.
+ * @param[in] pScratchOut points to a temporary buffer of size blockSize.
+ * @param[in] blockSize number of input samples to process per call.
+ */
+ void arm_fir_sparse_q15(
+ arm_fir_sparse_instance_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pDst,
+ q15_t * pScratchIn,
+ q31_t * pScratchOut,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the Q15 sparse FIR filter.
+ * @param[in,out] S points to an instance of the Q15 sparse FIR structure.
+ * @param[in] numTaps number of nonzero coefficients in the filter.
+ * @param[in] pCoeffs points to the array of filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] pTapDelay points to the array of offset times.
+ * @param[in] maxDelay maximum offset time supported.
+ * @param[in] blockSize number of samples that will be processed per block.
+ */
+ void arm_fir_sparse_init_q15(
+ arm_fir_sparse_instance_q15 * S,
+ uint16_t numTaps,
+ const q15_t * pCoeffs,
+ q15_t * pState,
+ int32_t * pTapDelay,
+ uint16_t maxDelay,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Processing function for the Q7 sparse FIR filter.
+ * @param[in] S points to an instance of the Q7 sparse FIR structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] pScratchIn points to a temporary buffer of size blockSize.
+ * @param[in] pScratchOut points to a temporary buffer of size blockSize.
+ * @param[in] blockSize number of input samples to process per call.
+ */
+ void arm_fir_sparse_q7(
+ arm_fir_sparse_instance_q7 * S,
+ const q7_t * pSrc,
+ q7_t * pDst,
+ q7_t * pScratchIn,
+ q31_t * pScratchOut,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Initialization function for the Q7 sparse FIR filter.
+ * @param[in,out] S points to an instance of the Q7 sparse FIR structure.
+ * @param[in] numTaps number of nonzero coefficients in the filter.
+ * @param[in] pCoeffs points to the array of filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] pTapDelay points to the array of offset times.
+ * @param[in] maxDelay maximum offset time supported.
+ * @param[in] blockSize number of samples that will be processed per block.
+ */
+ void arm_fir_sparse_init_q7(
+ arm_fir_sparse_instance_q7 * S,
+ uint16_t numTaps,
+ const q7_t * pCoeffs,
+ q7_t * pState,
+ int32_t * pTapDelay,
+ uint16_t maxDelay,
+ uint32_t blockSize);
+
+
+
+
+
+
+ /**
+ * @brief floating-point Circular write function.
+ */
+ __STATIC_FORCEINLINE void arm_circularWrite_f32(
+ int32_t * circBuffer,
+ int32_t L,
+ uint16_t * writeOffset,
+ int32_t bufferInc,
+ const int32_t * src,
+ int32_t srcInc,
+ uint32_t blockSize)
+ {
+ uint32_t i = 0U;
+ int32_t wOffset;
+
+ /* Copy the value of Index pointer that points
+ * to the current location where the input samples to be copied */
+ wOffset = *writeOffset;
+
+ /* Loop over the blockSize */
+ i = blockSize;
+
+ while (i > 0U)
+ {
+ /* copy the input sample to the circular buffer */
+ circBuffer[wOffset] = *src;
+
+ /* Update the input pointer */
+ src += srcInc;
+
+ /* Circularly update wOffset. Watch out for positive and negative value */
+ wOffset += bufferInc;
+ if (wOffset >= L)
+ wOffset -= L;
+
+ /* Decrement the loop counter */
+ i--;
+ }
+
+ /* Update the index pointer */
+ *writeOffset = (uint16_t)wOffset;
+ }
+
+
+
+ /**
+ * @brief floating-point Circular Read function.
+ */
+ __STATIC_FORCEINLINE void arm_circularRead_f32(
+ int32_t * circBuffer,
+ int32_t L,
+ int32_t * readOffset,
+ int32_t bufferInc,
+ int32_t * dst,
+ int32_t * dst_base,
+ int32_t dst_length,
+ int32_t dstInc,
+ uint32_t blockSize)
+ {
+ uint32_t i = 0U;
+ int32_t rOffset;
+ int32_t* dst_end;
+
+ /* Copy the value of Index pointer that points
+ * to the current location from where the input samples to be read */
+ rOffset = *readOffset;
+ dst_end = dst_base + dst_length;
+
+ /* Loop over the blockSize */
+ i = blockSize;
+
+ while (i > 0U)
+ {
+ /* copy the sample from the circular buffer to the destination buffer */
+ *dst = circBuffer[rOffset];
+
+ /* Update the input pointer */
+ dst += dstInc;
+
+ if (dst == dst_end)
+ {
+ dst = dst_base;
+ }
+
+ /* Circularly update rOffset. Watch out for positive and negative value */
+ rOffset += bufferInc;
+
+ if (rOffset >= L)
+ {
+ rOffset -= L;
+ }
+
+ /* Decrement the loop counter */
+ i--;
+ }
+
+ /* Update the index pointer */
+ *readOffset = rOffset;
+ }
+
+
+ /**
+ * @brief Q15 Circular write function.
+ */
+ __STATIC_FORCEINLINE void arm_circularWrite_q15(
+ q15_t * circBuffer,
+ int32_t L,
+ uint16_t * writeOffset,
+ int32_t bufferInc,
+ const q15_t * src,
+ int32_t srcInc,
+ uint32_t blockSize)
+ {
+ uint32_t i = 0U;
+ int32_t wOffset;
+
+ /* Copy the value of Index pointer that points
+ * to the current location where the input samples to be copied */
+ wOffset = *writeOffset;
+
+ /* Loop over the blockSize */
+ i = blockSize;
+
+ while (i > 0U)
+ {
+ /* copy the input sample to the circular buffer */
+ circBuffer[wOffset] = *src;
+
+ /* Update the input pointer */
+ src += srcInc;
+
+ /* Circularly update wOffset. Watch out for positive and negative value */
+ wOffset += bufferInc;
+ if (wOffset >= L)
+ wOffset -= L;
+
+ /* Decrement the loop counter */
+ i--;
+ }
+
+ /* Update the index pointer */
+ *writeOffset = (uint16_t)wOffset;
+ }
+
+
+ /**
+ * @brief Q15 Circular Read function.
+ */
+ __STATIC_FORCEINLINE void arm_circularRead_q15(
+ q15_t * circBuffer,
+ int32_t L,
+ int32_t * readOffset,
+ int32_t bufferInc,
+ q15_t * dst,
+ q15_t * dst_base,
+ int32_t dst_length,
+ int32_t dstInc,
+ uint32_t blockSize)
+ {
+ uint32_t i = 0;
+ int32_t rOffset;
+ q15_t* dst_end;
+
+ /* Copy the value of Index pointer that points
+ * to the current location from where the input samples to be read */
+ rOffset = *readOffset;
+
+ dst_end = dst_base + dst_length;
+
+ /* Loop over the blockSize */
+ i = blockSize;
+
+ while (i > 0U)
+ {
+ /* copy the sample from the circular buffer to the destination buffer */
+ *dst = circBuffer[rOffset];
+
+ /* Update the input pointer */
+ dst += dstInc;
+
+ if (dst == dst_end)
+ {
+ dst = dst_base;
+ }
+
+ /* Circularly update wOffset. Watch out for positive and negative value */
+ rOffset += bufferInc;
+
+ if (rOffset >= L)
+ {
+ rOffset -= L;
+ }
+
+ /* Decrement the loop counter */
+ i--;
+ }
+
+ /* Update the index pointer */
+ *readOffset = rOffset;
+ }
+
+
+ /**
+ * @brief Q7 Circular write function.
+ */
+ __STATIC_FORCEINLINE void arm_circularWrite_q7(
+ q7_t * circBuffer,
+ int32_t L,
+ uint16_t * writeOffset,
+ int32_t bufferInc,
+ const q7_t * src,
+ int32_t srcInc,
+ uint32_t blockSize)
+ {
+ uint32_t i = 0U;
+ int32_t wOffset;
+
+ /* Copy the value of Index pointer that points
+ * to the current location where the input samples to be copied */
+ wOffset = *writeOffset;
+
+ /* Loop over the blockSize */
+ i = blockSize;
+
+ while (i > 0U)
+ {
+ /* copy the input sample to the circular buffer */
+ circBuffer[wOffset] = *src;
+
+ /* Update the input pointer */
+ src += srcInc;
+
+ /* Circularly update wOffset. Watch out for positive and negative value */
+ wOffset += bufferInc;
+ if (wOffset >= L)
+ wOffset -= L;
+
+ /* Decrement the loop counter */
+ i--;
+ }
+
+ /* Update the index pointer */
+ *writeOffset = (uint16_t)wOffset;
+ }
+
+
+ /**
+ * @brief Q7 Circular Read function.
+ */
+ __STATIC_FORCEINLINE void arm_circularRead_q7(
+ q7_t * circBuffer,
+ int32_t L,
+ int32_t * readOffset,
+ int32_t bufferInc,
+ q7_t * dst,
+ q7_t * dst_base,
+ int32_t dst_length,
+ int32_t dstInc,
+ uint32_t blockSize)
+ {
+ uint32_t i = 0;
+ int32_t rOffset;
+ q7_t* dst_end;
+
+ /* Copy the value of Index pointer that points
+ * to the current location from where the input samples to be read */
+ rOffset = *readOffset;
+
+ dst_end = dst_base + dst_length;
+
+ /* Loop over the blockSize */
+ i = blockSize;
+
+ while (i > 0U)
+ {
+ /* copy the sample from the circular buffer to the destination buffer */
+ *dst = circBuffer[rOffset];
+
+ /* Update the input pointer */
+ dst += dstInc;
+
+ if (dst == dst_end)
+ {
+ dst = dst_base;
+ }
+
+ /* Circularly update rOffset. Watch out for positive and negative value */
+ rOffset += bufferInc;
+
+ if (rOffset >= L)
+ {
+ rOffset -= L;
+ }
+
+ /* Decrement the loop counter */
+ i--;
+ }
+
+ /* Update the index pointer */
+ *readOffset = rOffset;
+ }
+
+
+/**
+ @brief Levinson Durbin
+ @param[in] phi autocovariance vector starting with lag 0 (length is nbCoefs + 1)
+ @param[out] a autoregressive coefficients
+ @param[out] err prediction error (variance)
+ @param[in] nbCoefs number of autoregressive coefficients
+ */
+void arm_levinson_durbin_f32(const float32_t *phi,
+ float32_t *a,
+ float32_t *err,
+ int nbCoefs);
+
+
+/**
+ @brief Levinson Durbin
+ @param[in] phi autocovariance vector starting with lag 0 (length is nbCoefs + 1)
+ @param[out] a autoregressive coefficients
+ @param[out] err prediction error (variance)
+ @param[in] nbCoefs number of autoregressive coefficients
+ */
+void arm_levinson_durbin_q31(const q31_t *phi,
+ q31_t *a,
+ q31_t *err,
+ int nbCoefs);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _FILTERING_FUNCTIONS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/filtering_functions_f16.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/filtering_functions_f16.h
new file mode 100755
index 0000000..655cd7e
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/filtering_functions_f16.h
@@ -0,0 +1,236 @@
+/******************************************************************************
+ * @file filtering_functions_f16.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ * 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.
+ */
+
+
+#ifndef FILTERING_FUNCTIONS_F16_H_
+#define FILTERING_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 Instance structure for the floating-point FIR filter.
+ */
+ typedef struct
+ {
+ uint16_t numTaps; /**< number of filter coefficients in the filter. */
+ float16_t *pState; /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+ const float16_t *pCoeffs; /**< points to the coefficient array. The array is of length numTaps. */
+ } arm_fir_instance_f16;
+
+ /**
+ * @brief Initialization function for the floating-point FIR filter.
+ * @param[in,out] S points to an instance of the floating-point FIR filter structure.
+ * @param[in] numTaps Number of filter coefficients in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ * @param[in] blockSize number of samples that are processed at a time.
+ */
+ void arm_fir_init_f16(
+ arm_fir_instance_f16 * S,
+ uint16_t numTaps,
+ const float16_t * pCoeffs,
+ float16_t * pState,
+ uint32_t blockSize);
+
+ /**
+ * @brief Processing function for the floating-point FIR filter.
+ * @param[in] S points to an instance of the floating-point FIR structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_fir_f16(
+ const arm_fir_instance_f16 * S,
+ const float16_t * pSrc,
+ float16_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Instance structure for the floating-point Biquad cascade filter.
+ */
+ typedef struct
+ {
+ uint32_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
+ float16_t *pState; /**< Points to the array of state coefficients. The array is of length 4*numStages. */
+ const float16_t *pCoeffs; /**< Points to the array of coefficients. The array is of length 5*numStages. */
+ } arm_biquad_casd_df1_inst_f16;
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+ /**
+ * @brief Instance structure for the modified Biquad coefs required by vectorized code.
+ */
+ typedef struct
+ {
+ float16_t coeffs[12][8]; /**< Points to the array of modified coefficients. The array is of length 32. There is one per stage */
+ } arm_biquad_mod_coef_f16;
+#endif
+
+ /**
+ * @brief Processing function for the floating-point Biquad cascade filter.
+ * @param[in] S points to an instance of the floating-point Biquad cascade structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cascade_df1_f16(
+ const arm_biquad_casd_df1_inst_f16 * S,
+ const float16_t * pSrc,
+ float16_t * pDst,
+ uint32_t blockSize);
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+ void arm_biquad_cascade_df1_mve_init_f16(
+ arm_biquad_casd_df1_inst_f16 * S,
+ uint8_t numStages,
+ const float16_t * pCoeffs,
+ arm_biquad_mod_coef_f16 * pCoeffsMod,
+ float16_t * pState);
+#endif
+
+ void arm_biquad_cascade_df1_init_f16(
+ arm_biquad_casd_df1_inst_f16 * S,
+ uint8_t numStages,
+ const float16_t * pCoeffs,
+ float16_t * pState);
+
+ /**
+ * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.
+ */
+ typedef struct
+ {
+ uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
+ float16_t *pState; /**< points to the array of state coefficients. The array is of length 2*numStages. */
+ const float16_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */
+ } arm_biquad_cascade_df2T_instance_f16;
+
+ /**
+ * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.
+ */
+ typedef struct
+ {
+ uint8_t numStages; /**< number of 2nd order stages in the filter. Overall order is 2*numStages. */
+ float16_t *pState; /**< points to the array of state coefficients. The array is of length 4*numStages. */
+ const float16_t *pCoeffs; /**< points to the array of coefficients. The array is of length 5*numStages. */
+ } arm_biquad_cascade_stereo_df2T_instance_f16;
+
+ /**
+ * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter.
+ * @param[in] S points to an instance of the filter data structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cascade_df2T_f16(
+ const arm_biquad_cascade_df2T_instance_f16 * S,
+ const float16_t * pSrc,
+ float16_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. 2 channels
+ * @param[in] S points to an instance of the filter data structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_biquad_cascade_stereo_df2T_f16(
+ const arm_biquad_cascade_stereo_df2T_instance_f16 * S,
+ const float16_t * pSrc,
+ float16_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter.
+ * @param[in,out] S points to an instance of the filter data structure.
+ * @param[in] numStages number of 2nd order stages in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ */
+ void arm_biquad_cascade_df2T_init_f16(
+ arm_biquad_cascade_df2T_instance_f16 * S,
+ uint8_t numStages,
+ const float16_t * pCoeffs,
+ float16_t * pState);
+
+ /**
+ * @brief Initialization function for the floating-point transposed direct form II Biquad cascade filter.
+ * @param[in,out] S points to an instance of the filter data structure.
+ * @param[in] numStages number of 2nd order stages in the filter.
+ * @param[in] pCoeffs points to the filter coefficients.
+ * @param[in] pState points to the state buffer.
+ */
+ void arm_biquad_cascade_stereo_df2T_init_f16(
+ arm_biquad_cascade_stereo_df2T_instance_f16 * S,
+ uint8_t numStages,
+ const float16_t * pCoeffs,
+ float16_t * pState);
+
+ /**
+ * @brief Correlation of floating-point sequences.
+ * @param[in] pSrcA points to the first input sequence.
+ * @param[in] srcALen length of the first input sequence.
+ * @param[in] pSrcB points to the second input sequence.
+ * @param[in] srcBLen length of the second input sequence.
+ * @param[out] pDst points to the block of output data Length 2 * max(srcALen, srcBLen) - 1.
+ */
+ void arm_correlate_f16(
+ const float16_t * pSrcA,
+ uint32_t srcALen,
+ const float16_t * pSrcB,
+ uint32_t srcBLen,
+ float16_t * pDst);
+
+
+/**
+ @brief Levinson Durbin
+ @param[in] phi autocovariance vector starting with lag 0 (length is nbCoefs + 1)
+ @param[out] a autoregressive coefficients
+ @param[out] err prediction error (variance)
+ @param[in] nbCoefs number of autoregressive coefficients
+ */
+void arm_levinson_durbin_f16(const float16_t *phi,
+ float16_t *a,
+ float16_t *err,
+ int nbCoefs);
+
+#endif /*defined(ARM_FLOAT16_SUPPORTED)*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _FILTERING_FUNCTIONS_F16_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/interpolation_functions.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/interpolation_functions.h
new file mode 100755
index 0000000..66ef995
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/interpolation_functions.h
@@ -0,0 +1,275 @@
+/******************************************************************************
+ * @file interpolation_functions.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ * 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.
+ */
+
+
+#ifndef INTERPOLATION_FUNCTIONS_H_
+#define INTERPOLATION_FUNCTIONS_H_
+
+#include "arm_math_types.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/**
+ * @defgroup groupInterpolation Interpolation Functions
+ * These functions perform 1- and 2-dimensional interpolation of data.
+ * Linear interpolation is used for 1-dimensional data and
+ * bilinear interpolation is used for 2-dimensional data.
+ */
+
+
+ /**
+ * @brief Instance structure for the floating-point Linear Interpolate function.
+ */
+ typedef struct
+ {
+ uint32_t nValues; /**< nValues */
+ float32_t x1; /**< x1 */
+ float32_t xSpacing; /**< xSpacing */
+ const float32_t *pYData; /**< pointer to the table of Y values */
+ } arm_linear_interp_instance_f32;
+
+ /**
+ * @brief Instance structure for the floating-point bilinear interpolation function.
+ */
+ typedef struct
+ {
+ uint16_t numRows; /**< number of rows in the data table. */
+ uint16_t numCols; /**< number of columns in the data table. */
+ const float32_t *pData; /**< points to the data table. */
+ } arm_bilinear_interp_instance_f32;
+
+ /**
+ * @brief Instance structure for the Q31 bilinear interpolation function.
+ */
+ typedef struct
+ {
+ uint16_t numRows; /**< number of rows in the data table. */
+ uint16_t numCols; /**< number of columns in the data table. */
+ const q31_t *pData; /**< points to the data table. */
+ } arm_bilinear_interp_instance_q31;
+
+ /**
+ * @brief Instance structure for the Q15 bilinear interpolation function.
+ */
+ typedef struct
+ {
+ uint16_t numRows; /**< number of rows in the data table. */
+ uint16_t numCols; /**< number of columns in the data table. */
+ const q15_t *pData; /**< points to the data table. */
+ } arm_bilinear_interp_instance_q15;
+
+ /**
+ * @brief Instance structure for the Q15 bilinear interpolation function.
+ */
+ typedef struct
+ {
+ uint16_t numRows; /**< number of rows in the data table. */
+ uint16_t numCols; /**< number of columns in the data table. */
+ const q7_t *pData; /**< points to the data table. */
+ } arm_bilinear_interp_instance_q7;
+
+
+ /**
+ * @brief Struct for specifying cubic spline type
+ */
+ typedef enum
+ {
+ ARM_SPLINE_NATURAL = 0, /**< Natural spline */
+ ARM_SPLINE_PARABOLIC_RUNOUT = 1 /**< Parabolic runout spline */
+ } arm_spline_type;
+
+ /**
+ * @brief Instance structure for the floating-point cubic spline interpolation.
+ */
+ typedef struct
+ {
+ arm_spline_type type; /**< Type (boundary conditions) */
+ const float32_t * x; /**< x values */
+ const float32_t * y; /**< y values */
+ uint32_t n_x; /**< Number of known data points */
+ float32_t * coeffs; /**< Coefficients buffer (b,c, and d) */
+ } arm_spline_instance_f32;
+
+
+ /**
+ * @brief Processing function for the floating-point cubic spline interpolation.
+ * @param[in] S points to an instance of the floating-point spline structure.
+ * @param[in] xq points to the x values of the interpolated data points.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples of output data.
+ */
+ void arm_spline_f32(
+ arm_spline_instance_f32 * S,
+ const float32_t * xq,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Initialization function for the floating-point cubic spline interpolation.
+ * @param[in,out] S points to an instance of the floating-point spline structure.
+ * @param[in] type type of cubic spline interpolation (boundary conditions)
+ * @param[in] x points to the x values of the known data points.
+ * @param[in] y points to the y values of the known data points.
+ * @param[in] n number of known data points.
+ * @param[in] coeffs coefficients array for b, c, and d
+ * @param[in] tempBuffer buffer array for internal computations
+ */
+ void arm_spline_init_f32(
+ arm_spline_instance_f32 * S,
+ arm_spline_type type,
+ const float32_t * x,
+ const float32_t * y,
+ uint32_t n,
+ float32_t * coeffs,
+ float32_t * tempBuffer);
+
+
+ /**
+ * @brief Process function for the floating-point Linear Interpolation Function.
+ * @param[in,out] S is an instance of the floating-point Linear Interpolation structure
+ * @param[in] x input sample to process
+ * @return y processed output sample.
+ *
+ */
+ float32_t arm_linear_interp_f32(
+ const arm_linear_interp_instance_f32 * S,
+ float32_t x);
+
+ /**
+ *
+ * @brief Process function for the Q31 Linear Interpolation Function.
+ * @param[in] pYData pointer to Q31 Linear Interpolation table
+ * @param[in] x input sample to process
+ * @param[in] nValues number of table values
+ * @return y processed output sample.
+ *
+ * \par
+ * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.
+ * This function can support maximum of table size 2^12.
+ *
+ */
+ q31_t arm_linear_interp_q31(
+ const q31_t * pYData,
+ q31_t x,
+ uint32_t nValues);
+
+ /**
+ *
+ * @brief Process function for the Q15 Linear Interpolation Function.
+ * @param[in] pYData pointer to Q15 Linear Interpolation table
+ * @param[in] x input sample to process
+ * @param[in] nValues number of table values
+ * @return y processed output sample.
+ *
+ * \par
+ * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.
+ * This function can support maximum of table size 2^12.
+ *
+ */
+ q15_t arm_linear_interp_q15(
+ const q15_t * pYData,
+ q31_t x,
+ uint32_t nValues);
+
+ /**
+ *
+ * @brief Process function for the Q7 Linear Interpolation Function.
+ * @param[in] pYData pointer to Q7 Linear Interpolation table
+ * @param[in] x input sample to process
+ * @param[in] nValues number of table values
+ * @return y processed output sample.
+ *
+ * \par
+ * Input sample x is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.
+ * This function can support maximum of table size 2^12.
+ */
+q7_t arm_linear_interp_q7(
+ const q7_t * pYData,
+ q31_t x,
+ uint32_t nValues);
+
+ /**
+ * @brief Floating-point bilinear interpolation.
+ * @param[in,out] S points to an instance of the interpolation structure.
+ * @param[in] X interpolation coordinate.
+ * @param[in] Y interpolation coordinate.
+ * @return out interpolated value.
+ */
+ float32_t arm_bilinear_interp_f32(
+ const arm_bilinear_interp_instance_f32 * S,
+ float32_t X,
+ float32_t Y);
+
+ /**
+ * @brief Q31 bilinear interpolation.
+ * @param[in,out] S points to an instance of the interpolation structure.
+ * @param[in] X interpolation coordinate in 12.20 format.
+ * @param[in] Y interpolation coordinate in 12.20 format.
+ * @return out interpolated value.
+ */
+ q31_t arm_bilinear_interp_q31(
+ arm_bilinear_interp_instance_q31 * S,
+ q31_t X,
+ q31_t Y);
+
+
+ /**
+ * @brief Q15 bilinear interpolation.
+ * @param[in,out] S points to an instance of the interpolation structure.
+ * @param[in] X interpolation coordinate in 12.20 format.
+ * @param[in] Y interpolation coordinate in 12.20 format.
+ * @return out interpolated value.
+ */
+ q15_t arm_bilinear_interp_q15(
+ arm_bilinear_interp_instance_q15 * S,
+ q31_t X,
+ q31_t Y);
+
+ /**
+ * @brief Q7 bilinear interpolation.
+ * @param[in,out] S points to an instance of the interpolation structure.
+ * @param[in] X interpolation coordinate in 12.20 format.
+ * @param[in] Y interpolation coordinate in 12.20 format.
+ * @return out interpolated value.
+ */
+ q7_t arm_bilinear_interp_q7(
+ arm_bilinear_interp_instance_q7 * S,
+ q31_t X,
+ q31_t Y);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _INTERPOLATION_FUNCTIONS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/interpolation_functions_f16.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/interpolation_functions_f16.h
new file mode 100755
index 0000000..e1f27c3
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/interpolation_functions_f16.h
@@ -0,0 +1,109 @@
+/******************************************************************************
+ * @file interpolation_functions_f16.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ * 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.
+ */
+
+
+#ifndef INTERPOLATION_FUNCTIONS_F16_H_
+#define INTERPOLATION_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 Instance structure for the half floating-point Linear Interpolate function.
+ */
+typedef struct
+{
+ uint32_t nValues; /**< nValues */
+ float16_t x1; /**< x1 */
+ float16_t xSpacing; /**< xSpacing */
+ const float16_t *pYData; /**< pointer to the table of Y values */
+} arm_linear_interp_instance_f16;
+
+/**
+ * @brief Instance structure for the floating-point bilinear interpolation function.
+ */
+typedef struct
+{
+ uint16_t numRows;/**< number of rows in the data table. */
+ uint16_t numCols;/**< number of columns in the data table. */
+ const float16_t *pData; /**< points to the data table. */
+} arm_bilinear_interp_instance_f16;
+
+ /**
+ * @addtogroup LinearInterpolate
+ * @{
+ */
+
+ /**
+ * @brief Process function for the floating-point Linear Interpolation Function.
+ * @param[in,out] S is an instance of the floating-point Linear Interpolation structure
+ * @param[in] x input sample to process
+ * @return y processed output sample.
+ */
+ float16_t arm_linear_interp_f16(
+ const arm_linear_interp_instance_f16 * S,
+ float16_t x);
+
+ /**
+ * @} end of LinearInterpolate group
+ */
+
+/**
+ * @addtogroup BilinearInterpolate
+ * @{
+ */
+
+ /**
+ * @brief Floating-point bilinear interpolation.
+ * @param[in,out] S points to an instance of the interpolation structure.
+ * @param[in] X interpolation coordinate.
+ * @param[in] Y interpolation coordinate.
+ * @return out interpolated value.
+ */
+ float16_t arm_bilinear_interp_f16(
+ const arm_bilinear_interp_instance_f16 * S,
+ float16_t X,
+ float16_t Y);
+
+
+ /**
+ * @} end of BilinearInterpolate group
+ */
+#endif /*defined(ARM_FLOAT16_SUPPORTED)*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _INTERPOLATION_FUNCTIONS_F16_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/matrix_functions.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/matrix_functions.h
new file mode 100755
index 0000000..a19144b
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/matrix_functions.h
@@ -0,0 +1,871 @@
+/******************************************************************************
+ * @file matrix_functions.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.1
+ * @date 10 August 2022
+ * 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.
+ */
+
+
+#ifndef MATRIX_FUNCTIONS_H_
+#define MATRIX_FUNCTIONS_H_
+
+#include "arm_math_types.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * @defgroup groupMatrix Matrix Functions
+ *
+ * This set of functions provides basic matrix math operations.
+ * The functions operate on matrix data structures. For example,
+ * the type
+ * definition for the floating-point matrix structure is shown
+ * below:
+ *
+ * typedef struct
+ * {
+ * uint16_t numRows; // number of rows of the matrix.
+ * uint16_t numCols; // number of columns of the matrix.
+ * float32_t *pData; // points to the data of the matrix.
+ * } arm_matrix_instance_f32;
+ *
+ * There are similar definitions for Q15 and Q31 data types.
+ *
+ * The structure specifies the size of the matrix and then points to
+ * an array of data. The array is of size numRows X numCols
+ * and the values are arranged in row order. That is, the
+ * matrix element (i, j) is stored at:
+ *
+ * pData[i*numCols + j]
+ *
+ *
+ * \par Init Functions
+ * There is an associated initialization function for each type of matrix
+ * data structure.
+ * The initialization function sets the values of the internal structure fields.
+ * Refer to \ref arm_mat_init_f32(), \ref arm_mat_init_q31() and \ref arm_mat_init_q15()
+ * for floating-point, Q31 and Q15 types, respectively.
+ *
+ * \par
+ * Use of the initialization function is optional. However, if initialization function is used
+ * then the instance structure cannot be placed into a const data section.
+ * To place the instance structure in a const data
+ * section, manually initialize the data structure. For example:
+ *
+ * arm_matrix_instance_f32 S = {nRows, nColumns, pData};
+ * arm_matrix_instance_q31 S = {nRows, nColumns, pData};
+ * arm_matrix_instance_q15 S = {nRows, nColumns, pData};
+ *
+ * where nRows specifies the number of rows, nColumns
+ * specifies the number of columns, and pData points to the
+ * data array.
+ *
+ * \par Size Checking
+ * By default all of the matrix functions perform size checking on the input and
+ * output matrices. For example, the matrix addition function verifies that the
+ * two input matrices and the output matrix all have the same number of rows and
+ * columns. If the size check fails the functions return:
+ *
+ * ARM_MATH_SIZE_MISMATCH
+ *
+ * Otherwise the functions return
+ *
+ * ARM_MATH_SUCCESS
+ *
+ * There is some overhead associated with this matrix size checking.
+ * The matrix size checking is enabled via the \#define
+ *
+ * ARM_MATH_MATRIX_CHECK
+ *
+ * within the library project settings. By default this macro is defined
+ * and size checking is enabled. By changing the project settings and
+ * undefining this macro size checking is eliminated and the functions
+ * run a bit faster. With size checking disabled the functions always
+ * return ARM_MATH_SUCCESS.
+ */
+
+ #define DEFAULT_HOUSEHOLDER_THRESHOLD_F64 (1.0e-16)
+ #define DEFAULT_HOUSEHOLDER_THRESHOLD_F32 (1.0e-12f)
+
+ /**
+ * @brief Instance structure for the floating-point matrix structure.
+ */
+ typedef struct
+ {
+ uint16_t numRows; /**< number of rows of the matrix. */
+ uint16_t numCols; /**< number of columns of the matrix. */
+ float32_t *pData; /**< points to the data of the matrix. */
+ } arm_matrix_instance_f32;
+
+ /**
+ * @brief Instance structure for the floating-point matrix structure.
+ */
+ typedef struct
+ {
+ uint16_t numRows; /**< number of rows of the matrix. */
+ uint16_t numCols; /**< number of columns of the matrix. */
+ float64_t *pData; /**< points to the data of the matrix. */
+ } arm_matrix_instance_f64;
+
+ /**
+ * @brief Instance structure for the Q7 matrix structure.
+ */
+ typedef struct
+ {
+ uint16_t numRows; /**< number of rows of the matrix. */
+ uint16_t numCols; /**< number of columns of the matrix. */
+ q7_t *pData; /**< points to the data of the matrix. */
+ } arm_matrix_instance_q7;
+
+ /**
+ * @brief Instance structure for the Q15 matrix structure.
+ */
+ typedef struct
+ {
+ uint16_t numRows; /**< number of rows of the matrix. */
+ uint16_t numCols; /**< number of columns of the matrix. */
+ q15_t *pData; /**< points to the data of the matrix. */
+ } arm_matrix_instance_q15;
+
+ /**
+ * @brief Instance structure for the Q31 matrix structure.
+ */
+ typedef struct
+ {
+ uint16_t numRows; /**< number of rows of the matrix. */
+ uint16_t numCols; /**< number of columns of the matrix. */
+ q31_t *pData; /**< points to the data of the matrix. */
+ } arm_matrix_instance_q31;
+
+ /**
+ * @brief Floating-point matrix addition.
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_add_f32(
+ const arm_matrix_instance_f32 * pSrcA,
+ const arm_matrix_instance_f32 * pSrcB,
+ arm_matrix_instance_f32 * pDst);
+
+ /**
+ * @brief Q15 matrix addition.
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_add_q15(
+ const arm_matrix_instance_q15 * pSrcA,
+ const arm_matrix_instance_q15 * pSrcB,
+ arm_matrix_instance_q15 * pDst);
+
+ /**
+ * @brief Q31 matrix addition.
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_add_q31(
+ const arm_matrix_instance_q31 * pSrcA,
+ const arm_matrix_instance_q31 * pSrcB,
+ arm_matrix_instance_q31 * pDst);
+
+ /**
+ * @brief Floating-point, complex, matrix multiplication.
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_cmplx_mult_f32(
+ const arm_matrix_instance_f32 * pSrcA,
+ const arm_matrix_instance_f32 * pSrcB,
+ arm_matrix_instance_f32 * pDst);
+
+ /**
+ * @brief Q15, complex, matrix multiplication.
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_cmplx_mult_q15(
+ const arm_matrix_instance_q15 * pSrcA,
+ const arm_matrix_instance_q15 * pSrcB,
+ arm_matrix_instance_q15 * pDst,
+ q15_t * pScratch);
+
+ /**
+ * @brief Q31, complex, matrix multiplication.
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_cmplx_mult_q31(
+ const arm_matrix_instance_q31 * pSrcA,
+ const arm_matrix_instance_q31 * pSrcB,
+ arm_matrix_instance_q31 * pDst);
+
+ /**
+ * @brief Floating-point matrix transpose.
+ * @param[in] pSrc points to the input matrix
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either ARM_MATH_SIZE_MISMATCH
+ * or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_trans_f32(
+ const arm_matrix_instance_f32 * pSrc,
+ arm_matrix_instance_f32 * pDst);
+
+/**
+ * @brief Floating-point matrix transpose.
+ * @param[in] pSrc points to the input matrix
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either ARM_MATH_SIZE_MISMATCH
+ * or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_trans_f64(
+ const arm_matrix_instance_f64 * pSrc,
+ arm_matrix_instance_f64 * pDst);
+
+ /**
+ * @brief Floating-point complex matrix transpose.
+ * @param[in] pSrc points to the input matrix
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either ARM_MATH_SIZE_MISMATCH
+ * or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_cmplx_trans_f32(
+ const arm_matrix_instance_f32 * pSrc,
+ arm_matrix_instance_f32 * pDst);
+
+
+ /**
+ * @brief Q15 matrix transpose.
+ * @param[in] pSrc points to the input matrix
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either ARM_MATH_SIZE_MISMATCH
+ * or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_trans_q15(
+ const arm_matrix_instance_q15 * pSrc,
+ arm_matrix_instance_q15 * pDst);
+
+ /**
+ * @brief Q15 complex matrix transpose.
+ * @param[in] pSrc points to the input matrix
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either ARM_MATH_SIZE_MISMATCH
+ * or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_cmplx_trans_q15(
+ const arm_matrix_instance_q15 * pSrc,
+ arm_matrix_instance_q15 * pDst);
+
+ /**
+ * @brief Q7 matrix transpose.
+ * @param[in] pSrc points to the input matrix
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either ARM_MATH_SIZE_MISMATCH
+ * or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_trans_q7(
+ const arm_matrix_instance_q7 * pSrc,
+ arm_matrix_instance_q7 * pDst);
+
+ /**
+ * @brief Q31 matrix transpose.
+ * @param[in] pSrc points to the input matrix
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either ARM_MATH_SIZE_MISMATCH
+ * or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_trans_q31(
+ const arm_matrix_instance_q31 * pSrc,
+ arm_matrix_instance_q31 * pDst);
+
+ /**
+ * @brief Q31 complex matrix transpose.
+ * @param[in] pSrc points to the input matrix
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either ARM_MATH_SIZE_MISMATCH
+ * or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_cmplx_trans_q31(
+ const arm_matrix_instance_q31 * pSrc,
+ arm_matrix_instance_q31 * pDst);
+
+ /**
+ * @brief Floating-point matrix multiplication
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_mult_f32(
+ const arm_matrix_instance_f32 * pSrcA,
+ const arm_matrix_instance_f32 * pSrcB,
+ arm_matrix_instance_f32 * pDst);
+
+ /**
+ * @brief Floating-point matrix multiplication
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_mult_f64(
+ const arm_matrix_instance_f64 * pSrcA,
+ const arm_matrix_instance_f64 * pSrcB,
+ arm_matrix_instance_f64 * pDst);
+
+ /**
+ * @brief Floating-point matrix and vector multiplication
+ * @param[in] pSrcMat points to the input matrix structure
+ * @param[in] pVec points to vector
+ * @param[out] pDst points to output vector
+ */
+void arm_mat_vec_mult_f32(
+ const arm_matrix_instance_f32 *pSrcMat,
+ const float32_t *pVec,
+ float32_t *pDst);
+
+ /**
+ * @brief Q7 matrix multiplication
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @param[in] pState points to the array for storing intermediate results
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_mult_q7(
+ const arm_matrix_instance_q7 * pSrcA,
+ const arm_matrix_instance_q7 * pSrcB,
+ arm_matrix_instance_q7 * pDst,
+ q7_t * pState);
+
+ /**
+ * @brief Q7 matrix and vector multiplication
+ * @param[in] pSrcMat points to the input matrix structure
+ * @param[in] pVec points to vector
+ * @param[out] pDst points to output vector
+ */
+void arm_mat_vec_mult_q7(
+ const arm_matrix_instance_q7 *pSrcMat,
+ const q7_t *pVec,
+ q7_t *pDst);
+
+ /**
+ * @brief Q15 matrix multiplication
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @param[in] pState points to the array for storing intermediate results
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_mult_q15(
+ const arm_matrix_instance_q15 * pSrcA,
+ const arm_matrix_instance_q15 * pSrcB,
+ arm_matrix_instance_q15 * pDst,
+ q15_t * pState);
+
+ /**
+ * @brief Q15 matrix and vector multiplication
+ * @param[in] pSrcMat points to the input matrix structure
+ * @param[in] pVec points to vector
+ * @param[out] pDst points to output vector
+ */
+void arm_mat_vec_mult_q15(
+ const arm_matrix_instance_q15 *pSrcMat,
+ const q15_t *pVec,
+ q15_t *pDst);
+
+ /**
+ * @brief Q15 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @param[in] pState points to the array for storing intermediate results
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_mult_fast_q15(
+ const arm_matrix_instance_q15 * pSrcA,
+ const arm_matrix_instance_q15 * pSrcB,
+ arm_matrix_instance_q15 * pDst,
+ q15_t * pState);
+
+ /**
+ * @brief Q31 matrix multiplication
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_mult_q31(
+ const arm_matrix_instance_q31 * pSrcA,
+ const arm_matrix_instance_q31 * pSrcB,
+ arm_matrix_instance_q31 * pDst);
+
+ /**
+ * @brief Q31 matrix multiplication
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @param[in] pState points to the array for storing intermediate results
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_mult_opt_q31(
+ const arm_matrix_instance_q31 * pSrcA,
+ const arm_matrix_instance_q31 * pSrcB,
+ arm_matrix_instance_q31 * pDst,
+ q31_t *pState);
+
+ /**
+ * @brief Q31 matrix and vector multiplication
+ * @param[in] pSrcMat points to the input matrix structure
+ * @param[in] pVec points to vector
+ * @param[out] pDst points to output vector
+ */
+void arm_mat_vec_mult_q31(
+ const arm_matrix_instance_q31 *pSrcMat,
+ const q31_t *pVec,
+ q31_t *pDst);
+
+ /**
+ * @brief Q31 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_mult_fast_q31(
+ const arm_matrix_instance_q31 * pSrcA,
+ const arm_matrix_instance_q31 * pSrcB,
+ arm_matrix_instance_q31 * pDst);
+
+ /**
+ * @brief Floating-point matrix subtraction
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_sub_f32(
+ const arm_matrix_instance_f32 * pSrcA,
+ const arm_matrix_instance_f32 * pSrcB,
+ arm_matrix_instance_f32 * pDst);
+
+ /**
+ * @brief Floating-point matrix subtraction
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_sub_f64(
+ const arm_matrix_instance_f64 * pSrcA,
+ const arm_matrix_instance_f64 * pSrcB,
+ arm_matrix_instance_f64 * pDst);
+
+ /**
+ * @brief Q15 matrix subtraction
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_sub_q15(
+ const arm_matrix_instance_q15 * pSrcA,
+ const arm_matrix_instance_q15 * pSrcB,
+ arm_matrix_instance_q15 * pDst);
+
+ /**
+ * @brief Q31 matrix subtraction
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_sub_q31(
+ const arm_matrix_instance_q31 * pSrcA,
+ const arm_matrix_instance_q31 * pSrcB,
+ arm_matrix_instance_q31 * pDst);
+
+ /**
+ * @brief Floating-point matrix scaling.
+ * @param[in] pSrc points to the input matrix
+ * @param[in] scale scale factor
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_scale_f32(
+ const arm_matrix_instance_f32 * pSrc,
+ float32_t scale,
+ arm_matrix_instance_f32 * pDst);
+
+ /**
+ * @brief Q15 matrix scaling.
+ * @param[in] pSrc points to input matrix
+ * @param[in] scaleFract fractional portion of the scale factor
+ * @param[in] shift number of bits to shift the result by
+ * @param[out] pDst points to output matrix
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_scale_q15(
+ const arm_matrix_instance_q15 * pSrc,
+ q15_t scaleFract,
+ int32_t shift,
+ arm_matrix_instance_q15 * pDst);
+
+ /**
+ * @brief Q31 matrix scaling.
+ * @param[in] pSrc points to input matrix
+ * @param[in] scaleFract fractional portion of the scale factor
+ * @param[in] shift number of bits to shift the result by
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_scale_q31(
+ const arm_matrix_instance_q31 * pSrc,
+ q31_t scaleFract,
+ int32_t shift,
+ arm_matrix_instance_q31 * pDst);
+
+ /**
+ * @brief Q31 matrix initialization.
+ * @param[in,out] S points to an instance of the floating-point matrix structure.
+ * @param[in] nRows number of rows in the matrix.
+ * @param[in] nColumns number of columns in the matrix.
+ * @param[in] pData points to the matrix data array.
+ */
+void arm_mat_init_q31(
+ arm_matrix_instance_q31 * S,
+ uint16_t nRows,
+ uint16_t nColumns,
+ q31_t * pData);
+
+ /**
+ * @brief Q15 matrix initialization.
+ * @param[in,out] S points to an instance of the floating-point matrix structure.
+ * @param[in] nRows number of rows in the matrix.
+ * @param[in] nColumns number of columns in the matrix.
+ * @param[in] pData points to the matrix data array.
+ */
+void arm_mat_init_q15(
+ arm_matrix_instance_q15 * S,
+ uint16_t nRows,
+ uint16_t nColumns,
+ q15_t * pData);
+
+ /**
+ * @brief Q7 matrix initialization.
+ * @param[in,out] S points to an instance of the floating-point matrix structure.
+ * @param[in] nRows number of rows in the matrix.
+ * @param[in] nColumns number of columns in the matrix.
+ * @param[in] pData points to the matrix data array.
+ */
+void arm_mat_init_q7(
+ arm_matrix_instance_q7 * S,
+ uint16_t nRows,
+ uint16_t nColumns,
+ q7_t * pData);
+
+ /**
+ * @brief Floating-point matrix initialization.
+ * @param[in,out] S points to an instance of the floating-point matrix structure.
+ * @param[in] nRows number of rows in the matrix.
+ * @param[in] nColumns number of columns in the matrix.
+ * @param[in] pData points to the matrix data array.
+ */
+void arm_mat_init_f32(
+ arm_matrix_instance_f32 * S,
+ uint16_t nRows,
+ uint16_t nColumns,
+ float32_t * pData);
+
+/**
+ * @brief Floating-point matrix initialization.
+ * @param[in,out] S points to an instance of the floating-point matrix structure.
+ * @param[in] nRows number of rows in the matrix.
+ * @param[in] nColumns number of columns in the matrix.
+ * @param[in] pData points to the matrix data array.
+ */
+void arm_mat_init_f64(
+ arm_matrix_instance_f64 * S,
+ uint16_t nRows,
+ uint16_t nColumns,
+ float64_t * pData);
+
+
+
+
+ /**
+ * @brief Floating-point matrix inverse.
+ * @param[in] src points to the instance of the input floating-point matrix structure.
+ * @param[out] dst points to the instance of the output floating-point matrix structure.
+ * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
+ * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR.
+ */
+ arm_status arm_mat_inverse_f32(
+ const arm_matrix_instance_f32 * src,
+ arm_matrix_instance_f32 * dst);
+
+
+ /**
+ * @brief Floating-point matrix inverse.
+ * @param[in] src points to the instance of the input floating-point matrix structure.
+ * @param[out] dst points to the instance of the output floating-point matrix structure.
+ * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
+ * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR.
+ */
+ arm_status arm_mat_inverse_f64(
+ const arm_matrix_instance_f64 * src,
+ arm_matrix_instance_f64 * dst);
+
+ /**
+ * @brief Floating-point Cholesky decomposition of Symmetric Positive Definite Matrix.
+ * @param[in] src points to the instance of the input floating-point matrix structure.
+ * @param[out] dst points to the instance of the output floating-point matrix structure.
+ * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
+ * If the input matrix does not have a decomposition, then the algorithm terminates and returns error status ARM_MATH_DECOMPOSITION_FAILURE.
+ * If the matrix is ill conditioned or only semi-definite, then it is better using the LDL^t decomposition.
+ * The decomposition is returning a lower triangular matrix.
+ */
+ arm_status arm_mat_cholesky_f64(
+ const arm_matrix_instance_f64 * src,
+ arm_matrix_instance_f64 * dst);
+
+ /**
+ * @brief Floating-point Cholesky decomposition of Symmetric Positive Definite Matrix.
+ * @param[in] src points to the instance of the input floating-point matrix structure.
+ * @param[out] dst points to the instance of the output floating-point matrix structure.
+ * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
+ * If the input matrix does not have a decomposition, then the algorithm terminates and returns error status ARM_MATH_DECOMPOSITION_FAILURE.
+ * If the matrix is ill conditioned or only semi-definite, then it is better using the LDL^t decomposition.
+ * The decomposition is returning a lower triangular matrix.
+ */
+ arm_status arm_mat_cholesky_f32(
+ const arm_matrix_instance_f32 * src,
+ arm_matrix_instance_f32 * dst);
+
+ /**
+ * @brief Solve UT . X = A where UT is an upper triangular matrix
+ * @param[in] ut The upper triangular matrix
+ * @param[in] a The matrix a
+ * @param[out] dst The solution X of UT . X = A
+ * @return The function returns ARM_MATH_SINGULAR, if the system can't be solved.
+ */
+ arm_status arm_mat_solve_upper_triangular_f32(
+ const arm_matrix_instance_f32 * ut,
+ const arm_matrix_instance_f32 * a,
+ arm_matrix_instance_f32 * dst);
+
+ /**
+ * @brief Solve LT . X = A where LT is a lower triangular matrix
+ * @param[in] lt The lower triangular matrix
+ * @param[in] a The matrix a
+ * @param[out] dst The solution X of LT . X = A
+ * @return The function returns ARM_MATH_SINGULAR, if the system can't be solved.
+ */
+ arm_status arm_mat_solve_lower_triangular_f32(
+ const arm_matrix_instance_f32 * lt,
+ const arm_matrix_instance_f32 * a,
+ arm_matrix_instance_f32 * dst);
+
+
+ /**
+ * @brief Solve UT . X = A where UT is an upper triangular matrix
+ * @param[in] ut The upper triangular matrix
+ * @param[in] a The matrix a
+ * @param[out] dst The solution X of UT . X = A
+ * @return The function returns ARM_MATH_SINGULAR, if the system can't be solved.
+ */
+ arm_status arm_mat_solve_upper_triangular_f64(
+ const arm_matrix_instance_f64 * ut,
+ const arm_matrix_instance_f64 * a,
+ arm_matrix_instance_f64 * dst);
+
+ /**
+ * @brief Solve LT . X = A where LT is a lower triangular matrix
+ * @param[in] lt The lower triangular matrix
+ * @param[in] a The matrix a
+ * @param[out] dst The solution X of LT . X = A
+ * @return The function returns ARM_MATH_SINGULAR, if the system can't be solved.
+ */
+ arm_status arm_mat_solve_lower_triangular_f64(
+ const arm_matrix_instance_f64 * lt,
+ const arm_matrix_instance_f64 * a,
+ arm_matrix_instance_f64 * dst);
+
+
+ /**
+ * @brief Floating-point LDL decomposition of Symmetric Positive Semi-Definite Matrix.
+ * @param[in] src points to the instance of the input floating-point matrix structure.
+ * @param[out] l points to the instance of the output floating-point triangular matrix structure.
+ * @param[out] d points to the instance of the output floating-point diagonal matrix structure.
+ * @param[out] p points to the instance of the output floating-point permutation vector.
+ * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
+ * If the input matrix does not have a decomposition, then the algorithm terminates and returns error status ARM_MATH_DECOMPOSITION_FAILURE.
+ * The decomposition is returning a lower triangular matrix.
+ */
+ arm_status arm_mat_ldlt_f32(
+ const arm_matrix_instance_f32 * src,
+ arm_matrix_instance_f32 * l,
+ arm_matrix_instance_f32 * d,
+ uint16_t * pp);
+
+ /**
+ * @brief Floating-point LDL decomposition of Symmetric Positive Semi-Definite Matrix.
+ * @param[in] src points to the instance of the input floating-point matrix structure.
+ * @param[out] l points to the instance of the output floating-point triangular matrix structure.
+ * @param[out] d points to the instance of the output floating-point diagonal matrix structure.
+ * @param[out] p points to the instance of the output floating-point permutation vector.
+ * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
+ * If the input matrix does not have a decomposition, then the algorithm terminates and returns error status ARM_MATH_DECOMPOSITION_FAILURE.
+ * The decomposition is returning a lower triangular matrix.
+ */
+ arm_status arm_mat_ldlt_f64(
+ const arm_matrix_instance_f64 * src,
+ arm_matrix_instance_f64 * l,
+ arm_matrix_instance_f64 * d,
+ uint16_t * pp);
+
+/**
+ @brief QR decomposition of a m x n floating point matrix with m >= n.
+ @param[in] pSrc points to input matrix structure. The source matrix is modified by the function.
+ @param[in] threshold norm2 threshold.
+ @param[out] pOutR points to output R matrix structure of dimension m x n
+ @param[out] pOutQ points to output Q matrix structure of dimension m x m
+ @param[out] pOutTau points to Householder scaling factors of dimension n
+ @param[inout] pTmpA points to a temporary vector of dimension m.
+ @param[inout] pTmpB points to a temporary vector of dimension n.
+ @return execution status
+ - \ref ARM_MATH_SUCCESS : Operation successful
+ - \ref ARM_MATH_SIZE_MISMATCH : Matrix size check failed
+ - \ref ARM_MATH_SINGULAR : Input matrix is found to be singular (non-invertible)
+ */
+
+arm_status arm_mat_qr_f32(
+ const arm_matrix_instance_f32 * pSrc,
+ const float32_t threshold,
+ arm_matrix_instance_f32 * pOutR,
+ arm_matrix_instance_f32 * pOutQ,
+ float32_t * pOutTau,
+ float32_t *pTmpA,
+ float32_t *pTmpB
+ );
+
+/**
+ @brief QR decomposition of a m x n floating point matrix with m >= n.
+ @param[in] pSrc points to input matrix structure. The source matrix is modified by the function.
+ @param[in] threshold norm2 threshold.
+ @param[out] pOutR points to output R matrix structure of dimension m x n
+ @param[out] pOutQ points to output Q matrix structure of dimension m x m
+ @param[out] pOutTau points to Householder scaling factors of dimension n
+ @param[inout] pTmpA points to a temporary vector of dimension m.
+ @param[inout] pTmpB points to a temporary vector of dimension n.
+ @return execution status
+ - \ref ARM_MATH_SUCCESS : Operation successful
+ - \ref ARM_MATH_SIZE_MISMATCH : Matrix size check failed
+ - \ref ARM_MATH_SINGULAR : Input matrix is found to be singular (non-invertible)
+ */
+
+arm_status arm_mat_qr_f64(
+ const arm_matrix_instance_f64 * pSrc,
+ const float64_t threshold,
+ arm_matrix_instance_f64 * pOutR,
+ arm_matrix_instance_f64 * pOutQ,
+ float64_t * pOutTau,
+ float64_t *pTmpA,
+ float64_t *pTmpB
+ );
+
+/**
+ @brief Householder transform of a floating point vector.
+ @param[in] pSrc points to the input vector.
+ @param[in] threshold norm2 threshold.
+ @param[in] blockSize dimension of the vector space.
+ @param[outQ] pOut points to the output vector.
+ @return beta return the scaling factor beta
+ */
+
+float32_t arm_householder_f32(
+ const float32_t * pSrc,
+ const float32_t threshold,
+ uint32_t blockSize,
+ float32_t * pOut
+ );
+
+/**
+ @brief Householder transform of a double floating point vector.
+ @param[in] pSrc points to the input vector.
+ @param[in] threshold norm2 threshold.
+ @param[in] blockSize dimension of the vector space.
+ @param[outQ] pOut points to the output vector.
+ @return beta return the scaling factor beta
+ */
+
+float64_t arm_householder_f64(
+ const float64_t * pSrc,
+ const float64_t threshold,
+ uint32_t blockSize,
+ float64_t * pOut
+ );
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _MATRIX_FUNCTIONS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/matrix_functions_f16.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/matrix_functions_f16.h
new file mode 100755
index 0000000..25f99ab
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/matrix_functions_f16.h
@@ -0,0 +1,260 @@
+/******************************************************************************
+ * @file matrix_functions_f16.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ * 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.
+ */
+
+
+#ifndef MATRIX_FUNCTIONS_F16_H_
+#define MATRIX_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)
+
+ #define DEFAULT_HOUSEHOLDER_THRESHOLD_F16 (1.0e-3f)
+
+ /**
+ * @brief Instance structure for the floating-point matrix structure.
+ */
+ typedef struct
+ {
+ uint16_t numRows; /**< number of rows of the matrix. */
+ uint16_t numCols; /**< number of columns of the matrix. */
+ float16_t *pData; /**< points to the data of the matrix. */
+ } arm_matrix_instance_f16;
+
+ /**
+ * @brief Floating-point matrix addition.
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_add_f16(
+ const arm_matrix_instance_f16 * pSrcA,
+ const arm_matrix_instance_f16 * pSrcB,
+ arm_matrix_instance_f16 * pDst);
+
+ /**
+ * @brief Floating-point, complex, matrix multiplication.
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_cmplx_mult_f16(
+ const arm_matrix_instance_f16 * pSrcA,
+ const arm_matrix_instance_f16 * pSrcB,
+ arm_matrix_instance_f16 * pDst);
+
+ /**
+ * @brief Floating-point matrix transpose.
+ * @param[in] pSrc points to the input matrix
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either ARM_MATH_SIZE_MISMATCH
+ * or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_trans_f16(
+ const arm_matrix_instance_f16 * pSrc,
+ arm_matrix_instance_f16 * pDst);
+
+ /**
+ * @brief Floating-point complex matrix transpose.
+ * @param[in] pSrc points to the input matrix
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either ARM_MATH_SIZE_MISMATCH
+ * or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_cmplx_trans_f16(
+ const arm_matrix_instance_f16 * pSrc,
+ arm_matrix_instance_f16 * pDst);
+
+ /**
+ * @brief Floating-point matrix multiplication
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_mult_f16(
+ const arm_matrix_instance_f16 * pSrcA,
+ const arm_matrix_instance_f16 * pSrcB,
+ arm_matrix_instance_f16 * pDst);
+ /**
+ * @brief Floating-point matrix and vector multiplication
+ * @param[in] pSrcMat points to the input matrix structure
+ * @param[in] pVec points to vector
+ * @param[out] pDst points to output vector
+ */
+void arm_mat_vec_mult_f16(
+ const arm_matrix_instance_f16 *pSrcMat,
+ const float16_t *pVec,
+ float16_t *pDst);
+
+ /**
+ * @brief Floating-point matrix subtraction
+ * @param[in] pSrcA points to the first input matrix structure
+ * @param[in] pSrcB points to the second input matrix structure
+ * @param[out] pDst points to output matrix structure
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_sub_f16(
+ const arm_matrix_instance_f16 * pSrcA,
+ const arm_matrix_instance_f16 * pSrcB,
+ arm_matrix_instance_f16 * pDst);
+
+ /**
+ * @brief Floating-point matrix scaling.
+ * @param[in] pSrc points to the input matrix
+ * @param[in] scale scale factor
+ * @param[out] pDst points to the output matrix
+ * @return The function returns either
+ * ARM_MATH_SIZE_MISMATCH or ARM_MATH_SUCCESS based on the outcome of size checking.
+ */
+arm_status arm_mat_scale_f16(
+ const arm_matrix_instance_f16 * pSrc,
+ float16_t scale,
+ arm_matrix_instance_f16 * pDst);
+
+ /**
+ * @brief Floating-point matrix initialization.
+ * @param[in,out] S points to an instance of the floating-point matrix structure.
+ * @param[in] nRows number of rows in the matrix.
+ * @param[in] nColumns number of columns in the matrix.
+ * @param[in] pData points to the matrix data array.
+ */
+void arm_mat_init_f16(
+ arm_matrix_instance_f16 * S,
+ uint16_t nRows,
+ uint16_t nColumns,
+ float16_t * pData);
+
+
+ /**
+ * @brief Floating-point matrix inverse.
+ * @param[in] src points to the instance of the input floating-point matrix structure.
+ * @param[out] dst points to the instance of the output floating-point matrix structure.
+ * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
+ * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR.
+ */
+ arm_status arm_mat_inverse_f16(
+ const arm_matrix_instance_f16 * src,
+ arm_matrix_instance_f16 * dst);
+
+
+ /**
+ * @brief Floating-point Cholesky decomposition of Symmetric Positive Definite Matrix.
+ * @param[in] src points to the instance of the input floating-point matrix structure.
+ * @param[out] dst points to the instance of the output floating-point matrix structure.
+ * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
+ * If the input matrix does not have a decomposition, then the algorithm terminates and returns error status ARM_MATH_DECOMPOSITION_FAILURE.
+ * If the matrix is ill conditioned or only semi-definite, then it is better using the LDL^t decomposition.
+ * The decomposition is returning a lower triangular matrix.
+ */
+ arm_status arm_mat_cholesky_f16(
+ const arm_matrix_instance_f16 * src,
+ arm_matrix_instance_f16 * dst);
+
+ /**
+ * @brief Solve UT . X = A where UT is an upper triangular matrix
+ * @param[in] ut The upper triangular matrix
+ * @param[in] a The matrix a
+ * @param[out] dst The solution X of UT . X = A
+ * @return The function returns ARM_MATH_SINGULAR, if the system can't be solved.
+ */
+ arm_status arm_mat_solve_upper_triangular_f16(
+ const arm_matrix_instance_f16 * ut,
+ const arm_matrix_instance_f16 * a,
+ arm_matrix_instance_f16 * dst);
+
+ /**
+ * @brief Solve LT . X = A where LT is a lower triangular matrix
+ * @param[in] lt The lower triangular matrix
+ * @param[in] a The matrix a
+ * @param[out] dst The solution X of LT . X = A
+ * @return The function returns ARM_MATH_SINGULAR, if the system can't be solved.
+ */
+ arm_status arm_mat_solve_lower_triangular_f16(
+ const arm_matrix_instance_f16 * lt,
+ const arm_matrix_instance_f16 * a,
+ arm_matrix_instance_f16 * dst);
+
+
+/**
+ @brief QR decomposition of a m x n floating point matrix with m >= n.
+ @param[in] pSrc points to input matrix structure. The source matrix is modified by the function.
+ @param[in] threshold norm2 threshold.
+ @param[out] pOutR points to output R matrix structure of dimension m x n
+ @param[out] pOutQ points to output Q matrix structure of dimension m x m
+ @param[out] pOutTau points to Householder scaling factors of dimension n
+ @param[inout] pTmpA points to a temporary vector of dimension m.
+ @param[inout] pTmpB points to a temporary vector of dimension n.
+ @return execution status
+ - \ref ARM_MATH_SUCCESS : Operation successful
+ - \ref ARM_MATH_SIZE_MISMATCH : Matrix size check failed
+ - \ref ARM_MATH_SINGULAR : Input matrix is found to be singular (non-invertible)
+ */
+arm_status arm_mat_qr_f16(
+ const arm_matrix_instance_f16 * pSrc,
+ const float16_t threshold,
+ arm_matrix_instance_f16 * pOutR,
+ arm_matrix_instance_f16 * pOutQ,
+ float16_t * pOutTau,
+ float16_t *pTmpA,
+ float16_t *pTmpB
+ );
+
+/**
+ @brief Householder transform of a half floating point vector.
+ @param[in] pSrc points to the input vector.
+ @param[in] threshold norm2 threshold.
+ @param[in] blockSize dimension of the vector space.
+ @param[outQ] pOut points to the output vector.
+ @return beta return the scaling factor beta
+ */
+float16_t arm_householder_f16(
+ const float16_t * pSrc,
+ const float16_t threshold,
+ uint32_t blockSize,
+ float16_t * pOut
+ );
+
+#endif /*defined(ARM_FLOAT16_SUPPORTED)*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _MATRIX_FUNCTIONS_F16_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/matrix_utils.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/matrix_utils.h
new file mode 100755
index 0000000..acb996f
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/matrix_utils.h
@@ -0,0 +1,649 @@
+/******************************************************************************
+ * @file matrix_utils.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.11.0
+ * @date 30 May 2022
+ * Target Processor: Cortex-M and Cortex-A cores
+ ******************************************************************************/
+/*
+ * Copyright (c) 2010-2022 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.
+ */
+
+
+#ifndef MATRIX_UTILS_H_
+#define MATRIX_UTILS_H_
+
+#include "arm_math_types.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define ELEM(A,ROW,COL) &((A)->pData[(A)->numCols* (ROW) + (COL)])
+
+#define SCALE_COL_T(T,CAST,A,ROW,v,i) \
+{ \
+ int32_t _w; \
+ T *data = (A)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ const int32_t nb = (A)->numRows - ROW;\
+ \
+ data += i + _numCols * (ROW); \
+ \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ *data = CAST *data * CAST v; \
+ data += _numCols; \
+ } \
+}
+
+#define COPY_COL_T(T,A,ROW,COL,DST) \
+{ \
+ uint32_t _row; \
+ T *_pb=DST; \
+ T *_pa = (A)->pData + ROW * (A)->numCols + COL;\
+ for(_row = ROW; _row < (A)->numRows; _row ++) \
+ { \
+ *_pb++ = *_pa; \
+ _pa += (A)->numCols; \
+ } \
+}
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+#if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#define SWAP_ROWS_F16(A,COL,i,j) \
+ { \
+ int cnt = ((A)->numCols)-(COL); \
+ int32_t _w; \
+ float16_t *data = (A)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ \
+ for(_w=(COL);_w < _numCols; _w+=8) \
+ { \
+ f16x8_t tmpa,tmpb; \
+ mve_pred16_t p0 = vctp16q(cnt); \
+ \
+ tmpa=vldrhq_z_f16(&data[i*_numCols + _w],p0);\
+ tmpb=vldrhq_z_f16(&data[j*_numCols + _w],p0);\
+ \
+ vstrhq_p(&data[i*_numCols + _w], tmpb, p0); \
+ vstrhq_p(&data[j*_numCols + _w], tmpa, p0); \
+ \
+ cnt -= 8; \
+ } \
+ }
+
+#define SCALE_ROW_F16(A,COL,v,i) \
+{ \
+ int cnt = ((A)->numCols)-(COL); \
+ int32_t _w; \
+ float16_t *data = (A)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ \
+ for(_w=(COL);_w < _numCols; _w+=8) \
+ { \
+ f16x8_t tmpa; \
+ mve_pred16_t p0 = vctp16q(cnt); \
+ tmpa = vldrhq_z_f16(&data[i*_numCols + _w],p0);\
+ tmpa = vmulq_n_f16(tmpa,(_Float16)v); \
+ vstrhq_p(&data[i*_numCols + _w], tmpa, p0); \
+ cnt -= 8; \
+ } \
+ \
+}
+
+#define MAC_ROW_F16(COL,A,i,v,B,j) \
+{ \
+ int cnt = ((A)->numCols)-(COL); \
+ int32_t _w; \
+ float16_t *dataA = (A)->pData; \
+ float16_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ \
+ for(_w=(COL);_w < _numCols; _w+=8) \
+ { \
+ f16x8_t tmpa,tmpb; \
+ mve_pred16_t p0 = vctp16q(cnt); \
+ tmpa = vldrhq_z_f16(&dataA[i*_numCols + _w],p0);\
+ tmpb = vldrhq_z_f16(&dataB[j*_numCols + _w],p0);\
+ tmpa = vfmaq_n_f16(tmpa,tmpb,v); \
+ vstrhq_p(&dataA[i*_numCols + _w], tmpa, p0); \
+ cnt -= 8; \
+ } \
+ \
+}
+
+#define MAS_ROW_F16(COL,A,i,v,B,j) \
+{ \
+ int cnt = ((A)->numCols)-(COL); \
+ int32_t _w; \
+ float16_t *dataA = (A)->pData; \
+ float16_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ f16x8_t vec=vdupq_n_f16(v); \
+ \
+ for(_w=(COL);_w < _numCols; _w+=8) \
+ { \
+ f16x8_t tmpa,tmpb; \
+ mve_pred16_t p0 = vctp16q(cnt); \
+ tmpa = vldrhq_z_f16(&dataA[i*_numCols + _w],p0);\
+ tmpb = vldrhq_z_f16(&dataB[j*_numCols + _w],p0);\
+ tmpa = vfmsq_f16(tmpa,tmpb,vec); \
+ vstrhq_p(&dataA[i*_numCols + _w], tmpa, p0); \
+ cnt -= 8; \
+ } \
+ \
+}
+
+#else
+
+
+#define SWAP_ROWS_F16(A,COL,i,j) \
+{ \
+ int32_t _w; \
+ float16_t *dataI = (A)->pData; \
+ float16_t *dataJ = (A)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols-(COL); \
+ \
+ dataI += i*_numCols + (COL); \
+ dataJ += j*_numCols + (COL); \
+ \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ float16_t tmp; \
+ tmp = *dataI; \
+ *dataI++ = *dataJ; \
+ *dataJ++ = tmp; \
+ } \
+}
+
+#define SCALE_ROW_F16(A,COL,v,i) \
+{ \
+ int32_t _w; \
+ float16_t *data = (A)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols-(COL); \
+ \
+ data += i*_numCols + (COL); \
+ \
+ _Float16 sum; \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ sum = *data; \
+ sum *= (_Float16)v; \
+ *data++ = sum; \
+ } \
+}
+
+
+#define MAC_ROW_F16(COL,A,i,v,B,j) \
+{ \
+ int32_t _w; \
+ float16_t *dataA = (A)->pData; \
+ float16_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ const int32_t nb = _numCols-(COL); \
+ \
+ dataA += i*_numCols + (COL); \
+ dataB += j*_numCols + (COL); \
+ \
+ _Float16 sum ; \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ sum = *dataA; \
+ sum += (_Float16)v * (_Float16)*dataB++;\
+ *dataA++ = sum; \
+ } \
+}
+
+#define MAS_ROW_F16(COL,A,i,v,B,j) \
+{ \
+ int32_t _w; \
+ float16_t *dataA = (A)->pData; \
+ float16_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ const int32_t nb = _numCols-(COL); \
+ \
+ dataA += i*_numCols + (COL); \
+ dataB += j*_numCols + (COL); \
+ \
+ _Float16 sum ; \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ sum = *dataA; \
+ sum -= (_Float16)v * (_Float16)*dataB++;\
+ *dataA++ = sum; \
+ } \
+}
+
+#endif /*defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)*/
+
+/* Functions with only a scalar version */
+#define COPY_COL_F16(A,ROW,COL,DST) \
+ COPY_COL_T(float16_t,A,ROW,COL,DST)
+
+#define SCALE_COL_F16(A,ROW,v,i) \
+ SCALE_COL_T(float16_t,(_Float16),A,ROW,v,i)
+
+#endif /* defined(ARM_FLOAT16_SUPPORTED)*/
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#define SWAP_ROWS_F32(A,COL,i,j) \
+ { \
+ int cnt = ((A)->numCols)-(COL); \
+ float32_t *data = (A)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ int32_t _w; \
+ \
+ for(_w=(COL);_w < _numCols; _w+=4) \
+ { \
+ f32x4_t tmpa,tmpb; \
+ mve_pred16_t p0 = vctp32q(cnt); \
+ \
+ tmpa=vldrwq_z_f32(&data[i*_numCols + _w],p0);\
+ tmpb=vldrwq_z_f32(&data[j*_numCols + _w],p0);\
+ \
+ vstrwq_p(&data[i*_numCols + _w], tmpb, p0); \
+ vstrwq_p(&data[j*_numCols + _w], tmpa, p0); \
+ \
+ cnt -= 4; \
+ } \
+ }
+
+#define MAC_ROW_F32(COL,A,i,v,B,j) \
+{ \
+ int cnt = ((A)->numCols)-(COL); \
+ float32_t *dataA = (A)->pData; \
+ float32_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ int32_t _w; \
+ \
+ for(_w=(COL);_w < _numCols; _w+=4) \
+ { \
+ f32x4_t tmpa,tmpb; \
+ mve_pred16_t p0 = vctp32q(cnt); \
+ tmpa = vldrwq_z_f32(&dataA[i*_numCols + _w],p0);\
+ tmpb = vldrwq_z_f32(&dataB[j*_numCols + _w],p0);\
+ tmpa = vfmaq_n_f32(tmpa,tmpb,v); \
+ vstrwq_p(&dataA[i*_numCols + _w], tmpa, p0); \
+ cnt -= 4; \
+ } \
+ \
+}
+
+#define MAS_ROW_F32(COL,A,i,v,B,j) \
+{ \
+ int cnt = ((A)->numCols)-(COL); \
+ float32_t *dataA = (A)->pData; \
+ float32_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ int32_t _w; \
+ f32x4_t vec=vdupq_n_f32(v); \
+ \
+ for(_w=(COL);_w < _numCols; _w+=4) \
+ { \
+ f32x4_t tmpa,tmpb; \
+ mve_pred16_t p0 = vctp32q(cnt); \
+ tmpa = vldrwq_z_f32(&dataA[i*_numCols + _w],p0);\
+ tmpb = vldrwq_z_f32(&dataB[j*_numCols + _w],p0);\
+ tmpa = vfmsq_f32(tmpa,tmpb,vec); \
+ vstrwq_p(&dataA[i*_numCols + _w], tmpa, p0); \
+ cnt -= 4; \
+ } \
+ \
+}
+
+#define SCALE_ROW_F32(A,COL,v,i) \
+{ \
+ int cnt = ((A)->numCols)-(COL); \
+ float32_t *data = (A)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ int32_t _w; \
+ \
+ for(_w=(COL);_w < _numCols; _w+=4) \
+ { \
+ f32x4_t tmpa; \
+ mve_pred16_t p0 = vctp32q(cnt); \
+ tmpa = vldrwq_z_f32(&data[i*_numCols + _w],p0);\
+ tmpa = vmulq_n_f32(tmpa,v); \
+ vstrwq_p(&data[i*_numCols + _w], tmpa, p0); \
+ cnt -= 4; \
+ } \
+ \
+}
+
+#elif defined(ARM_MATH_NEON)
+
+#define SWAP_ROWS_F32(A,COL,i,j) \
+{ \
+ int32_t _w; \
+ float32_t *dataI = (A)->pData; \
+ float32_t *dataJ = (A)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols - COL; \
+ \
+ dataI += i*_numCols + (COL); \
+ dataJ += j*_numCols + (COL); \
+ \
+ float32_t tmp; \
+ \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ tmp = *dataI; \
+ *dataI++ = *dataJ; \
+ *dataJ++ = tmp; \
+ } \
+}
+
+#define MAC_ROW_F32(COL,A,i,v,B,j) \
+{ \
+ float32_t *dataA = (A)->pData; \
+ float32_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols - (COL); \
+ int32_t nbElems; \
+ f32x4_t vec = vdupq_n_f32(v); \
+ \
+ nbElems = nb >> 2; \
+ \
+ dataA += i*_numCols + (COL); \
+ dataB += j*_numCols + (COL); \
+ \
+ while(nbElems>0) \
+ { \
+ f32x4_t tmpa,tmpb; \
+ tmpa = vld1q_f32(dataA,p0); \
+ tmpb = vld1q_f32(dataB,p0); \
+ tmpa = vmlaq_f32(tmpa,tmpb,vec);\
+ vst1q_f32(dataA, tmpa, p0); \
+ nbElems--; \
+ dataA += 4; \
+ dataB += 4; \
+ } \
+ \
+ nbElems = nb & 3; \
+ while(nbElems > 0) \
+ { \
+ *dataA++ += v* *dataB++; \
+ nbElems--; \
+ } \
+}
+
+#define MAS_ROW_F32(COL,A,i,v,B,j) \
+{ \
+ float32_t *dataA = (A)->pData; \
+ float32_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols - (COL); \
+ int32_t nbElems; \
+ f32x4_t vec = vdupq_n_f32(v); \
+ \
+ nbElems = nb >> 2; \
+ \
+ dataA += i*_numCols + (COL); \
+ dataB += j*_numCols + (COL); \
+ \
+ while(nbElems>0) \
+ { \
+ f32x4_t tmpa,tmpb; \
+ tmpa = vld1q_f32(dataA); \
+ tmpb = vld1q_f32(dataB); \
+ tmpa = vmlsq_f32(tmpa,tmpb,vec);\
+ vst1q_f32(dataA, tmpa); \
+ nbElems--; \
+ dataA += 4; \
+ dataB += 4; \
+ } \
+ \
+ nbElems = nb & 3; \
+ while(nbElems > 0) \
+ { \
+ *dataA++ -= v* *dataB++; \
+ nbElems--; \
+ } \
+}
+
+#define SCALE_ROW_F32(A,COL,v,i) \
+{ \
+ float32_t *data = (A)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ const int32_t nb = _numCols - (COL); \
+ int32_t nbElems; \
+ f32x4_t vec = vdupq_n_f32(v); \
+ \
+ nbElems = nb >> 2; \
+ \
+ data += i*_numCols + (COL); \
+ while(nbElems>0) \
+ { \
+ f32x4_t tmpa; \
+ tmpa = vld1q_f32(data); \
+ tmpa = vmulq_f32(tmpa,vec); \
+ vst1q_f32(data, tmpa); \
+ data += 4; \
+ nbElems --; \
+ } \
+ \
+ nbElems = nb & 3; \
+ while(nbElems > 0) \
+ { \
+ *data++ *= v; \
+ nbElems--; \
+ } \
+ \
+}
+
+#else
+
+#define SWAP_ROWS_F32(A,COL,i,j) \
+{ \
+ int32_t _w; \
+ float32_t tmp; \
+ float32_t *dataI = (A)->pData; \
+ float32_t *dataJ = (A)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols - COL; \
+ \
+ dataI += i*_numCols + (COL); \
+ dataJ += j*_numCols + (COL); \
+ \
+ \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ tmp = *dataI; \
+ *dataI++ = *dataJ; \
+ *dataJ++ = tmp; \
+ } \
+}
+
+#define SCALE_ROW_F32(A,COL,v,i) \
+{ \
+ int32_t _w; \
+ float32_t *data = (A)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols - COL; \
+ \
+ data += i*_numCols + (COL); \
+ \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ *data++ *= v; \
+ } \
+}
+
+
+#define MAC_ROW_F32(COL,A,i,v,B,j) \
+{ \
+ int32_t _w; \
+ float32_t *dataA = (A)->pData; \
+ float32_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols-(COL); \
+ \
+ dataA = dataA + i*_numCols + (COL); \
+ dataB = dataB + j*_numCols + (COL); \
+ \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ *dataA++ += v* *dataB++; \
+ } \
+}
+
+#define MAS_ROW_F32(COL,A,i,v,B,j) \
+{ \
+ int32_t _w; \
+ float32_t *dataA = (A)->pData; \
+ float32_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols-(COL); \
+ \
+ dataA = dataA + i*_numCols + (COL); \
+ dataB = dataB + j*_numCols + (COL); \
+ \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ *dataA++ -= v* *dataB++; \
+ } \
+}
+
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+
+/* Functions _with only a scalar version */
+
+#define COPY_COL_F32(A,ROW,COL,DST) \
+ COPY_COL_T(float32_t,A,ROW,COL,DST)
+
+#define COPY_COL_F64(A,ROW,COL,DST) \
+ COPY_COL_T(float64_t,A,ROW,COL,DST)
+
+#define SWAP_COLS_F32(A,COL,i,j) \
+{ \
+ int32_t _w; \
+ float32_t *data = (A)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ for(_w=(COL);_w < _numCols; _w++) \
+ { \
+ float32_t tmp; \
+ tmp = data[_w*_numCols + i]; \
+ data[_w*_numCols + i] = data[_w*_numCols + j];\
+ data[_w*_numCols + j] = tmp; \
+ } \
+}
+
+#define SCALE_COL_F32(A,ROW,v,i) \
+ SCALE_COL_T(float32_t,,A,ROW,v,i)
+
+#define SWAP_ROWS_F64(A,COL,i,j) \
+{ \
+ int32_t _w; \
+ float64_t *dataI = (A)->pData; \
+ float64_t *dataJ = (A)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols-(COL); \
+ \
+ dataI += i*_numCols + (COL); \
+ dataJ += j*_numCols + (COL); \
+ \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ float64_t tmp; \
+ tmp = *dataI; \
+ *dataI++ = *dataJ; \
+ *dataJ++ = tmp; \
+ } \
+}
+
+#define SWAP_COLS_F64(A,COL,i,j) \
+{ \
+ int32_t _w; \
+ float64_t *data = (A)->pData; \
+ const int32_t _numCols = (A)->numCols; \
+ for(_w=(COL);_w < _numCols; _w++) \
+ { \
+ float64_t tmp; \
+ tmp = data[_w*_numCols + i]; \
+ data[_w*_numCols + i] = data[_w*_numCols + j];\
+ data[_w*_numCols + j] = tmp; \
+ } \
+}
+
+#define SCALE_ROW_F64(A,COL,v,i) \
+{ \
+ int32_t _w; \
+ float64_t *data = (A)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols-(COL); \
+ \
+ data += i*_numCols + (COL); \
+ \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ *data++ *= v; \
+ } \
+}
+
+#define SCALE_COL_F64(A,ROW,v,i) \
+ SCALE_COL_T(float64_t,,A,ROW,v,i)
+
+#define MAC_ROW_F64(COL,A,i,v,B,j) \
+{ \
+ int32_t _w; \
+ float64_t *dataA = (A)->pData; \
+ float64_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols-(COL); \
+ \
+ dataA += i*_numCols + (COL); \
+ dataB += j*_numCols + (COL); \
+ \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ *dataA++ += v* *dataB++; \
+ } \
+}
+
+#define MAS_ROW_F64(COL,A,i,v,B,j) \
+{ \
+ int32_t _w; \
+ float64_t *dataA = (A)->pData; \
+ float64_t *dataB = (B)->pData; \
+ const int32_t _numCols = (A)->numCols;\
+ const int32_t nb = _numCols-(COL); \
+ \
+ dataA += i*_numCols + (COL); \
+ dataB += j*_numCols + (COL); \
+ \
+ for(_w=0;_w < nb; _w++) \
+ { \
+ *dataA++ -= v* *dataB++; \
+ } \
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _MATRIX_UTILS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/none.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/none.h
new file mode 100755
index 0000000..019c41f
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/none.h
@@ -0,0 +1,576 @@
+/******************************************************************************
+ * @file none.h
+ * @brief Intrinsics when no DSP extension available
+ * @version V1.9.0
+ * @date 20. July 2020
+ ******************************************************************************/
+/*
+ * 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.
+ */
+
+/*
+
+Definitions in this file are allowing to reuse some versions of the
+CMSIS-DSP to build on a core (M0 for instance) or a host where
+DSP extension are not available.
+
+Ideally a pure C version should have been used instead.
+But those are not always available or use a restricted set
+of intrinsics.
+
+*/
+
+#ifndef NONE_H_
+#define NONE_H_
+
+#include "arm_math_types.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+
+/*
+
+Normally those kind of definitions are in a compiler file
+in Core or Core_A.
+
+But for MSVC compiler it is a bit special. The goal is very specific
+to CMSIS-DSP and only to allow the use of this library from other
+systems like Python or Matlab.
+
+MSVC is not going to be used to cross-compile to ARM. So, having a MSVC
+compiler file in Core or Core_A would not make sense.
+
+*/
+#if defined ( _MSC_VER ) || defined(__GNUC_PYTHON__) || defined(__APPLE_CC__)
+ __STATIC_FORCEINLINE uint8_t __CLZ(uint32_t data)
+ {
+ if (data == 0U) { return 32U; }
+
+ uint32_t count = 0U;
+ uint32_t mask = 0x80000000U;
+
+ while ((data & mask) == 0U)
+ {
+ count += 1U;
+ mask = mask >> 1U;
+ }
+ return ((uint8_t)count);
+ }
+
+ __STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat)
+ {
+ if ((sat >= 1U) && (sat <= 32U))
+ {
+ const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
+ const int32_t min = -1 - max ;
+ if (val > max)
+ {
+ return max;
+ }
+ else if (val < min)
+ {
+ return min;
+ }
+ }
+ return val;
+ }
+
+ __STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat)
+ {
+ if (sat <= 31U)
+ {
+ const uint32_t max = ((1U << sat) - 1U);
+ if (val > (int32_t)max)
+ {
+ return max;
+ }
+ else if (val < 0)
+ {
+ return 0U;
+ }
+ }
+ return (uint32_t)val;
+ }
+
+ /**
+ \brief Rotate Right in unsigned value (32 bit)
+ \details Rotate Right (immediate) provides the value of the contents of a register rotated by a variable number of bits.
+ \param [in] op1 Value to rotate
+ \param [in] op2 Number of Bits to rotate
+ \return Rotated value
+ */
+__STATIC_FORCEINLINE uint32_t __ROR(uint32_t op1, uint32_t op2)
+{
+ op2 %= 32U;
+ if (op2 == 0U)
+ {
+ return op1;
+ }
+ return (op1 >> op2) | (op1 << (32U - op2));
+}
+
+
+#endif
+
+/**
+ * @brief Clips Q63 to Q31 values.
+ */
+ __STATIC_FORCEINLINE q31_t clip_q63_to_q31(
+ q63_t x)
+ {
+ return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ?
+ ((0x7FFFFFFF ^ ((q31_t) (x >> 63)))) : (q31_t) x;
+ }
+
+ /**
+ * @brief Clips Q63 to Q15 values.
+ */
+ __STATIC_FORCEINLINE q15_t clip_q63_to_q15(
+ q63_t x)
+ {
+ return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ?
+ ((0x7FFF ^ ((q15_t) (x >> 63)))) : (q15_t) (x >> 15);
+ }
+
+ /**
+ * @brief Clips Q31 to Q7 values.
+ */
+ __STATIC_FORCEINLINE q7_t clip_q31_to_q7(
+ q31_t x)
+ {
+ return ((q31_t) (x >> 24) != ((q31_t) x >> 23)) ?
+ ((0x7F ^ ((q7_t) (x >> 31)))) : (q7_t) x;
+ }
+
+ /**
+ * @brief Clips Q31 to Q15 values.
+ */
+ __STATIC_FORCEINLINE q15_t clip_q31_to_q15(
+ q31_t x)
+ {
+ return ((q31_t) (x >> 16) != ((q31_t) x >> 15)) ?
+ ((0x7FFF ^ ((q15_t) (x >> 31)))) : (q15_t) x;
+ }
+
+ /**
+ * @brief Multiplies 32 X 64 and returns 32 bit result in 2.30 format.
+ */
+ __STATIC_FORCEINLINE q63_t mult32x64(
+ q63_t x,
+ q31_t y)
+ {
+ return ((((q63_t) (x & 0x00000000FFFFFFFF) * y) >> 32) +
+ (((q63_t) (x >> 32) * y) ) );
+ }
+
+/* SMMLAR */
+#define multAcc_32x32_keep32_R(a, x, y) \
+ a = (q31_t) (((((q63_t) a) << 32) + ((q63_t) x * y) + 0x80000000LL ) >> 32)
+
+/* SMMLSR */
+#define multSub_32x32_keep32_R(a, x, y) \
+ a = (q31_t) (((((q63_t) a) << 32) - ((q63_t) x * y) + 0x80000000LL ) >> 32)
+
+/* SMMULR */
+#define mult_32x32_keep32_R(a, x, y) \
+ a = (q31_t) (((q63_t) x * y + 0x80000000LL ) >> 32)
+
+/* SMMLA */
+#define multAcc_32x32_keep32(a, x, y) \
+ a += (q31_t) (((q63_t) x * y) >> 32)
+
+/* SMMLS */
+#define multSub_32x32_keep32(a, x, y) \
+ a -= (q31_t) (((q63_t) x * y) >> 32)
+
+/* SMMUL */
+#define mult_32x32_keep32(a, x, y) \
+ a = (q31_t) (((q63_t) x * y ) >> 32)
+
+#ifndef ARM_MATH_DSP
+ /**
+ * @brief definition to pack two 16 bit values.
+ */
+ #define __PKHBT(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0x0000FFFF) | \
+ (((int32_t)(ARG2) << ARG3) & (int32_t)0xFFFF0000) )
+ #define __PKHTB(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) << 0) & (int32_t)0xFFFF0000) | \
+ (((int32_t)(ARG2) >> ARG3) & (int32_t)0x0000FFFF) )
+#endif
+
+ /**
+ * @brief definition to pack four 8 bit values.
+ */
+#ifndef ARM_MATH_BIG_ENDIAN
+ #define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v0) << 0) & (int32_t)0x000000FF) | \
+ (((int32_t)(v1) << 8) & (int32_t)0x0000FF00) | \
+ (((int32_t)(v2) << 16) & (int32_t)0x00FF0000) | \
+ (((int32_t)(v3) << 24) & (int32_t)0xFF000000) )
+#else
+ #define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v3) << 0) & (int32_t)0x000000FF) | \
+ (((int32_t)(v2) << 8) & (int32_t)0x0000FF00) | \
+ (((int32_t)(v1) << 16) & (int32_t)0x00FF0000) | \
+ (((int32_t)(v0) << 24) & (int32_t)0xFF000000) )
+#endif
+
+
+
+
+/*
+ * @brief C custom defined intrinsic functions
+ */
+#if !defined (ARM_MATH_DSP)
+
+
+ /*
+ * @brief C custom defined QADD8
+ */
+ __STATIC_FORCEINLINE uint32_t __QADD8(
+ uint32_t x,
+ uint32_t y)
+ {
+ q31_t r, s, t, u;
+
+ r = __SSAT(((((q31_t)x << 24) >> 24) + (((q31_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF;
+ s = __SSAT(((((q31_t)x << 16) >> 24) + (((q31_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF;
+ t = __SSAT(((((q31_t)x << 8) >> 24) + (((q31_t)y << 8) >> 24)), 8) & (int32_t)0x000000FF;
+ u = __SSAT(((((q31_t)x ) >> 24) + (((q31_t)y ) >> 24)), 8) & (int32_t)0x000000FF;
+
+ return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r )));
+ }
+
+
+ /*
+ * @brief C custom defined QSUB8
+ */
+ __STATIC_FORCEINLINE uint32_t __QSUB8(
+ uint32_t x,
+ uint32_t y)
+ {
+ q31_t r, s, t, u;
+
+ r = __SSAT(((((q31_t)x << 24) >> 24) - (((q31_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF;
+ s = __SSAT(((((q31_t)x << 16) >> 24) - (((q31_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF;
+ t = __SSAT(((((q31_t)x << 8) >> 24) - (((q31_t)y << 8) >> 24)), 8) & (int32_t)0x000000FF;
+ u = __SSAT(((((q31_t)x ) >> 24) - (((q31_t)y ) >> 24)), 8) & (int32_t)0x000000FF;
+
+ return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r )));
+ }
+
+
+ /*
+ * @brief C custom defined QADD16
+ */
+ __STATIC_FORCEINLINE uint32_t __QADD16(
+ uint32_t x,
+ uint32_t y)
+ {
+/* q31_t r, s; without initialisation 'arm_offset_q15 test' fails but 'intrinsic' tests pass! for armCC */
+ q31_t r = 0, s = 0;
+
+ r = __SSAT(((((q31_t)x << 16) >> 16) + (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
+ s = __SSAT(((((q31_t)x ) >> 16) + (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF;
+
+ return ((uint32_t)((s << 16) | (r )));
+ }
+
+
+ /*
+ * @brief C custom defined SHADD16
+ */
+ __STATIC_FORCEINLINE uint32_t __SHADD16(
+ uint32_t x,
+ uint32_t y)
+ {
+ q31_t r, s;
+
+ r = (((((q31_t)x << 16) >> 16) + (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+ s = (((((q31_t)x ) >> 16) + (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+
+ return ((uint32_t)((s << 16) | (r )));
+ }
+
+
+ /*
+ * @brief C custom defined QSUB16
+ */
+ __STATIC_FORCEINLINE uint32_t __QSUB16(
+ uint32_t x,
+ uint32_t y)
+ {
+ q31_t r, s;
+
+ r = __SSAT(((((q31_t)x << 16) >> 16) - (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
+ s = __SSAT(((((q31_t)x ) >> 16) - (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF;
+
+ return ((uint32_t)((s << 16) | (r )));
+ }
+
+
+ /*
+ * @brief C custom defined SHSUB16
+ */
+ __STATIC_FORCEINLINE uint32_t __SHSUB16(
+ uint32_t x,
+ uint32_t y)
+ {
+ q31_t r, s;
+
+ r = (((((q31_t)x << 16) >> 16) - (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+ s = (((((q31_t)x ) >> 16) - (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+
+ return ((uint32_t)((s << 16) | (r )));
+ }
+
+
+ /*
+ * @brief C custom defined QASX
+ */
+ __STATIC_FORCEINLINE uint32_t __QASX(
+ uint32_t x,
+ uint32_t y)
+ {
+ q31_t r, s;
+
+ r = __SSAT(((((q31_t)x << 16) >> 16) - (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF;
+ s = __SSAT(((((q31_t)x ) >> 16) + (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
+
+ return ((uint32_t)((s << 16) | (r )));
+ }
+
+
+ /*
+ * @brief C custom defined SHASX
+ */
+ __STATIC_FORCEINLINE uint32_t __SHASX(
+ uint32_t x,
+ uint32_t y)
+ {
+ q31_t r, s;
+
+ r = (((((q31_t)x << 16) >> 16) - (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+ s = (((((q31_t)x ) >> 16) + (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+
+ return ((uint32_t)((s << 16) | (r )));
+ }
+
+
+ /*
+ * @brief C custom defined QSAX
+ */
+ __STATIC_FORCEINLINE uint32_t __QSAX(
+ uint32_t x,
+ uint32_t y)
+ {
+ q31_t r, s;
+
+ r = __SSAT(((((q31_t)x << 16) >> 16) + (((q31_t)y ) >> 16)), 16) & (int32_t)0x0000FFFF;
+ s = __SSAT(((((q31_t)x ) >> 16) - (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
+
+ return ((uint32_t)((s << 16) | (r )));
+ }
+
+
+ /*
+ * @brief C custom defined SHSAX
+ */
+ __STATIC_FORCEINLINE uint32_t __SHSAX(
+ uint32_t x,
+ uint32_t y)
+ {
+ q31_t r, s;
+
+ r = (((((q31_t)x << 16) >> 16) + (((q31_t)y ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+ s = (((((q31_t)x ) >> 16) - (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+
+ return ((uint32_t)((s << 16) | (r )));
+ }
+
+
+ /*
+ * @brief C custom defined SMUSDX
+ */
+ __STATIC_FORCEINLINE uint32_t __SMUSDX(
+ uint32_t x,
+ uint32_t y)
+ {
+ return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) -
+ ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) ));
+ }
+
+ /*
+ * @brief C custom defined SMUADX
+ */
+ __STATIC_FORCEINLINE uint32_t __SMUADX(
+ uint32_t x,
+ uint32_t y)
+ {
+ return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) +
+ ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) ));
+ }
+
+
+ /*
+ * @brief C custom defined QADD
+ */
+ __STATIC_FORCEINLINE int32_t __QADD(
+ int32_t x,
+ int32_t y)
+ {
+ return ((int32_t)(clip_q63_to_q31((q63_t)x + (q31_t)y)));
+ }
+
+
+ /*
+ * @brief C custom defined QSUB
+ */
+ __STATIC_FORCEINLINE int32_t __QSUB(
+ int32_t x,
+ int32_t y)
+ {
+ return ((int32_t)(clip_q63_to_q31((q63_t)x - (q31_t)y)));
+ }
+
+
+ /*
+ * @brief C custom defined SMLAD
+ */
+ __STATIC_FORCEINLINE uint32_t __SMLAD(
+ uint32_t x,
+ uint32_t y,
+ uint32_t sum)
+ {
+ return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) +
+ ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) +
+ ( ((q31_t)sum ) ) ));
+ }
+
+
+ /*
+ * @brief C custom defined SMLADX
+ */
+ __STATIC_FORCEINLINE uint32_t __SMLADX(
+ uint32_t x,
+ uint32_t y,
+ uint32_t sum)
+ {
+ return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) +
+ ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) +
+ ( ((q31_t)sum ) ) ));
+ }
+
+
+ /*
+ * @brief C custom defined SMLSDX
+ */
+ __STATIC_FORCEINLINE uint32_t __SMLSDX(
+ uint32_t x,
+ uint32_t y,
+ uint32_t sum)
+ {
+ return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) -
+ ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) +
+ ( ((q31_t)sum ) ) ));
+ }
+
+
+ /*
+ * @brief C custom defined SMLALD
+ */
+ __STATIC_FORCEINLINE uint64_t __SMLALD(
+ uint32_t x,
+ uint32_t y,
+ uint64_t sum)
+ {
+/* return (sum + ((q15_t) (x >> 16) * (q15_t) (y >> 16)) + ((q15_t) x * (q15_t) y)); */
+ return ((uint64_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) +
+ ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) +
+ ( ((q63_t)sum ) ) ));
+ }
+
+
+ /*
+ * @brief C custom defined SMLALDX
+ */
+ __STATIC_FORCEINLINE uint64_t __SMLALDX(
+ uint32_t x,
+ uint32_t y,
+ uint64_t sum)
+ {
+/* return (sum + ((q15_t) (x >> 16) * (q15_t) y)) + ((q15_t) x * (q15_t) (y >> 16)); */
+ return ((uint64_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y ) >> 16)) +
+ ((((q31_t)x ) >> 16) * (((q31_t)y << 16) >> 16)) +
+ ( ((q63_t)sum ) ) ));
+ }
+
+
+ /*
+ * @brief C custom defined SMUAD
+ */
+ __STATIC_FORCEINLINE uint32_t __SMUAD(
+ uint32_t x,
+ uint32_t y)
+ {
+ return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) +
+ ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) ));
+ }
+
+
+ /*
+ * @brief C custom defined SMUSD
+ */
+ __STATIC_FORCEINLINE uint32_t __SMUSD(
+ uint32_t x,
+ uint32_t y)
+ {
+ return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) -
+ ((((q31_t)x ) >> 16) * (((q31_t)y ) >> 16)) ));
+ }
+
+
+ /*
+ * @brief C custom defined SXTB16
+ */
+ __STATIC_FORCEINLINE uint32_t __SXTB16(
+ uint32_t x)
+ {
+ return ((uint32_t)(((((q31_t)x << 24) >> 24) & (q31_t)0x0000FFFF) |
+ ((((q31_t)x << 8) >> 8) & (q31_t)0xFFFF0000) ));
+ }
+
+ /*
+ * @brief C custom defined SMMLA
+ */
+ __STATIC_FORCEINLINE int32_t __SMMLA(
+ int32_t x,
+ int32_t y,
+ int32_t sum)
+ {
+ return (sum + (int32_t) (((int64_t) x * y) >> 32));
+ }
+
+#endif /* !defined (ARM_MATH_DSP) */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _TRANSFORM_FUNCTIONS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/quaternion_math_functions.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/quaternion_math_functions.h
new file mode 100755
index 0000000..6c823a3
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/quaternion_math_functions.h
@@ -0,0 +1,153 @@
+/******************************************************************************
+ * @file quaternion_math_functions.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ *
+ * Target Processor: Cortex-M and Cortex-A cores
+ ******************************************************************************/
+/*
+ * Copyright (c) 2010-2021 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.
+ */
+
+
+#ifndef QUATERNION_MATH_FUNCTIONS_H_
+#define QUATERNION_MATH_FUNCTIONS_H_
+
+#include "arm_math_types.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * @defgroup groupQuaternionMath Quaternion Math Functions
+ * Functions to operates on quaternions and convert between a
+ * rotation and quaternion representation.
+ */
+
+
+/**
+ @brief Floating-point quaternion Norm.
+ @param[in] pInputQuaternions points to the input vector of quaternions
+ @param[out] pNorms points to the output vector of norms
+ @param[in] nbQuaternions number of quaternions in each vector
+ */
+void arm_quaternion_norm_f32(const float32_t *pInputQuaternions,
+ float32_t *pNorms,
+ uint32_t nbQuaternions);
+
+
+/**
+ @brief Floating-point quaternion inverse.
+ @param[in] pInputQuaternions points to the input vector of quaternions
+ @param[out] pInverseQuaternions points to the output vector of inverse quaternions
+ @param[in] nbQuaternions number of quaternions in each vector
+ */
+void arm_quaternion_inverse_f32(const float32_t *pInputQuaternions,
+ float32_t *pInverseQuaternions,
+ uint32_t nbQuaternions);
+
+
+/**
+ @brief Floating-point quaternion conjugates.
+ @param[in] pInputQuaternions points to the input vector of quaternions
+ @param[out] pConjugateQuaternions points to the output vector of conjugate quaternions
+ @param[in] nbQuaternions number of quaternions in each vector
+ */
+void arm_quaternion_conjugate_f32(const float32_t *inputQuaternions,
+ float32_t *pConjugateQuaternions,
+ uint32_t nbQuaternions);
+
+
+/**
+ @brief Floating-point normalization of quaternions.
+ @param[in] pInputQuaternions points to the input vector of quaternions
+ @param[out] pNormalizedQuaternions points to the output vector of normalized quaternions
+ @param[in] nbQuaternions number of quaternions in each vector
+ */
+void arm_quaternion_normalize_f32(const float32_t *inputQuaternions,
+ float32_t *pNormalizedQuaternions,
+ uint32_t nbQuaternions);
+
+
+/**
+ @brief Floating-point product of two quaternions.
+ @param[in] qa First quaternion
+ @param[in] qb Second quaternion
+ @param[out] r Product of two quaternions
+ */
+void arm_quaternion_product_single_f32(const float32_t *qa,
+ const float32_t *qb,
+ float32_t *r);
+
+
+/**
+ @brief Floating-point elementwise product two quaternions.
+ @param[in] qa First array of quaternions
+ @param[in] qb Second array of quaternions
+ @param[out] r Elementwise product of quaternions
+ @param[in] nbQuaternions Number of quaternions in the array
+ */
+void arm_quaternion_product_f32(const float32_t *qa,
+ const float32_t *qb,
+ float32_t *r,
+ uint32_t nbQuaternions);
+
+
+/**
+ * @brief Conversion of quaternion to equivalent rotation matrix.
+ * @param[in] pInputQuaternions points to an array of normalized quaternions
+ * @param[out] pOutputRotations points to an array of 3x3 rotations (in row order)
+ * @param[in] nbQuaternions in the array
+ *
+ * Format of rotation matrix
+ * \par
+ * The quaternion a + ib + jc + kd is converted into rotation matrix:
+ * a^2 + b^2 - c^2 - d^2 2bc - 2ad 2bd + 2ac
+ * 2bc + 2ad a^2 - b^2 + c^2 - d^2 2cd - 2ab
+ * 2bd - 2ac 2cd + 2ab a^2 - b^2 - c^2 + d^2
+ *
+ * Rotation matrix is saved in row order : R00 R01 R02 R10 R11 R12 R20 R21 R22
+ */
+void arm_quaternion2rotation_f32(const float32_t *pInputQuaternions,
+ float32_t *pOutputRotations,
+ uint32_t nbQuaternions);
+
+
+/**
+ * @brief Conversion of a rotation matrix to equivalent quaternion.
+ * @param[in] pInputRotations points to an array 3x3 rotation matrix (in row order)
+ * @param[out] pOutputQuaternions points to an array of quaternions
+ * @param[in] nbQuaternions in the array
+*/
+void arm_rotation2quaternion_f32(const float32_t *pInputRotations,
+ float32_t *pOutputQuaternions,
+ uint32_t nbQuaternions);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _QUATERNION_MATH_FUNCTIONS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/statistics_functions.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/statistics_functions.h
new file mode 100755
index 0000000..301aadd
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/statistics_functions.h
@@ -0,0 +1,988 @@
+/******************************************************************************
+ * @file statistics_functions.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.1
+ * @date 14 July 2022
+ * 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.
+ */
+
+
+#ifndef STATISTICS_FUNCTIONS_H_
+#define STATISTICS_FUNCTIONS_H_
+
+#include "arm_math_types.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+#include "dsp/basic_math_functions.h"
+#include "dsp/fast_math_functions.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/**
+ * @defgroup groupStats Statistics Functions
+ */
+
+/**
+ * @brief Computation of the LogSumExp
+ *
+ * In probabilistic computations, the dynamic of the probability values can be very
+ * wide because they come from gaussian functions.
+ * To avoid underflow and overflow issues, the values are represented by their log.
+ * In this representation, multiplying the original exp values is easy : their logs are added.
+ * But adding the original exp values is requiring some special handling and it is the
+ * goal of the LogSumExp function.
+ *
+ * If the values are x1...xn, the function is computing:
+ *
+ * ln(exp(x1) + ... + exp(xn)) and the computation is done in such a way that
+ * rounding issues are minimised.
+ *
+ * The max xm of the values is extracted and the function is computing:
+ * xm + ln(exp(x1 - xm) + ... + exp(xn - xm))
+ *
+ * @param[in] *in Pointer to an array of input values.
+ * @param[in] blockSize Number of samples in the input array.
+ * @return LogSumExp
+ *
+ */
+
+
+float32_t arm_logsumexp_f32(const float32_t *in, uint32_t blockSize);
+
+/**
+ * @brief Dot product with log arithmetic
+ *
+ * Vectors are containing the log of the samples
+ *
+ * @param[in] pSrcA points to the first input vector
+ * @param[in] pSrcB points to the second input vector
+ * @param[in] blockSize number of samples in each vector
+ * @param[in] pTmpBuffer temporary buffer of length blockSize
+ * @return The log of the dot product .
+ *
+ */
+
+
+float32_t arm_logsumexp_dot_prod_f32(const float32_t * pSrcA,
+ const float32_t * pSrcB,
+ uint32_t blockSize,
+ float32_t *pTmpBuffer);
+
+/**
+ * @brief Entropy
+ *
+ * @param[in] pSrcA Array of input values.
+ * @param[in] blockSize Number of samples in the input array.
+ * @return Entropy -Sum(p ln p)
+ *
+ */
+
+
+float32_t arm_entropy_f32(const float32_t * pSrcA,uint32_t blockSize);
+
+
+/**
+ * @brief Entropy
+ *
+ * @param[in] pSrcA Array of input values.
+ * @param[in] blockSize Number of samples in the input array.
+ * @return Entropy -Sum(p ln p)
+ *
+ */
+
+
+float64_t arm_entropy_f64(const float64_t * pSrcA, uint32_t blockSize);
+
+
+/**
+ * @brief Kullback-Leibler
+ *
+ * @param[in] pSrcA Pointer to an array of input values for probability distribution A.
+ * @param[in] pSrcB Pointer to an array of input values for probability distribution B.
+ * @param[in] blockSize Number of samples in the input array.
+ * @return Kullback-Leibler Divergence D(A || B)
+ *
+ */
+float32_t arm_kullback_leibler_f32(const float32_t * pSrcA
+ ,const float32_t * pSrcB
+ ,uint32_t blockSize);
+
+
+/**
+ * @brief Kullback-Leibler
+ *
+ * @param[in] pSrcA Pointer to an array of input values for probability distribution A.
+ * @param[in] pSrcB Pointer to an array of input values for probability distribution B.
+ * @param[in] blockSize Number of samples in the input array.
+ * @return Kullback-Leibler Divergence D(A || B)
+ *
+ */
+float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
+ const float64_t * pSrcB,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Sum of the squares of the elements of a Q31 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_q31(
+ const q31_t * pSrc,
+ uint32_t blockSize,
+ q63_t * pResult);
+
+
+ /**
+ * @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_f32(
+ const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_t * pResult);
+
+
+ /**
+ * @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_f64(
+ const float64_t * pSrc,
+ uint32_t blockSize,
+ float64_t * pResult);
+
+
+ /**
+ * @brief Sum of the squares of the elements of a Q15 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_q15(
+ const q15_t * pSrc,
+ uint32_t blockSize,
+ q63_t * pResult);
+
+
+ /**
+ * @brief Sum of the squares of the elements of a Q7 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_q7(
+ const q7_t * pSrc,
+ uint32_t blockSize,
+ q31_t * pResult);
+
+
+ /**
+ * @brief Mean value of a Q7 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_q7(
+ const q7_t * pSrc,
+ uint32_t blockSize,
+ q7_t * pResult);
+
+
+ /**
+ * @brief Mean value of a Q15 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_q15(
+ const q15_t * pSrc,
+ uint32_t blockSize,
+ q15_t * pResult);
+
+
+ /**
+ * @brief Mean value of a Q31 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_q31(
+ const q31_t * pSrc,
+ uint32_t blockSize,
+ q31_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_f32(
+ const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_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_f64(
+ const float64_t * pSrc,
+ uint32_t blockSize,
+ float64_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_f32(
+ const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_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_f64(
+ const float64_t * pSrc,
+ uint32_t blockSize,
+ float64_t * pResult);
+
+
+ /**
+ * @brief Variance of the elements of a Q31 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_q31(
+ const q31_t * pSrc,
+ uint32_t blockSize,
+ q31_t * pResult);
+
+
+ /**
+ * @brief Variance of the elements of a Q15 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_q15(
+ const q15_t * pSrc,
+ uint32_t blockSize,
+ q15_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_f32(
+ const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_t * pResult);
+
+
+ /**
+ * @brief Root Mean Square of the elements of a Q31 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_q31(
+ const q31_t * pSrc,
+ uint32_t blockSize,
+ q31_t * pResult);
+
+
+ /**
+ * @brief Root Mean Square of the elements of a Q15 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_q15(
+ const q15_t * pSrc,
+ uint32_t blockSize,
+ q15_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_f32(
+ const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_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_f64(
+ const float64_t * pSrc,
+ uint32_t blockSize,
+ float64_t * pResult);
+
+
+ /**
+ * @brief Standard deviation of the elements of a Q31 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_q31(
+ const q31_t * pSrc,
+ uint32_t blockSize,
+ q31_t * pResult);
+
+
+ /**
+ * @brief Standard deviation of the elements of a Q15 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_q15(
+ const q15_t * pSrc,
+ uint32_t blockSize,
+ q15_t * pResult);
+
+
+
+ /**
+ * @brief Minimum value of a Q7 vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output pointer
+ * @param[in] pIndex is the array index of the minimum value in the input buffer.
+ */
+ void arm_min_q7(
+ const q7_t * pSrc,
+ uint32_t blockSize,
+ q7_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Minimum value of absolute values of a Q7 vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output pointer
+ * @param[in] pIndex is the array index of the minimum value in the input buffer.
+ */
+ void arm_absmin_q7(
+ const q7_t * pSrc,
+ uint32_t blockSize,
+ q7_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Minimum value of absolute values of a Q7 vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output pointer
+ */
+ void arm_absmin_no_idx_q7(
+ const q7_t * pSrc,
+ uint32_t blockSize,
+ q7_t * pResult);
+
+
+ /**
+ * @brief Minimum value of a Q15 vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output pointer
+ * @param[in] pIndex is the array index of the minimum value in the input buffer.
+ */
+ void arm_min_q15(
+ const q15_t * pSrc,
+ uint32_t blockSize,
+ q15_t * pResult,
+ uint32_t * pIndex);
+
+/**
+ * @brief Minimum value of absolute values of a Q15 vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output pointer
+ * @param[in] pIndex is the array index of the minimum value in the input buffer.
+ */
+ void arm_absmin_q15(
+ const q15_t * pSrc,
+ uint32_t blockSize,
+ q15_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Minimum value of absolute values of a Q15 vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output pointer
+ */
+ void arm_absmin_no_idx_q15(
+ const q15_t * pSrc,
+ uint32_t blockSize,
+ q15_t * pResult);
+
+
+ /**
+ * @brief Minimum value of a Q31 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_q31(
+ const q31_t * pSrc,
+ uint32_t blockSize,
+ q31_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Minimum value of absolute values of a Q31 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_absmin_q31(
+ const q31_t * pSrc,
+ uint32_t blockSize,
+ q31_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Minimum value of absolute values of a Q31 vector.
+ * @param[in] pSrc is input pointer
+ * @param[in] blockSize is the number of samples to process
+ * @param[out] pResult is output pointer
+ */
+ void arm_absmin_no_idx_q31(
+ const q31_t * pSrc,
+ uint32_t blockSize,
+ q31_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_f32(
+ const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Minimum value of absolute values 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_absmin_f32(
+ const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Minimum value of absolute values 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
+ */
+ void arm_absmin_no_idx_f32(
+ const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_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_f64(
+ const float64_t * pSrc,
+ uint32_t blockSize,
+ float64_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Minimum value of absolute values 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_absmin_f64(
+ const float64_t * pSrc,
+ uint32_t blockSize,
+ float64_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Minimum value of absolute values 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
+ */
+ void arm_absmin_no_idx_f64(
+ const float64_t * pSrc,
+ uint32_t blockSize,
+ float64_t * pResult);
+
+
+/**
+ * @brief Maximum value of a Q7 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_q7(
+ const q7_t * pSrc,
+ uint32_t blockSize,
+ q7_t * pResult,
+ uint32_t * pIndex);
+
+/**
+ * @brief Maximum value of absolute values of a Q7 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_absmax_q7(
+ const q7_t * pSrc,
+ uint32_t blockSize,
+ q7_t * pResult,
+ uint32_t * pIndex);
+
+/**
+ * @brief Maximum value of absolute values of a Q7 vector.
+ * @param[in] pSrc points to the input buffer
+ * @param[in] blockSize length of the input vector
+ * @param[out] pResult maximum value returned here
+ */
+ void arm_absmax_no_idx_q7(
+ const q7_t * pSrc,
+ uint32_t blockSize,
+ q7_t * pResult);
+
+
+/**
+ * @brief Maximum value of a Q15 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_q15(
+ const q15_t * pSrc,
+ uint32_t blockSize,
+ q15_t * pResult,
+ uint32_t * pIndex);
+
+/**
+ * @brief Maximum value of absolute values of a Q15 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_absmax_q15(
+ const q15_t * pSrc,
+ uint32_t blockSize,
+ q15_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Maximum value of absolute values of a Q15 vector.
+ * @param[in] pSrc points to the input buffer
+ * @param[in] blockSize length of the input vector
+ * @param[out] pResult maximum value returned here
+ */
+ void arm_absmax_no_idx_q15(
+ const q15_t * pSrc,
+ uint32_t blockSize,
+ q15_t * pResult);
+
+/**
+ * @brief Maximum value of a Q31 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_q31(
+ const q31_t * pSrc,
+ uint32_t blockSize,
+ q31_t * pResult,
+ uint32_t * pIndex);
+
+/**
+ * @brief Maximum value of absolute values of a Q31 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_absmax_q31(
+ const q31_t * pSrc,
+ uint32_t blockSize,
+ q31_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Maximum value of absolute values of a Q31 vector.
+ * @param[in] pSrc points to the input buffer
+ * @param[in] blockSize length of the input vector
+ * @param[out] pResult maximum value returned here
+ */
+ void arm_absmax_no_idx_q31(
+ const q31_t * pSrc,
+ uint32_t blockSize,
+ q31_t * pResult);
+
+/**
+ * @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_f32(
+ const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_t * pResult,
+ uint32_t * pIndex);
+
+/**
+ * @brief Maximum value of absolute values 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_absmax_f32(
+ const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Maximum value of absolute values 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
+ */
+ void arm_absmax_no_idx_f32(
+ const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_t * pResult);
+
+/**
+ * @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_f64(
+ const float64_t * pSrc,
+ uint32_t blockSize,
+ float64_t * pResult,
+ uint32_t * pIndex);
+
+/**
+ * @brief Maximum value of absolute values 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_absmax_f64(
+ const float64_t * pSrc,
+ uint32_t blockSize,
+ float64_t * pResult,
+ uint32_t * pIndex);
+
+/**
+ * @brief Maximum value of absolute values 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
+ */
+ void arm_absmax_no_idx_f64(
+ const float64_t * pSrc,
+ uint32_t blockSize,
+ float64_t * pResult);
+
+ /**
+ @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
+ */
+ void arm_max_no_idx_f32(
+ const float32_t *pSrc,
+ uint32_t blockSize,
+ float32_t *pResult);
+
+ /**
+ @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
+ */
+ void arm_min_no_idx_f32(
+ const float32_t *pSrc,
+ uint32_t blockSize,
+ float32_t *pResult);
+
+ /**
+ @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
+ */
+ void arm_max_no_idx_f64(
+ const float64_t *pSrc,
+ uint32_t blockSize,
+ float64_t *pResult);
+
+ /**
+ @brief Maximum value of a q31 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
+ */
+ void arm_max_no_idx_q31(
+ const q31_t *pSrc,
+ uint32_t blockSize,
+ q31_t *pResult);
+
+ /**
+ @brief Maximum value of a q15 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
+ */
+ void arm_max_no_idx_q15(
+ const q15_t *pSrc,
+ uint32_t blockSize,
+ q15_t *pResult);
+
+ /**
+ @brief Maximum value of a q7 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
+ */
+ void arm_max_no_idx_q7(
+ const q7_t *pSrc,
+ uint32_t blockSize,
+ q7_t *pResult);
+
+ /**
+ @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
+ */
+ void arm_min_no_idx_f64(
+ const float64_t *pSrc,
+ uint32_t blockSize,
+ float64_t *pResult);
+
+/**
+ @brief Minimum value of a q31 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
+ */
+ void arm_min_no_idx_q31(
+ const q31_t *pSrc,
+ uint32_t blockSize,
+ q31_t *pResult);
+
+ /**
+ @brief Minimum value of a q15 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
+ */
+ void arm_min_no_idx_q15(
+ const q15_t *pSrc,
+ uint32_t blockSize,
+ q15_t *pResult);
+
+ /**
+ @brief Minimum value of a q7 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
+ */
+void arm_min_no_idx_q7(
+ const q7_t *pSrc,
+ uint32_t blockSize,
+ q7_t *pResult);
+
+/**
+ @brief Mean square error between two Q7 vectors.
+ @param[in] pSrcA points to the first input vector
+ @param[in] pSrcB points to the second input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult mean square error
+*/
+
+void arm_mse_q7(
+ const q7_t * pSrcA,
+ const q7_t * pSrcB,
+ uint32_t blockSize,
+ q7_t * pResult);
+
+/**
+ @brief Mean square error between two Q15 vectors.
+ @param[in] pSrcA points to the first input vector
+ @param[in] pSrcB points to the second input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult mean square error
+*/
+
+void arm_mse_q15(
+ const q15_t * pSrcA,
+ const q15_t * pSrcB,
+ uint32_t blockSize,
+ q15_t * pResult);
+
+/**
+ @brief Mean square error between two Q31 vectors.
+ @param[in] pSrcA points to the first input vector
+ @param[in] pSrcB points to the second input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult mean square error
+*/
+
+void arm_mse_q31(
+ const q31_t * pSrcA,
+ const q31_t * pSrcB,
+ uint32_t blockSize,
+ q31_t * pResult);
+
+/**
+ @brief Mean square error between two single precision float vectors.
+ @param[in] pSrcA points to the first input vector
+ @param[in] pSrcB points to the second input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult mean square error
+*/
+
+void arm_mse_f32(
+ const float32_t * pSrcA,
+ const float32_t * pSrcB,
+ uint32_t blockSize,
+ float32_t * pResult);
+
+/**
+ @brief Mean square error between two double precision float vectors.
+ @param[in] pSrcA points to the first input vector
+ @param[in] pSrcB points to the second input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult mean square error
+*/
+
+void arm_mse_f64(
+ const float64_t * pSrcA,
+ const float64_t * pSrcB,
+ uint32_t blockSize,
+ float64_t * pResult);
+
+
+/**
+ * @brief Accumulation 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_accumulate_f32(
+const float32_t * pSrc,
+ uint32_t blockSize,
+ float32_t * pResult);
+
+/**
+ * @brief Accumulation 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_accumulate_f64(
+const float64_t * pSrc,
+ uint32_t blockSize,
+ float64_t * pResult);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _STATISTICS_FUNCTIONS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/statistics_functions_f16.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/statistics_functions_f16.h
new file mode 100755
index 0000000..746e8df
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/statistics_functions_f16.h
@@ -0,0 +1,274 @@
+/******************************************************************************
+ * @file statistics_functions_f16.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.1
+ * @date 14 July 2022
+ * 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.
+ */
+
+
+#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 Minimum value of absolute values 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_absmin_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);
+
+/**
+ * @brief Maximum value of absolute values 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_absmax_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult,
+ uint32_t * pIndex);
+
+ /**
+ * @brief Minimum value of absolute values 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
+ */
+ void arm_absmin_no_idx_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult);
+
+/**
+ * @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
+ */
+ void arm_absmax_no_idx_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult);
+
+
+/**
+ * @brief Entropy
+ *
+ * @param[in] pSrcA Array of input values.
+ * @param[in] blockSize Number of samples in the input array.
+ * @return Entropy -Sum(p ln p)
+ */
+float16_t arm_entropy_f16(const float16_t * pSrcA,uint32_t blockSize);
+
+
+float16_t arm_logsumexp_f16(const float16_t *in, uint32_t blockSize);
+
+
+/**
+ * @brief Dot product with log arithmetic
+ *
+ * Vectors are containing the log of the samples
+ *
+ * @param[in] pSrcA points to the first input vector
+ * @param[in] pSrcB points to the second input vector
+ * @param[in] blockSize number of samples in each vector
+ * @param[in] pTmpBuffer temporary buffer of length blockSize
+ * @return The log of the dot product .
+ */
+float16_t arm_logsumexp_dot_prod_f16(const float16_t * pSrcA,
+ const float16_t * pSrcB,
+ uint32_t blockSize,
+ float16_t *pTmpBuffer);
+
+
+/**
+ * @brief Kullback-Leibler
+ *
+ * @param[in] pSrcA Pointer to an array of input values for probability distribution A.
+ * @param[in] pSrcB Pointer to an array of input values for probability distribution B.
+ * @param[in] blockSize Number of samples in the input array.
+ * @return Kullback-Leibler Divergence D(A || B)
+ */
+float16_t arm_kullback_leibler_f16(const float16_t * pSrcA
+ ,const float16_t * pSrcB
+ ,uint32_t blockSize);
+
+
+/**
+ @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
+ */
+ void arm_max_no_idx_f16(
+ const float16_t *pSrc,
+ uint32_t blockSize,
+ float16_t *pResult);
+
+
+/**
+ @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
+ */
+ void arm_min_no_idx_f16(
+ const float16_t *pSrc,
+ uint32_t blockSize,
+ float16_t *pResult);
+
+
+/**
+ @brief Mean square error between two half precision float vectors.
+ @param[in] pSrcA points to the first input vector
+ @param[in] pSrcB points to the second input vector
+ @param[in] blockSize number of samples in input vector
+ @param[out] pResult mean square error
+*/
+void arm_mse_f16(
+ const float16_t * pSrcA,
+ const float16_t * pSrcB,
+ uint32_t blockSize,
+ float16_t * pResult);
+
+
+/**
+ * @brief Sum 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_accumulate_f16(
+ const float16_t * pSrc,
+ uint32_t blockSize,
+ float16_t * pResult);
+
+
+#endif /*defined(ARM_FLOAT16_SUPPORTED)*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _STATISTICS_FUNCTIONS_F16_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/support_functions.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/support_functions.h
new file mode 100755
index 0000000..1f3ce8c
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/support_functions.h
@@ -0,0 +1,539 @@
+/******************************************************************************
+ * @file support_functions.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.1
+ * @date 18 August 2022
+ * 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.
+ */
+
+
+#ifndef SUPPORT_FUNCTIONS_H_
+#define SUPPORT_FUNCTIONS_H_
+
+#include "arm_math_types.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * @defgroup groupSupport Support Functions
+ */
+
+
+/**
+ * @brief Converts the elements of the 64 bit floating-point vector to floating-point vector.
+ * @param[in] pSrc points to the floating-point 64 input vector
+ * @param[out] pDst points to the floating-point output vector
+ * @param[in] blockSize length of the input vector
+ */
+ void arm_f64_to_float(
+ const float64_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+/**
+ * @brief Converts the elements of the 64 bit floating-point vector to Q31 vector.
+ * @param[in] pSrc points to the floating-point 64 input vector
+ * @param[out] pDst points to the Q31 output vector
+ * @param[in] blockSize length of the input vector
+ */
+ void arm_f64_to_q31(
+ const float64_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+/**
+ * @brief Converts the elements of the 64 bit floating-point vector to Q15 vector.
+ * @param[in] pSrc points to the floating-point 64 input vector
+ * @param[out] pDst points to the Q15 output vector
+ * @param[in] blockSize length of the input vector
+ */
+ void arm_f64_to_q15(
+ const float64_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+/**
+ * @brief Converts the elements of the 64 bit floating-point vector to Q7 vector.
+ * @param[in] pSrc points to the floating-point 64 input vector
+ * @param[out] pDst points to the Q7 output vector
+ * @param[in] blockSize length of the input vector
+ */
+ void arm_f64_to_q7(
+ const float64_t * pSrc,
+ q7_t * pDst,
+ uint32_t blockSize);
+
+
+
+/**
+ * @brief Converts the elements of the floating-point vector to 64 bit floating-point vector.
+ * @param[in] pSrc points to the floating-point input vector
+ * @param[out] pDst points to the 64 bit floating-point output vector
+ * @param[in] blockSize length of the input vector
+ */
+ void arm_float_to_f64(
+ const float32_t * pSrc,
+ float64_t * pDst,
+ uint32_t blockSize);
+
+/**
+ * @brief Converts the elements of the floating-point vector to Q31 vector.
+ * @param[in] pSrc points to the floating-point input vector
+ * @param[out] pDst points to the Q31 output vector
+ * @param[in] blockSize length of the input vector
+ */
+ void arm_float_to_q31(
+ const float32_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Converts the elements of the floating-point vector to Q15 vector.
+ * @param[in] pSrc points to the floating-point input vector
+ * @param[out] pDst points to the Q15 output vector
+ * @param[in] blockSize length of the input vector
+ */
+ void arm_float_to_q15(
+ const float32_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Converts the elements of the floating-point vector to Q7 vector.
+ * @param[in] pSrc points to the floating-point input vector
+ * @param[out] pDst points to the Q7 output vector
+ * @param[in] blockSize length of the input vector
+ */
+ void arm_float_to_q7(
+ const float32_t * pSrc,
+ q7_t * pDst,
+ uint32_t blockSize);
+
+/**
+ * @brief Converts the elements of the Q31 vector to 64 bit floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[out] pDst is output pointer
+ * @param[in] blockSize is the number of samples to process
+ */
+void arm_q31_to_f64(
+const q31_t * pSrc,
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Converts the elements of the Q31 vector to floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[out] pDst is output pointer
+ * @param[in] blockSize is the number of samples to process
+ */
+ void arm_q31_to_float(
+ const q31_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Converts the elements of the Q31 vector to Q15 vector.
+ * @param[in] pSrc is input pointer
+ * @param[out] pDst is output pointer
+ * @param[in] blockSize is the number of samples to process
+ */
+ void arm_q31_to_q15(
+ const q31_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Converts the elements of the Q31 vector to Q7 vector.
+ * @param[in] pSrc is input pointer
+ * @param[out] pDst is output pointer
+ * @param[in] blockSize is the number of samples to process
+ */
+ void arm_q31_to_q7(
+ const q31_t * pSrc,
+ q7_t * pDst,
+ uint32_t blockSize);
+
+/**
+ * @brief Converts the elements of the Q15 vector to 64 bit floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[out] pDst is output pointer
+ * @param[in] blockSize is the number of samples to process
+ */
+void arm_q15_to_f64(
+const q15_t * pSrc,
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Converts the elements of the Q15 vector to floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[out] pDst is output pointer
+ * @param[in] blockSize is the number of samples to process
+ */
+ void arm_q15_to_float(
+ const q15_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Converts the elements of the Q15 vector to Q31 vector.
+ * @param[in] pSrc is input pointer
+ * @param[out] pDst is output pointer
+ * @param[in] blockSize is the number of samples to process
+ */
+ void arm_q15_to_q31(
+ const q15_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Converts the elements of the Q15 vector to Q7 vector.
+ * @param[in] pSrc is input pointer
+ * @param[out] pDst is output pointer
+ * @param[in] blockSize is the number of samples to process
+ */
+ void arm_q15_to_q7(
+ const q15_t * pSrc,
+ q7_t * pDst,
+ uint32_t blockSize);
+
+/**
+ * @brief Converts the elements of the Q7 vector to 64 bit floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[out] pDst is output pointer
+ * @param[in] blockSize is the number of samples to process
+ */
+void arm_q7_to_f64(
+const q7_t * pSrc,
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Converts the elements of the Q7 vector to floating-point vector.
+ * @param[in] pSrc is input pointer
+ * @param[out] pDst is output pointer
+ * @param[in] blockSize is the number of samples to process
+ */
+ void arm_q7_to_float(
+ const q7_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Converts the elements of the Q7 vector to Q31 vector.
+ * @param[in] pSrc input pointer
+ * @param[out] pDst output pointer
+ * @param[in] blockSize number of samples to process
+ */
+ void arm_q7_to_q31(
+ const q7_t * pSrc,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Converts the elements of the Q7 vector to Q15 vector.
+ * @param[in] pSrc input pointer
+ * @param[out] pDst output pointer
+ * @param[in] blockSize number of samples to process
+ */
+ void arm_q7_to_q15(
+ const q7_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+
+
+
+
+ /**
+ * @brief Struct for specifying sorting algorithm
+ */
+ typedef enum
+ {
+ ARM_SORT_BITONIC = 0,
+ /**< Bitonic sort */
+ ARM_SORT_BUBBLE = 1,
+ /**< Bubble sort */
+ ARM_SORT_HEAP = 2,
+ /**< Heap sort */
+ ARM_SORT_INSERTION = 3,
+ /**< Insertion sort */
+ ARM_SORT_QUICK = 4,
+ /**< Quick sort */
+ ARM_SORT_SELECTION = 5
+ /**< Selection sort */
+ } arm_sort_alg;
+
+ /**
+ * @brief Struct for specifying sorting algorithm
+ */
+ typedef enum
+ {
+ ARM_SORT_DESCENDING = 0,
+ /**< Descending order (9 to 0) */
+ ARM_SORT_ASCENDING = 1
+ /**< Ascending order (0 to 9) */
+ } arm_sort_dir;
+
+ /**
+ * @brief Instance structure for the sorting algorithms.
+ */
+ typedef struct
+ {
+ arm_sort_alg alg; /**< Sorting algorithm selected */
+ arm_sort_dir dir; /**< Sorting order (direction) */
+ } arm_sort_instance_f32;
+
+ /**
+ * @param[in] S points to an instance of the sorting structure.
+ * @param[in] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data.
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_sort_f32(
+ const arm_sort_instance_f32 * S,
+ float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @param[in,out] S points to an instance of the sorting structure.
+ * @param[in] alg Selected algorithm.
+ * @param[in] dir Sorting order.
+ */
+ void arm_sort_init_f32(
+ arm_sort_instance_f32 * S,
+ arm_sort_alg alg,
+ arm_sort_dir dir);
+
+ /**
+ * @brief Instance structure for the sorting algorithms.
+ */
+ typedef struct
+ {
+ arm_sort_dir dir; /**< Sorting order (direction) */
+ float32_t * buffer; /**< Working buffer */
+ } arm_merge_sort_instance_f32;
+
+ /**
+ * @param[in] S points to an instance of the sorting structure.
+ * @param[in,out] pSrc points to the block of input data.
+ * @param[out] pDst points to the block of output data
+ * @param[in] blockSize number of samples to process.
+ */
+ void arm_merge_sort_f32(
+ const arm_merge_sort_instance_f32 * S,
+ float32_t *pSrc,
+ float32_t *pDst,
+ uint32_t blockSize);
+
+ /**
+ * @param[in,out] S points to an instance of the sorting structure.
+ * @param[in] dir Sorting order.
+ * @param[in] buffer Working buffer.
+ */
+ void arm_merge_sort_init_f32(
+ arm_merge_sort_instance_f32 * S,
+ arm_sort_dir dir,
+ float32_t * buffer);
+
+
+
+ /**
+ * @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_f32(
+ const float32_t * pSrc,
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+
+ /**
+ * @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_f64(
+ const float64_t * pSrc,
+ float64_t * pDst,
+ uint32_t blockSize);
+
+
+
+ /**
+ * @brief Copies the elements of a Q7 vector.
+ * @param[in] pSrc input pointer
+ * @param[out] pDst output pointer
+ * @param[in] blockSize number of samples to process
+ */
+ void arm_copy_q7(
+ const q7_t * pSrc,
+ q7_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Copies the elements of a Q15 vector.
+ * @param[in] pSrc input pointer
+ * @param[out] pDst output pointer
+ * @param[in] blockSize number of samples to process
+ */
+ void arm_copy_q15(
+ const q15_t * pSrc,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Copies the elements of a Q31 vector.
+ * @param[in] pSrc input pointer
+ * @param[out] pDst output pointer
+ * @param[in] blockSize number of samples to process
+ */
+ void arm_copy_q31(
+ const q31_t * pSrc,
+ q31_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_f32(
+ float32_t value,
+ float32_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_f64(
+ float64_t value,
+ float64_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Fills a constant value into a Q7 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_q7(
+ q7_t value,
+ q7_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Fills a constant value into a Q15 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_q15(
+ q15_t value,
+ q15_t * pDst,
+ uint32_t blockSize);
+
+
+ /**
+ * @brief Fills a constant value into a Q31 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_q31(
+ q31_t value,
+ q31_t * pDst,
+ uint32_t blockSize);
+
+
+
+
+
+
+
+/**
+ * @brief Weighted average
+ *
+ *
+ * @param[in] *in Array of input values.
+ * @param[in] *weights Weights
+ * @param[in] blockSize Number of samples in the input array.
+ * @return Weighted average
+ *
+ */
+float32_t arm_weighted_average_f32(const float32_t *in
+ , const float32_t *weights
+ , 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)
+ *
+ */
+void arm_barycenter_f32(const float32_t *in
+ , const float32_t *weights
+ , float32_t *out
+ , uint32_t nbVectors
+ , uint32_t vecDim);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _SUPPORT_FUNCTIONS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/support_functions_f16.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/support_functions_f16.h
new file mode 100755
index 0000000..4786e59
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/support_functions_f16.h
@@ -0,0 +1,204 @@
+/******************************************************************************
+ * @file support_functions_f16.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.1
+ * @date 18 August 2022
+ * 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.
+ */
+
+
+#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 64 bit floating-point vector to 16 bit floating-point vector.
+ * @param[in] pSrc points to the f64 input vector
+ * @param[out] pDst points to the f16 output vector
+ * @param[in] blockSize length of the input vector
+ */
+void arm_f64_to_f16(const float64_t * pSrc, float16_t * pDst, uint32_t blockSize);
+
+
+/**
+ * @brief Converts the elements of the 16 bit floating-point vector to 64 bit floating-point vector.
+ * @param[in] pSrc points to the f16 input vector
+ * @param[out] pDst points to the f64 output vector
+ * @param[in] blockSize length of the input vector
+ */
+void arm_f16_to_f64(const float16_t * pSrc, float64_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 average
+ * @param[in] *in Array of input values.
+ * @param[in] *weights Weights
+ * @param[in] blockSize Number of samples in the input array.
+ * @return Weighted average
+ */
+float16_t arm_weighted_average_f16(const float16_t *in
+ , const float16_t *weights
+ , 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)
+ */
+void arm_barycenter_f16(const float16_t *in
+ , const float16_t *weights
+ , float16_t *out
+ , uint32_t nbVectors
+ , uint32_t vecDim);
+
+
+/**
+ @ingroup groupSupport
+ */
+
+/**
+ * @defgroup typecast Typecasting
+ */
+
+/**
+ @addtogroup typecast
+ @{
+ */
+
+/**
+ * @brief Interpret a f16 as an s16 value
+ * @param[in] x input value.
+ * @return return value.
+ *
+ * @par Description
+ * It is a typecast. No conversion of the float to int is done.
+ * The memcpy will be optimized out by the compiler.
+ * memcpy is used to prevent type punning issues.
+ * With gcc, -fno-builtins MUST not be used or the
+ * memcpy will not be optimized out.
+ */
+__STATIC_INLINE int16_t arm_typecast_s16_f16(float16_t x)
+{
+ int16_t res;
+ res=*(int16_t*)memcpy((char*)&res,(char*)&x,sizeof(float16_t));
+ return(res);
+}
+
+/**
+ * @brief Interpret an s16 as an f16 value
+ * @param[in] x input value.
+ * @return return value.
+ *
+ * @par Description
+ * It is a typecast. No conversion of the int to float is done.
+ * The memcpy will be optimized out by the compiler.
+ * memcpy is used to prevent type punning issues.
+ * With gcc, -fno-builtins MUST not be used or the
+ * memcpy will not be optimized out.
+ */
+__STATIC_INLINE float16_t arm_typecast_f16_s16(int16_t x)
+{
+ float16_t res;
+ res=*(float16_t*)memcpy((char*)&res,(char*)&x,sizeof(int16_t));
+ return(res);
+}
+
+
+/**
+ @} end of typecast group
+ */
+
+
+#endif /*defined(ARM_FLOAT16_SUPPORTED)*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _SUPPORT_FUNCTIONS_F16_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/svm_defines.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/svm_defines.h
new file mode 100755
index 0000000..185a8a9
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/svm_defines.h
@@ -0,0 +1,46 @@
+/******************************************************************************
+ * @file svm_defines.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ *
+ * 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.
+ */
+
+
+#ifndef SVM_DEFINES_H_
+#define SVM_DEFINES_H_
+
+/**
+ * @brief Struct for specifying SVM Kernel
+ */
+typedef enum
+{
+ ARM_ML_KERNEL_LINEAR = 0,
+ /**< Linear kernel */
+ ARM_ML_KERNEL_POLYNOMIAL = 1,
+ /**< Polynomial kernel */
+ ARM_ML_KERNEL_RBF = 2,
+ /**< Radial Basis Function kernel */
+ ARM_ML_KERNEL_SIGMOID = 3
+ /**< Sigmoid kernel */
+} arm_ml_kernel_type;
+
+#endif
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/svm_functions.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/svm_functions.h
new file mode 100755
index 0000000..cb00cd4
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/svm_functions.h
@@ -0,0 +1,280 @@
+/******************************************************************************
+ * @file svm_functions.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ * 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.
+ */
+
+
+#ifndef SVM_FUNCTIONS_H_
+#define SVM_FUNCTIONS_H_
+
+#include "arm_math_types.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+#include "dsp/svm_defines.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#define STEP(x) (x) <= 0 ? 0 : 1
+
+/**
+ * @defgroup groupSVM SVM Functions
+ * This set of functions is implementing SVM classification on 2 classes.
+ * The training must be done from scikit-learn. The parameters can be easily
+ * generated from the scikit-learn object. Some examples are given in
+ * DSP/Testing/PatternGeneration/SVM.py
+ *
+ * If more than 2 classes are needed, the functions in this folder
+ * will have to be used, as building blocks, to do multi-class classification.
+ *
+ * No multi-class classification is provided in this SVM folder.
+ *
+ */
+
+/**
+ * @brief Integer exponentiation
+ * @param[in] x value
+ * @param[in] nb integer exponent >= 1
+ * @return x^nb
+ */
+__STATIC_INLINE float32_t arm_exponent_f32(float32_t x, int32_t nb)
+{
+ float32_t r = x;
+ nb --;
+ while(nb > 0)
+ {
+ r = r * x;
+ nb--;
+ }
+ return(r);
+}
+
+
+/**
+ * @brief Instance structure for linear SVM prediction function.
+ */
+typedef struct
+{
+ uint32_t nbOfSupportVectors; /**< Number of support vectors */
+ uint32_t vectorDimension; /**< Dimension of vector space */
+ float32_t intercept; /**< Intercept */
+ const float32_t *dualCoefficients; /**< Dual coefficients */
+ const float32_t *supportVectors; /**< Support vectors */
+ const int32_t *classes; /**< The two SVM classes */
+} arm_svm_linear_instance_f32;
+
+
+/**
+ * @brief Instance structure for polynomial SVM prediction function.
+ */
+typedef struct
+{
+ uint32_t nbOfSupportVectors; /**< Number of support vectors */
+ uint32_t vectorDimension; /**< Dimension of vector space */
+ float32_t intercept; /**< Intercept */
+ const float32_t *dualCoefficients; /**< Dual coefficients */
+ const float32_t *supportVectors; /**< Support vectors */
+ const int32_t *classes; /**< The two SVM classes */
+ int32_t degree; /**< Polynomial degree */
+ float32_t coef0; /**< Polynomial constant */
+ float32_t gamma; /**< Gamma factor */
+} arm_svm_polynomial_instance_f32;
+
+
+/**
+ * @brief Instance structure for rbf SVM prediction function.
+ */
+typedef struct
+{
+ uint32_t nbOfSupportVectors; /**< Number of support vectors */
+ uint32_t vectorDimension; /**< Dimension of vector space */
+ float32_t intercept; /**< Intercept */
+ const float32_t *dualCoefficients; /**< Dual coefficients */
+ const float32_t *supportVectors; /**< Support vectors */
+ const int32_t *classes; /**< The two SVM classes */
+ float32_t gamma; /**< Gamma factor */
+} arm_svm_rbf_instance_f32;
+
+
+/**
+ * @brief Instance structure for sigmoid SVM prediction function.
+ */
+typedef struct
+{
+ uint32_t nbOfSupportVectors; /**< Number of support vectors */
+ uint32_t vectorDimension; /**< Dimension of vector space */
+ float32_t intercept; /**< Intercept */
+ const float32_t *dualCoefficients; /**< Dual coefficients */
+ const float32_t *supportVectors; /**< Support vectors */
+ const int32_t *classes; /**< The two SVM classes */
+ float32_t coef0; /**< Independent constant */
+ float32_t gamma; /**< Gamma factor */
+} arm_svm_sigmoid_instance_f32;
+
+
+/**
+ * @brief SVM linear instance init function
+ * @param[in] S Parameters for SVM functions
+ * @param[in] nbOfSupportVectors Number of support vectors
+ * @param[in] vectorDimension Dimension of vector space
+ * @param[in] intercept Intercept
+ * @param[in] dualCoefficients Array of dual coefficients
+ * @param[in] supportVectors Array of support vectors
+ * @param[in] classes Array of 2 classes ID
+ */
+void arm_svm_linear_init_f32(arm_svm_linear_instance_f32 *S,
+ uint32_t nbOfSupportVectors,
+ uint32_t vectorDimension,
+ float32_t intercept,
+ const float32_t *dualCoefficients,
+ const float32_t *supportVectors,
+ const int32_t *classes);
+
+
+/**
+ * @brief SVM linear prediction
+ * @param[in] S Pointer to an instance of the linear SVM structure.
+ * @param[in] in Pointer to input vector
+ * @param[out] pResult Decision value
+ */
+void arm_svm_linear_predict_f32(const arm_svm_linear_instance_f32 *S,
+ const float32_t * in,
+ int32_t * pResult);
+
+
+/**
+ * @brief SVM polynomial instance init function
+ * @param[in] S points to an instance of the polynomial SVM structure.
+ * @param[in] nbOfSupportVectors Number of support vectors
+ * @param[in] vectorDimension Dimension of vector space
+ * @param[in] intercept Intercept
+ * @param[in] dualCoefficients Array of dual coefficients
+ * @param[in] supportVectors Array of support vectors
+ * @param[in] classes Array of 2 classes ID
+ * @param[in] degree Polynomial degree
+ * @param[in] coef0 coeff0 (scikit-learn terminology)
+ * @param[in] gamma gamma (scikit-learn terminology)
+ */
+void arm_svm_polynomial_init_f32(arm_svm_polynomial_instance_f32 *S,
+ uint32_t nbOfSupportVectors,
+ uint32_t vectorDimension,
+ float32_t intercept,
+ const float32_t *dualCoefficients,
+ const float32_t *supportVectors,
+ const int32_t *classes,
+ int32_t degree,
+ float32_t coef0,
+ float32_t gamma
+ );
+
+
+/**
+ * @brief SVM polynomial prediction
+ * @param[in] S Pointer to an instance of the polynomial SVM structure.
+ * @param[in] in Pointer to input vector
+ * @param[out] pResult Decision value
+ */
+void arm_svm_polynomial_predict_f32(const arm_svm_polynomial_instance_f32 *S,
+ const float32_t * in,
+ int32_t * pResult);
+
+
+/**
+ * @brief SVM radial basis function instance init function
+ * @param[in] S points to an instance of the polynomial SVM structure.
+ * @param[in] nbOfSupportVectors Number of support vectors
+ * @param[in] vectorDimension Dimension of vector space
+ * @param[in] intercept Intercept
+ * @param[in] dualCoefficients Array of dual coefficients
+ * @param[in] supportVectors Array of support vectors
+ * @param[in] classes Array of 2 classes ID
+ * @param[in] gamma gamma (scikit-learn terminology)
+ */
+void arm_svm_rbf_init_f32(arm_svm_rbf_instance_f32 *S,
+ uint32_t nbOfSupportVectors,
+ uint32_t vectorDimension,
+ float32_t intercept,
+ const float32_t *dualCoefficients,
+ const float32_t *supportVectors,
+ const int32_t *classes,
+ float32_t gamma
+ );
+
+
+/**
+ * @brief SVM rbf prediction
+ * @param[in] S Pointer to an instance of the rbf SVM structure.
+ * @param[in] in Pointer to input vector
+ * @param[out] pResult decision value
+ */
+void arm_svm_rbf_predict_f32(const arm_svm_rbf_instance_f32 *S,
+ const float32_t * in,
+ int32_t * pResult);
+
+
+/**
+ * @brief SVM sigmoid instance init function
+ * @param[in] S points to an instance of the rbf SVM structure.
+ * @param[in] nbOfSupportVectors Number of support vectors
+ * @param[in] vectorDimension Dimension of vector space
+ * @param[in] intercept Intercept
+ * @param[in] dualCoefficients Array of dual coefficients
+ * @param[in] supportVectors Array of support vectors
+ * @param[in] classes Array of 2 classes ID
+ * @param[in] coef0 coeff0 (scikit-learn terminology)
+ * @param[in] gamma gamma (scikit-learn terminology)
+ */
+void arm_svm_sigmoid_init_f32(arm_svm_sigmoid_instance_f32 *S,
+ uint32_t nbOfSupportVectors,
+ uint32_t vectorDimension,
+ float32_t intercept,
+ const float32_t *dualCoefficients,
+ const float32_t *supportVectors,
+ const int32_t *classes,
+ float32_t coef0,
+ float32_t gamma
+ );
+
+
+/**
+ * @brief SVM sigmoid prediction
+ * @param[in] S Pointer to an instance of the rbf SVM structure.
+ * @param[in] in Pointer to input vector
+ * @param[out] pResult Decision value
+ */
+void arm_svm_sigmoid_predict_f32(const arm_svm_sigmoid_instance_f32 *S,
+ const float32_t * in,
+ int32_t * pResult);
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _SVM_FUNCTIONS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/svm_functions_f16.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/svm_functions_f16.h
new file mode 100755
index 0000000..5f757a0
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/svm_functions_f16.h
@@ -0,0 +1,265 @@
+/******************************************************************************
+ * @file svm_functions_f16.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ * 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.
+ */
+
+
+#ifndef SVM_FUNCTIONS_F16_H_
+#define SVM_FUNCTIONS_F16_H_
+
+#include "arm_math_types_f16.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+#include "dsp/svm_defines.h"
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+#define STEP(x) (x) <= 0 ? 0 : 1
+
+/**
+ * @defgroup groupSVM SVM Functions
+ * This set of functions is implementing SVM classification on 2 classes.
+ * The training must be done from scikit-learn. The parameters can be easily
+ * generated from the scikit-learn object. Some examples are given in
+ * DSP/Testing/PatternGeneration/SVM.py
+ *
+ * If more than 2 classes are needed, the functions in this folder
+ * will have to be used, as building blocks, to do multi-class classification.
+ *
+ * No multi-class classification is provided in this SVM folder.
+ *
+ */
+
+
+
+/**
+ * @brief Instance structure for linear SVM prediction function.
+ */
+typedef struct
+{
+ uint32_t nbOfSupportVectors; /**< Number of support vectors */
+ uint32_t vectorDimension; /**< Dimension of vector space */
+ float16_t intercept; /**< Intercept */
+ const float16_t *dualCoefficients; /**< Dual coefficients */
+ const float16_t *supportVectors; /**< Support vectors */
+ const int32_t *classes; /**< The two SVM classes */
+} arm_svm_linear_instance_f16;
+
+
+/**
+ * @brief Instance structure for polynomial SVM prediction function.
+ */
+typedef struct
+{
+ uint32_t nbOfSupportVectors; /**< Number of support vectors */
+ uint32_t vectorDimension; /**< Dimension of vector space */
+ float16_t intercept; /**< Intercept */
+ const float16_t *dualCoefficients; /**< Dual coefficients */
+ const float16_t *supportVectors; /**< Support vectors */
+ const int32_t *classes; /**< The two SVM classes */
+ int32_t degree; /**< Polynomial degree */
+ float16_t coef0; /**< Polynomial constant */
+ float16_t gamma; /**< Gamma factor */
+} arm_svm_polynomial_instance_f16;
+
+
+/**
+ * @brief Instance structure for rbf SVM prediction function.
+ */
+typedef struct
+{
+ uint32_t nbOfSupportVectors; /**< Number of support vectors */
+ uint32_t vectorDimension; /**< Dimension of vector space */
+ float16_t intercept; /**< Intercept */
+ const float16_t *dualCoefficients; /**< Dual coefficients */
+ const float16_t *supportVectors; /**< Support vectors */
+ const int32_t *classes; /**< The two SVM classes */
+ float16_t gamma; /**< Gamma factor */
+} arm_svm_rbf_instance_f16;
+
+
+/**
+ * @brief Instance structure for sigmoid SVM prediction function.
+ */
+typedef struct
+{
+ uint32_t nbOfSupportVectors; /**< Number of support vectors */
+ uint32_t vectorDimension; /**< Dimension of vector space */
+ float16_t intercept; /**< Intercept */
+ const float16_t *dualCoefficients; /**< Dual coefficients */
+ const float16_t *supportVectors; /**< Support vectors */
+ const int32_t *classes; /**< The two SVM classes */
+ float16_t coef0; /**< Independent constant */
+ float16_t gamma; /**< Gamma factor */
+} arm_svm_sigmoid_instance_f16;
+
+
+/**
+ * @brief SVM linear instance init function
+ * @param[in] S Parameters for SVM functions
+ * @param[in] nbOfSupportVectors Number of support vectors
+ * @param[in] vectorDimension Dimension of vector space
+ * @param[in] intercept Intercept
+ * @param[in] dualCoefficients Array of dual coefficients
+ * @param[in] supportVectors Array of support vectors
+ * @param[in] classes Array of 2 classes ID
+ */
+void arm_svm_linear_init_f16(arm_svm_linear_instance_f16 *S,
+ uint32_t nbOfSupportVectors,
+ uint32_t vectorDimension,
+ float16_t intercept,
+ const float16_t *dualCoefficients,
+ const float16_t *supportVectors,
+ const int32_t *classes);
+
+/**
+ * @brief SVM linear prediction
+ * @param[in] S Pointer to an instance of the linear SVM structure.
+ * @param[in] in Pointer to input vector
+ * @param[out] pResult Decision value
+ */
+void arm_svm_linear_predict_f16(const arm_svm_linear_instance_f16 *S,
+ const float16_t * in,
+ int32_t * pResult);
+
+
+/**
+ * @brief SVM polynomial instance init function
+ * @param[in] S points to an instance of the polynomial SVM structure.
+ * @param[in] nbOfSupportVectors Number of support vectors
+ * @param[in] vectorDimension Dimension of vector space
+ * @param[in] intercept Intercept
+ * @param[in] dualCoefficients Array of dual coefficients
+ * @param[in] supportVectors Array of support vectors
+ * @param[in] classes Array of 2 classes ID
+ * @param[in] degree Polynomial degree
+ * @param[in] coef0 coeff0 (scikit-learn terminology)
+ * @param[in] gamma gamma (scikit-learn terminology)
+ */
+void arm_svm_polynomial_init_f16(arm_svm_polynomial_instance_f16 *S,
+ uint32_t nbOfSupportVectors,
+ uint32_t vectorDimension,
+ float16_t intercept,
+ const float16_t *dualCoefficients,
+ const float16_t *supportVectors,
+ const int32_t *classes,
+ int32_t degree,
+ float16_t coef0,
+ float16_t gamma
+ );
+
+
+/**
+ * @brief SVM polynomial prediction
+ * @param[in] S Pointer to an instance of the polynomial SVM structure.
+ * @param[in] in Pointer to input vector
+ * @param[out] pResult Decision value
+ */
+void arm_svm_polynomial_predict_f16(const arm_svm_polynomial_instance_f16 *S,
+ const float16_t * in,
+ int32_t * pResult);
+
+
+/**
+ * @brief SVM radial basis function instance init function
+ * @param[in] S points to an instance of the polynomial SVM structure.
+ * @param[in] nbOfSupportVectors Number of support vectors
+ * @param[in] vectorDimension Dimension of vector space
+ * @param[in] intercept Intercept
+ * @param[in] dualCoefficients Array of dual coefficients
+ * @param[in] supportVectors Array of support vectors
+ * @param[in] classes Array of 2 classes ID
+ * @param[in] gamma gamma (scikit-learn terminology)
+ */
+void arm_svm_rbf_init_f16(arm_svm_rbf_instance_f16 *S,
+ uint32_t nbOfSupportVectors,
+ uint32_t vectorDimension,
+ float16_t intercept,
+ const float16_t *dualCoefficients,
+ const float16_t *supportVectors,
+ const int32_t *classes,
+ float16_t gamma
+ );
+
+
+/**
+ * @brief SVM rbf prediction
+ * @param[in] S Pointer to an instance of the rbf SVM structure.
+ * @param[in] in Pointer to input vector
+ * @param[out] pResult decision value
+ */
+void arm_svm_rbf_predict_f16(const arm_svm_rbf_instance_f16 *S,
+ const float16_t * in,
+ int32_t * pResult);
+
+
+/**
+ * @brief SVM sigmoid instance init function
+ * @param[in] S points to an instance of the rbf SVM structure.
+ * @param[in] nbOfSupportVectors Number of support vectors
+ * @param[in] vectorDimension Dimension of vector space
+ * @param[in] intercept Intercept
+ * @param[in] dualCoefficients Array of dual coefficients
+ * @param[in] supportVectors Array of support vectors
+ * @param[in] classes Array of 2 classes ID
+ * @param[in] coef0 coeff0 (scikit-learn terminology)
+ * @param[in] gamma gamma (scikit-learn terminology)
+ */
+void arm_svm_sigmoid_init_f16(arm_svm_sigmoid_instance_f16 *S,
+ uint32_t nbOfSupportVectors,
+ uint32_t vectorDimension,
+ float16_t intercept,
+ const float16_t *dualCoefficients,
+ const float16_t *supportVectors,
+ const int32_t *classes,
+ float16_t coef0,
+ float16_t gamma
+ );
+
+
+/**
+ * @brief SVM sigmoid prediction
+ * @param[in] S Pointer to an instance of the rbf SVM structure.
+ * @param[in] in Pointer to input vector
+ * @param[out] pResult Decision value
+ */
+void arm_svm_sigmoid_predict_f16(const arm_svm_sigmoid_instance_f16 *S,
+ const float16_t * in,
+ int32_t * pResult);
+
+
+
+#endif /*defined(ARM_FLOAT16_SUPPORTED)*/
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _SVM_FUNCTIONS_F16_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/transform_functions.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/transform_functions.h
new file mode 100755
index 0000000..27094e5
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/transform_functions.h
@@ -0,0 +1,1408 @@
+/******************************************************************************
+ * @file transform_functions.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ * 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.
+ */
+
+
+#ifndef TRANSFORM_FUNCTIONS_H_
+#define TRANSFORM_FUNCTIONS_H_
+
+#include "arm_math_types.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+#include "dsp/basic_math_functions.h"
+#include "dsp/complex_math_functions.h"
+
+// Only available for Neon versions of the FFTs
+// otherwise only powers of 2 are supported
+
+#if !defined(ARM_MIXED_RADIX_FFT)
+#define ARM_MIXED_RADIX_FFT 1
+#endif
+
+#if !defined(ARM_MATH_NEON)
+#if defined(ARM_MFCC_CFFT_BASED)
+#if !defined(ARM_MFCC_USE_CFFT)
+#define ARM_MFCC_USE_CFFT
+#endif
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+/**
+ * @defgroup groupTransforms Transform Functions
+ *
+ * CMSIS-DSP provides CFFT and RFFT for different architectures.
+ * The implementation of those transforms may be different for the
+ * different architectures : different algorithms, different capabilities
+ * of the instruction set.
+ *
+ * All those variants are not giving exactly the same results but they
+ * are passing the same tests with same SNR checks and same threshold for
+ * the sample errors.
+ *
+ * The APIs for the Neon variants are different : some additional
+ * temporary buffers are required.
+ *
+ * Float16 versions are provided but they are not very accurate and
+ * should only be used for small FFTs.
+ *
+ * @par Transform initializations
+ *
+ * There are several ways to initialize the transform functions.
+ * Below explanations are using q15 as example but the same explanations
+ * apply to other datatypes.
+ *
+ * Before Helium and Neon, you can just use a pre-initialized
+ * constant data structure and use it in the arm_cfft_... function.
+ * For instance, &arm_cfft_sR_q15_len256 for a 256 Q15 CFFT.
+ *
+ * On Helium and Neon, you *must* use an initialization function. If you know the size of your FFT (or other transform) you can use a specific initialization function for this size only : like arm_cfft_init_256_q15 for a 256 Q15 complex FFT.
+ *
+ * By using a specific initialization function, you give an hint to the linker and it will be able to remove all unused initialization tables (some compilation and link flags must be used for the linker to be able to do this optimization. It is compiler dependent).
+ *
+ * If you don't know the size you'll need at runtime, you need to use a function like arm_cfft_init_q15. If you use such a function, all the tables for all FFT sizes (up to the CMSIS-DSP maximum of 4096) will be included in the build !
+ *
+ * On Neon, there is another possibility. You can use arm_cfft_init_dynamic_q15. This function will allocate a buffer at runtime and compute at runtime all the tables that are required for a specific FFT size. This initialization is also supported by RFFT.
+ * The computation to initialize all the tables can take lot of cycles
+ * (since several cos and sin must be computed)
+ *
+ * With this new Neon specific initialization you can use longer lengths.
+ * With CFFT, you can also use lengths containing radix 3 and/or 5 (but
+ * the length must still be a multiple of 4).
+ *
+ * @par Size of buffers according to the target architecture and datatype:
+ * They are described on the page \ref transformbuffers "transform buffers".
+ */
+
+
+ /**
+ * @brief Instance structure for the Q15 CFFT/CIFFT function.
+ */
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+ uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+ const q15_t *pTwiddle; /**< points to the Sin twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+ uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+ } arm_cfft_radix2_instance_q15;
+
+/* Deprecated */
+ arm_status arm_cfft_radix2_init_q15(
+ arm_cfft_radix2_instance_q15 * S,
+ uint16_t fftLen,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+
+/* Deprecated */
+ void arm_cfft_radix2_q15(
+ const arm_cfft_radix2_instance_q15 * S,
+ q15_t * pSrc);
+
+
+ /**
+ * @brief Instance structure for the Q15 CFFT/CIFFT function.
+ */
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+ uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+ const q15_t *pTwiddle; /**< points to the twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+ uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+ } arm_cfft_radix4_instance_q15;
+
+/* Deprecated */
+ arm_status arm_cfft_radix4_init_q15(
+ arm_cfft_radix4_instance_q15 * S,
+ uint16_t fftLen,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+
+/* Deprecated */
+ void arm_cfft_radix4_q15(
+ const arm_cfft_radix4_instance_q15 * S,
+ q15_t * pSrc);
+
+ /**
+ * @brief Instance structure for the Radix-2 Q31 CFFT/CIFFT function.
+ */
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+ uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+ const q31_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+ uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+ } arm_cfft_radix2_instance_q31;
+
+/* Deprecated */
+ arm_status arm_cfft_radix2_init_q31(
+ arm_cfft_radix2_instance_q31 * S,
+ uint16_t fftLen,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+
+/* Deprecated */
+ void arm_cfft_radix2_q31(
+ const arm_cfft_radix2_instance_q31 * S,
+ q31_t * pSrc);
+
+ /**
+ * @brief Instance structure for the Q31 CFFT/CIFFT function.
+ */
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+ uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+ const q31_t *pTwiddle; /**< points to the twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+ uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+ } arm_cfft_radix4_instance_q31;
+
+/* Deprecated */
+ void arm_cfft_radix4_q31(
+ const arm_cfft_radix4_instance_q31 * S,
+ q31_t * pSrc);
+
+/* Deprecated */
+ arm_status arm_cfft_radix4_init_q31(
+ arm_cfft_radix4_instance_q31 * S,
+ uint16_t fftLen,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+
+ /**
+ * @brief Instance structure for the floating-point CFFT/CIFFT function.
+ */
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+ uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+ const float32_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+ uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+ float32_t onebyfftLen; /**< value of 1/fftLen. */
+ } arm_cfft_radix2_instance_f32;
+
+
+/* Deprecated */
+ arm_status arm_cfft_radix2_init_f32(
+ arm_cfft_radix2_instance_f32 * S,
+ uint16_t fftLen,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+
+/* Deprecated */
+ void arm_cfft_radix2_f32(
+ const arm_cfft_radix2_instance_f32 * S,
+ float32_t * pSrc);
+
+ /**
+ * @brief Instance structure for the floating-point CFFT/CIFFT function.
+ */
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+ uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+ const float32_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+ uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+ float32_t onebyfftLen; /**< value of 1/fftLen. */
+ } arm_cfft_radix4_instance_f32;
+
+
+
+/* Deprecated */
+ arm_status arm_cfft_radix4_init_f32(
+ arm_cfft_radix4_instance_f32 * S,
+ uint16_t fftLen,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+
+/* Deprecated */
+ void arm_cfft_radix4_f32(
+ const arm_cfft_radix4_instance_f32 * S,
+ float32_t * pSrc);
+
+ /**
+ * @brief Instance structure for the fixed-point CFFT/CIFFT function.
+ */
+#if defined(ARM_MATH_NEON)
+typedef struct
+{
+ uint32_t fftLen; /**< length of the FFT. */
+ const q15_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const q15_t *last_twiddles; /**< last stage twiddle used for mixed radix */
+ const uint32_t *factors;
+ int32_t algorithm_flag;
+} arm_cfft_instance_q15;
+#else
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ const q15_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t bitRevLength; /**< bit reversal table length. */
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+ const uint32_t *rearranged_twiddle_tab_stride1_arr; /**< Per stage reordered twiddle pointer (offset 1) */ \
+ const uint32_t *rearranged_twiddle_tab_stride2_arr; /**< Per stage reordered twiddle pointer (offset 2) */ \
+ const uint32_t *rearranged_twiddle_tab_stride3_arr; /**< Per stage reordered twiddle pointer (offset 3) */ \
+ const q15_t *rearranged_twiddle_stride1; /**< reordered twiddle offset 1 storage */ \
+ const q15_t *rearranged_twiddle_stride2; /**< reordered twiddle offset 2 storage */ \
+ const q15_t *rearranged_twiddle_stride3;
+#endif
+ } arm_cfft_instance_q15;
+#endif
+
+arm_status arm_cfft_init_4096_q15(arm_cfft_instance_q15 * S);
+arm_status arm_cfft_init_2048_q15(arm_cfft_instance_q15 * S);
+arm_status arm_cfft_init_1024_q15(arm_cfft_instance_q15 * S);
+arm_status arm_cfft_init_512_q15(arm_cfft_instance_q15 * S);
+arm_status arm_cfft_init_256_q15(arm_cfft_instance_q15 * S);
+arm_status arm_cfft_init_128_q15(arm_cfft_instance_q15 * S);
+arm_status arm_cfft_init_64_q15(arm_cfft_instance_q15 * S);
+arm_status arm_cfft_init_32_q15(arm_cfft_instance_q15 * S);
+arm_status arm_cfft_init_16_q15(arm_cfft_instance_q15 * S);
+
+arm_status arm_cfft_init_q15(
+ arm_cfft_instance_q15 * S,
+ uint16_t fftLen);
+
+
+
+#if defined(ARM_MATH_NEON)
+
+extern arm_cfft_instance_q15 *arm_cfft_init_dynamic_q15(uint32_t fftLen);
+
+void arm_cfft_q15(
+ const arm_cfft_instance_q15 * S,
+ const q15_t * src,
+ q15_t * dst,
+ q15_t * buffer,
+ uint8_t ifftFlag
+ );
+#else
+void arm_cfft_q15(
+ const arm_cfft_instance_q15 * S,
+ q15_t * p1,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+#endif
+
+ /**
+ * @brief Instance structure for the fixed-point CFFT/CIFFT function.
+ */
+#if defined(ARM_MATH_NEON)
+typedef struct
+{
+ uint32_t fftLen; /**< length of the FFT. */
+ const q31_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const q31_t *last_twiddles; /**< last stage twiddle used for mixed radix */
+ const uint32_t *factors;
+ int32_t algorithm_flag;
+} arm_cfft_instance_q31;
+#else
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ const q31_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t bitRevLength; /**< bit reversal table length. */
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+ const uint32_t *rearranged_twiddle_tab_stride1_arr; /**< Per stage reordered twiddle pointer (offset 1) */ \
+ const uint32_t *rearranged_twiddle_tab_stride2_arr; /**< Per stage reordered twiddle pointer (offset 2) */ \
+ const uint32_t *rearranged_twiddle_tab_stride3_arr; /**< Per stage reordered twiddle pointer (offset 3) */ \
+ const q31_t *rearranged_twiddle_stride1; /**< reordered twiddle offset 1 storage */ \
+ const q31_t *rearranged_twiddle_stride2; /**< reordered twiddle offset 2 storage */ \
+ const q31_t *rearranged_twiddle_stride3;
+#endif
+ } arm_cfft_instance_q31;
+#endif
+
+arm_status arm_cfft_init_4096_q31(arm_cfft_instance_q31 * S);
+arm_status arm_cfft_init_2048_q31(arm_cfft_instance_q31 * S);
+arm_status arm_cfft_init_1024_q31(arm_cfft_instance_q31 * S);
+arm_status arm_cfft_init_512_q31(arm_cfft_instance_q31 * S);
+arm_status arm_cfft_init_256_q31(arm_cfft_instance_q31 * S);
+arm_status arm_cfft_init_128_q31(arm_cfft_instance_q31 * S);
+arm_status arm_cfft_init_64_q31(arm_cfft_instance_q31 * S);
+arm_status arm_cfft_init_32_q31(arm_cfft_instance_q31 * S);
+arm_status arm_cfft_init_16_q31(arm_cfft_instance_q31 * S);
+
+arm_status arm_cfft_init_q31(
+ arm_cfft_instance_q31 * S,
+ uint16_t fftLen);
+
+#if defined(ARM_MATH_NEON)
+
+extern arm_cfft_instance_q31 *arm_cfft_init_dynamic_q31(uint32_t fftLen);
+
+void arm_cfft_q31(
+ const arm_cfft_instance_q31 * S,
+ const q31_t * src,
+ q31_t * dst,
+ q31_t * buffer,
+ uint8_t ifftFlag
+ );
+#else
+void arm_cfft_q31(
+ const arm_cfft_instance_q31 * S,
+ q31_t * p1,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+#endif
+
+#if defined(ARM_MATH_NEON)
+typedef struct
+{
+ uint32_t fftLen; /**< length of the FFT. */
+ const float32_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const float32_t *last_twiddles; /**< last stage twiddle used for mixed radix */
+ const uint32_t *factors;
+ int32_t algorithm_flag;
+} arm_cfft_instance_f32;
+#else
+ /**
+ * @brief Instance structure for the floating-point CFFT/CIFFT function.
+ */
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ const float32_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t bitRevLength; /**< bit reversal table length. */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+ const uint32_t *rearranged_twiddle_tab_stride1_arr; /**< Per stage reordered twiddle pointer (offset 1) */ \
+ const uint32_t *rearranged_twiddle_tab_stride2_arr; /**< Per stage reordered twiddle pointer (offset 2) */ \
+ const uint32_t *rearranged_twiddle_tab_stride3_arr; /**< Per stage reordered twiddle pointer (offset 3) */ \
+ const float32_t *rearranged_twiddle_stride1; /**< reordered twiddle offset 1 storage */ \
+ const float32_t *rearranged_twiddle_stride2; /**< reordered twiddle offset 2 storage */ \
+ const float32_t *rearranged_twiddle_stride3;
+#endif
+ } arm_cfft_instance_f32;
+#endif
+
+
+arm_status arm_cfft_init_4096_f32(arm_cfft_instance_f32 * S);
+arm_status arm_cfft_init_2048_f32(arm_cfft_instance_f32 * S);
+arm_status arm_cfft_init_1024_f32(arm_cfft_instance_f32 * S);
+arm_status arm_cfft_init_512_f32(arm_cfft_instance_f32 * S);
+arm_status arm_cfft_init_256_f32(arm_cfft_instance_f32 * S);
+arm_status arm_cfft_init_128_f32(arm_cfft_instance_f32 * S);
+arm_status arm_cfft_init_64_f32(arm_cfft_instance_f32 * S);
+arm_status arm_cfft_init_32_f32(arm_cfft_instance_f32 * S);
+arm_status arm_cfft_init_16_f32(arm_cfft_instance_f32 * S);
+
+ arm_status arm_cfft_init_f32(
+ arm_cfft_instance_f32 * S,
+ uint16_t fftLen);
+
+#if defined(ARM_MATH_NEON)
+
+extern arm_cfft_instance_f32 *arm_cfft_init_dynamic_f32(uint32_t fftLen);
+
+/* `pIn` content is modified by the function.
+ `pIn` array must be different from `pOut` one
+*/
+void arm_cfft_f32(
+ const arm_cfft_instance_f32 * S,
+ const float32_t * pIn,
+ float32_t * pOut,
+ float32_t * pBuffer, /* When used, `in` is not modified */
+ uint8_t ifftFlag);
+#else
+ void arm_cfft_f32(
+ const arm_cfft_instance_f32 * S,
+ float32_t * p1,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+#endif
+
+
+ /**
+ * @brief Instance structure for the Double Precision Floating-point CFFT/CIFFT function.
+ */
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ const float64_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t bitRevLength; /**< bit reversal table length. */
+ } arm_cfft_instance_f64;
+
+arm_status arm_cfft_init_4096_f64(arm_cfft_instance_f64 * S);
+arm_status arm_cfft_init_2048_f64(arm_cfft_instance_f64 * S);
+arm_status arm_cfft_init_1024_f64(arm_cfft_instance_f64 * S);
+arm_status arm_cfft_init_512_f64(arm_cfft_instance_f64 * S);
+arm_status arm_cfft_init_256_f64(arm_cfft_instance_f64 * S);
+arm_status arm_cfft_init_128_f64(arm_cfft_instance_f64 * S);
+arm_status arm_cfft_init_64_f64(arm_cfft_instance_f64 * S);
+arm_status arm_cfft_init_32_f64(arm_cfft_instance_f64 * S);
+arm_status arm_cfft_init_16_f64(arm_cfft_instance_f64 * S);
+
+ arm_status arm_cfft_init_f64(
+ arm_cfft_instance_f64 * S,
+ uint16_t fftLen);
+
+ void arm_cfft_f64(
+ const arm_cfft_instance_f64 * S,
+ float64_t * p1,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+
+ /**
+ * @brief Instance structure for the Q15 RFFT/RIFFT function.
+ */
+#if defined(ARM_MATH_NEON)
+ typedef struct
+ {
+ uint32_t nfft;
+ uint32_t ncfft;
+ const uint32_t *factors;
+ const q15_t *twiddles;
+ const q15_t *super_twiddles;
+ } arm_rfft_instance_q15;
+#else
+ typedef struct
+ {
+ uint32_t fftLenReal; /**< length of the real FFT. */
+ uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */
+ uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */
+ uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+ const q15_t *pTwiddleAReal; /**< points to the real twiddle factor table. */
+ const q15_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+ arm_cfft_instance_q15 cfftInst;
+#else
+ const arm_cfft_instance_q15 *pCfft; /**< points to the complex FFT instance. */
+#endif
+ } arm_rfft_instance_q15;
+#endif
+
+#if defined(ARM_MATH_NEON)
+
+extern arm_rfft_instance_q15 *arm_rfft_init_dynamic_q15(uint32_t fftLenReal);
+
+arm_status arm_rfft_init_32_q15(
+ arm_rfft_instance_q15 * S);
+
+arm_status arm_rfft_init_64_q15(
+ arm_rfft_instance_q15 * S);
+
+arm_status arm_rfft_init_128_q15(
+ arm_rfft_instance_q15 * S);
+
+arm_status arm_rfft_init_256_q15(
+ arm_rfft_instance_q15 * S);
+
+arm_status arm_rfft_init_512_q15(
+ arm_rfft_instance_q15 * S);
+
+arm_status arm_rfft_init_1024_q15(
+ arm_rfft_instance_q15 * S);
+
+arm_status arm_rfft_init_2048_q15(
+ arm_rfft_instance_q15 * S);
+
+arm_status arm_rfft_init_4096_q15(
+ arm_rfft_instance_q15 * S);
+
+arm_status arm_rfft_init_8192_q15(
+ arm_rfft_instance_q15 * S);
+
+ arm_status arm_rfft_init_q15(
+ arm_rfft_instance_q15 * S,
+ uint32_t fftLenReal);
+
+void arm_rfft_q15(
+ const arm_rfft_instance_q15 * S,
+ const q15_t * pSrc,
+ q15_t * pDst,
+ q15_t * tmp,
+ uint8_t ifftFlag);
+#else
+arm_status arm_rfft_init_32_q15(
+ arm_rfft_instance_q15 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+arm_status arm_rfft_init_64_q15(
+ arm_rfft_instance_q15 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+arm_status arm_rfft_init_128_q15(
+ arm_rfft_instance_q15 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+arm_status arm_rfft_init_256_q15(
+ arm_rfft_instance_q15 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+arm_status arm_rfft_init_512_q15(
+ arm_rfft_instance_q15 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+arm_status arm_rfft_init_1024_q15(
+ arm_rfft_instance_q15 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+arm_status arm_rfft_init_2048_q15(
+ arm_rfft_instance_q15 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+arm_status arm_rfft_init_4096_q15(
+ arm_rfft_instance_q15 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+arm_status arm_rfft_init_8192_q15(
+ arm_rfft_instance_q15 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ arm_status arm_rfft_init_q15(
+ arm_rfft_instance_q15 * S,
+ uint32_t fftLenReal,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ void arm_rfft_q15(
+ const arm_rfft_instance_q15 * S,
+ q15_t * pSrc,
+ q15_t * pDst);
+#endif
+
+ /**
+ * @brief Instance structure for the Q31 RFFT/RIFFT function.
+ */
+#if defined(ARM_MATH_NEON)
+ typedef struct
+ {
+ uint32_t nfft;
+ uint32_t ncfft;
+ const uint32_t *factors;
+ const q31_t *twiddles;
+ const q31_t *super_twiddles;
+ } arm_rfft_instance_q31;
+#else
+ typedef struct
+ {
+ uint32_t fftLenReal; /**< length of the real FFT. */
+ uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */
+ uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */
+ uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+ const q31_t *pTwiddleAReal; /**< points to the real twiddle factor table. */
+ const q31_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+ arm_cfft_instance_q31 cfftInst;
+#else
+ const arm_cfft_instance_q31 *pCfft; /**< points to the complex FFT instance. */
+#endif
+ } arm_rfft_instance_q31;
+#endif
+
+
+#if defined(ARM_MATH_NEON)
+
+extern arm_rfft_instance_q31 *arm_rfft_init_dynamic_q31(uint32_t fftLenReal);
+
+ arm_status arm_rfft_init_32_q31(
+ arm_rfft_instance_q31 * S);
+
+ arm_status arm_rfft_init_64_q31(
+ arm_rfft_instance_q31 * S);
+
+ arm_status arm_rfft_init_128_q31(
+ arm_rfft_instance_q31 * S);
+
+ arm_status arm_rfft_init_256_q31(
+ arm_rfft_instance_q31 * S);
+
+ arm_status arm_rfft_init_512_q31(
+ arm_rfft_instance_q31 * S);
+
+ arm_status arm_rfft_init_1024_q31(
+ arm_rfft_instance_q31 * S);
+
+ arm_status arm_rfft_init_2048_q31(
+ arm_rfft_instance_q31 * S);
+
+ arm_status arm_rfft_init_4096_q31(
+ arm_rfft_instance_q31 * S);
+
+ arm_status arm_rfft_init_8192_q31(
+ arm_rfft_instance_q31 * S);
+
+ arm_status arm_rfft_init_q31(
+ arm_rfft_instance_q31 * S,
+ uint32_t fftLenReal);
+
+ void arm_rfft_q31(
+ const arm_rfft_instance_q31 * S,
+ const q31_t * pSrc,
+ q31_t * pDst,
+ q31_t * tmp,
+ uint8_t ifftFlag);
+#else
+ arm_status arm_rfft_init_32_q31(
+ arm_rfft_instance_q31 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ arm_status arm_rfft_init_64_q31(
+ arm_rfft_instance_q31 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ arm_status arm_rfft_init_128_q31(
+ arm_rfft_instance_q31 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ arm_status arm_rfft_init_256_q31(
+ arm_rfft_instance_q31 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ arm_status arm_rfft_init_512_q31(
+ arm_rfft_instance_q31 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ arm_status arm_rfft_init_1024_q31(
+ arm_rfft_instance_q31 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ arm_status arm_rfft_init_2048_q31(
+ arm_rfft_instance_q31 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ arm_status arm_rfft_init_4096_q31(
+ arm_rfft_instance_q31 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ arm_status arm_rfft_init_8192_q31(
+ arm_rfft_instance_q31 * S,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ arm_status arm_rfft_init_q31(
+ arm_rfft_instance_q31 * S,
+ uint32_t fftLenReal,
+ uint32_t ifftFlagR,
+ uint32_t bitReverseFlag);
+
+ void arm_rfft_q31(
+ const arm_rfft_instance_q31 * S,
+ q31_t * pSrc,
+ q31_t * pDst);
+#endif
+
+ /**
+ * @brief Instance structure for the floating-point RFFT/RIFFT function.
+ */
+ typedef struct
+ {
+ uint32_t fftLenReal; /**< length of the real FFT. */
+ uint16_t fftLenBy2; /**< length of the complex FFT. */
+ uint8_t ifftFlagR; /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */
+ uint8_t bitReverseFlagR; /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */
+ uint32_t twidCoefRModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+ const float32_t *pTwiddleAReal; /**< points to the real twiddle factor table. */
+ const float32_t *pTwiddleBReal; /**< points to the imag twiddle factor table. */
+ arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */
+ } arm_rfft_instance_f32;
+
+ /**
+ * @brief Instance structure for the Double Precision Floating-point RFFT/RIFFT function.
+ */
+typedef struct
+ {
+ arm_cfft_instance_f64 Sint; /**< Internal CFFT structure. */
+ uint16_t fftLenRFFT; /**< length of the real sequence */
+ const float64_t * pTwiddleRFFT; /**< Twiddle factors real stage */
+ } arm_rfft_fast_instance_f64 ;
+
+arm_status arm_rfft_fast_init_32_f64( arm_rfft_fast_instance_f64 * S );
+arm_status arm_rfft_fast_init_64_f64( arm_rfft_fast_instance_f64 * S );
+arm_status arm_rfft_fast_init_128_f64( arm_rfft_fast_instance_f64 * S );
+arm_status arm_rfft_fast_init_256_f64( arm_rfft_fast_instance_f64 * S );
+arm_status arm_rfft_fast_init_512_f64( arm_rfft_fast_instance_f64 * S );
+arm_status arm_rfft_fast_init_1024_f64( arm_rfft_fast_instance_f64 * S );
+arm_status arm_rfft_fast_init_2048_f64( arm_rfft_fast_instance_f64 * S );
+arm_status arm_rfft_fast_init_4096_f64( arm_rfft_fast_instance_f64 * S );
+
+arm_status arm_rfft_fast_init_f64 (
+ arm_rfft_fast_instance_f64 * S,
+ uint16_t fftLen);
+
+
+void arm_rfft_fast_f64(
+ arm_rfft_fast_instance_f64 * S,
+ float64_t * p, float64_t * pOut,
+ uint8_t ifftFlag);
+
+
+ /**
+ * @brief Instance structure for the floating-point RFFT/RIFFT function.
+ */
+#if defined(ARM_MATH_NEON)
+ typedef struct
+ {
+ uint32_t nfft;
+ const float32_t *r_twiddles;
+ const uint32_t *r_factors;
+ const float32_t *r_twiddles_backward;
+ const float32_t *r_twiddles_neon;
+ const float32_t *r_twiddles_neon_backward;
+ const uint32_t *r_factors_neon;
+ const float32_t *r_super_twiddles_neon;
+ } arm_rfft_fast_instance_f32 ;
+#else
+typedef struct
+ {
+ arm_cfft_instance_f32 Sint; /**< Internal CFFT structure. */
+ uint16_t fftLenRFFT; /**< length of the real sequence */
+ const float32_t * pTwiddleRFFT; /**< Twiddle factors real stage */
+ } arm_rfft_fast_instance_f32 ;
+#endif
+
+arm_status arm_rfft_fast_init_32_f32( arm_rfft_fast_instance_f32 * S );
+arm_status arm_rfft_fast_init_64_f32( arm_rfft_fast_instance_f32 * S );
+arm_status arm_rfft_fast_init_128_f32( arm_rfft_fast_instance_f32 * S );
+arm_status arm_rfft_fast_init_256_f32( arm_rfft_fast_instance_f32 * S );
+arm_status arm_rfft_fast_init_512_f32( arm_rfft_fast_instance_f32 * S );
+arm_status arm_rfft_fast_init_1024_f32( arm_rfft_fast_instance_f32 * S );
+arm_status arm_rfft_fast_init_2048_f32( arm_rfft_fast_instance_f32 * S );
+arm_status arm_rfft_fast_init_4096_f32( arm_rfft_fast_instance_f32 * S );
+
+
+arm_status arm_rfft_fast_init_f32 (
+ arm_rfft_fast_instance_f32 * S,
+ uint16_t fftLen);
+
+#if defined(ARM_MATH_NEON)
+
+extern arm_rfft_fast_instance_f32 *arm_rfft_fast_init_dynamic_f32 (uint32_t fftLen);
+
+void arm_rfft_fast_f32(
+ const arm_rfft_fast_instance_f32 * S,
+ const float32_t * p,
+ float32_t * pOut,
+ float32_t *tmpbuf,
+ uint8_t ifftFlag);
+#else
+ void arm_rfft_fast_f32(
+ const arm_rfft_fast_instance_f32 * S,
+ float32_t * p, float32_t * pOut,
+ uint8_t ifftFlag);
+#endif
+
+
+ /**
+ * @brief Instance structure for the Floating-point MFCC function.
+ */
+typedef struct
+ {
+ const float32_t *dctCoefs; /**< Internal DCT coefficients */
+ const float32_t *filterCoefs; /**< Internal Mel filter coefficients */
+ const float32_t *windowCoefs; /**< Windowing coefficients */
+ const uint32_t *filterPos; /**< Internal Mel filter positions in spectrum */
+ const uint32_t *filterLengths; /**< Internal Mel filter lengths */
+ uint32_t fftLen; /**< FFT length */
+ uint32_t nbMelFilters; /**< Number of Mel filters */
+ uint32_t nbDctOutputs; /**< Number of DCT outputs */
+#if defined(ARM_MFCC_USE_CFFT)
+ /* Implementation of the MFCC is using a CFFT */
+ arm_cfft_instance_f32 cfft; /**< Internal CFFT instance */
+#else
+ /* Implementation of the MFCC is using a RFFT (default) */
+ arm_rfft_fast_instance_f32 rfft;
+#endif
+ } arm_mfcc_instance_f32 ;
+
+arm_status arm_mfcc_init_32_f32(
+ arm_mfcc_instance_f32 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float32_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float32_t *filterCoefs,
+ const float32_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_64_f32(
+ arm_mfcc_instance_f32 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float32_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float32_t *filterCoefs,
+ const float32_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_128_f32(
+ arm_mfcc_instance_f32 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float32_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float32_t *filterCoefs,
+ const float32_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_256_f32(
+ arm_mfcc_instance_f32 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float32_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float32_t *filterCoefs,
+ const float32_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_512_f32(
+ arm_mfcc_instance_f32 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float32_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float32_t *filterCoefs,
+ const float32_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_1024_f32(
+ arm_mfcc_instance_f32 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float32_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float32_t *filterCoefs,
+ const float32_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_2048_f32(
+ arm_mfcc_instance_f32 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float32_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float32_t *filterCoefs,
+ const float32_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_4096_f32(
+ arm_mfcc_instance_f32 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float32_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float32_t *filterCoefs,
+ const float32_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_f32(
+ arm_mfcc_instance_f32 * S,
+ uint32_t fftLen,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float32_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float32_t *filterCoefs,
+ const float32_t *windowCoefs
+ );
+
+
+/**
+ @brief MFCC F32
+ @param[in] S points to the mfcc instance structure
+ @param[in] pSrc points to the input samples
+ @param[out] pDst points to the output MFCC values
+ @param[inout] pTmp points to a temporary buffer of complex
+ */
+#if defined(ARM_MATH_NEON)
+void arm_mfcc_f32(
+ const arm_mfcc_instance_f32 * S,
+ float32_t *pSrc,
+ float32_t *pDst,
+ float32_t *pTmp,
+ float32_t *pTmp2
+ );
+#else
+ void arm_mfcc_f32(
+ const arm_mfcc_instance_f32 * S,
+ float32_t *pSrc,
+ float32_t *pDst,
+ float32_t *pTmp
+ );
+#endif
+
+ /**
+ * @brief Instance structure for the Q31 MFCC function.
+ */
+typedef struct
+ {
+ const q31_t *dctCoefs; /**< Internal DCT coefficients */
+ const q31_t *filterCoefs; /**< Internal Mel filter coefficients */
+ const q31_t *windowCoefs; /**< Windowing coefficients */
+ const uint32_t *filterPos; /**< Internal Mel filter positions in spectrum */
+ const uint32_t *filterLengths; /**< Internal Mel filter lengths */
+ uint32_t fftLen; /**< FFT length */
+ uint32_t nbMelFilters; /**< Number of Mel filters */
+ uint32_t nbDctOutputs; /**< Number of DCT outputs */
+#if defined(ARM_MFCC_USE_CFFT)
+ /* Implementation of the MFCC is using a CFFT */
+ arm_cfft_instance_q31 cfft; /**< Internal CFFT instance */
+#else
+ /* Implementation of the MFCC is using a RFFT (default) */
+ arm_rfft_instance_q31 rfft;
+#endif
+ } arm_mfcc_instance_q31 ;
+
+arm_status arm_mfcc_init_32_q31(
+ arm_mfcc_instance_q31 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q31_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q31_t *filterCoefs,
+ const q31_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_64_q31(
+ arm_mfcc_instance_q31 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q31_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q31_t *filterCoefs,
+ const q31_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_128_q31(
+ arm_mfcc_instance_q31 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q31_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q31_t *filterCoefs,
+ const q31_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_256_q31(
+ arm_mfcc_instance_q31 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q31_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q31_t *filterCoefs,
+ const q31_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_512_q31(
+ arm_mfcc_instance_q31 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q31_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q31_t *filterCoefs,
+ const q31_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_1024_q31(
+ arm_mfcc_instance_q31 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q31_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q31_t *filterCoefs,
+ const q31_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_2048_q31(
+ arm_mfcc_instance_q31 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q31_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q31_t *filterCoefs,
+ const q31_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_4096_q31(
+ arm_mfcc_instance_q31 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q31_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q31_t *filterCoefs,
+ const q31_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_q31(
+ arm_mfcc_instance_q31 * S,
+ uint32_t fftLen,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q31_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q31_t *filterCoefs,
+ const q31_t *windowCoefs
+ );
+
+
+/**
+ @brief MFCC Q31
+ @param[in] S points to the mfcc instance structure
+ @param[in] pSrc points to the input samples
+ @param[out] pDst points to the output MFCC values
+ @param[inout] pTmp points to a temporary buffer of complex
+ @return error status
+ */
+#if defined(ARM_MATH_NEON)
+ arm_status arm_mfcc_q31(
+ const arm_mfcc_instance_q31 * S,
+ q31_t *pSrc,
+ q31_t *pDst,
+ q31_t *pTmp,
+ q31_t *pTmp2
+ );
+#else
+ arm_status arm_mfcc_q31(
+ const arm_mfcc_instance_q31 * S,
+ q31_t *pSrc,
+ q31_t *pDst,
+ q31_t *pTmp
+ );
+#endif
+
+ /**
+ * @brief Instance structure for the Q15 MFCC function.
+ */
+typedef struct
+ {
+ const q15_t *dctCoefs; /**< Internal DCT coefficients */
+ const q15_t *filterCoefs; /**< Internal Mel filter coefficients */
+ const q15_t *windowCoefs; /**< Windowing coefficients */
+ const uint32_t *filterPos; /**< Internal Mel filter positions in spectrum */
+ const uint32_t *filterLengths; /**< Internal Mel filter lengths */
+ uint32_t fftLen; /**< FFT length */
+ uint32_t nbMelFilters; /**< Number of Mel filters */
+ uint32_t nbDctOutputs; /**< Number of DCT outputs */
+#if defined(ARM_MFCC_USE_CFFT)
+ /* Implementation of the MFCC is using a CFFT */
+ arm_cfft_instance_q15 cfft; /**< Internal CFFT instance */
+#else
+ /* Implementation of the MFCC is using a RFFT (default) */
+ arm_rfft_instance_q15 rfft;
+#endif
+ } arm_mfcc_instance_q15 ;
+
+arm_status arm_mfcc_init_32_q15(
+ arm_mfcc_instance_q15 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q15_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q15_t *filterCoefs,
+ const q15_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_64_q15(
+ arm_mfcc_instance_q15 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q15_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q15_t *filterCoefs,
+ const q15_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_128_q15(
+ arm_mfcc_instance_q15 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q15_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q15_t *filterCoefs,
+ const q15_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_256_q15(
+ arm_mfcc_instance_q15 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q15_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q15_t *filterCoefs,
+ const q15_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_512_q15(
+ arm_mfcc_instance_q15 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q15_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q15_t *filterCoefs,
+ const q15_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_1024_q15(
+ arm_mfcc_instance_q15 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q15_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q15_t *filterCoefs,
+ const q15_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_2048_q15(
+ arm_mfcc_instance_q15 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q15_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q15_t *filterCoefs,
+ const q15_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_4096_q15(
+ arm_mfcc_instance_q15 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q15_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q15_t *filterCoefs,
+ const q15_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_q15(
+ arm_mfcc_instance_q15 * S,
+ uint32_t fftLen,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const q15_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const q15_t *filterCoefs,
+ const q15_t *windowCoefs
+ );
+
+
+/**
+ @brief MFCC Q15
+ @param[in] S points to the mfcc instance structure
+ @param[in] pSrc points to the input samples
+ @param[out] pDst points to the output MFCC values in q8.7 format
+ @param[inout] pTmp points to a temporary buffer of complex
+ @return error status
+ */
+#if defined(ARM_MATH_NEON)
+ arm_status arm_mfcc_q15(
+ const arm_mfcc_instance_q15 * S,
+ q15_t *pSrc,
+ q15_t *pDst,
+ q31_t *pTmp,
+ q15_t *pTmp2
+ );
+#else
+ arm_status arm_mfcc_q15(
+ const arm_mfcc_instance_q15 * S,
+ q15_t *pSrc,
+ q15_t *pDst,
+ q31_t *pTmp
+ );
+#endif
+
+/**
+ @brief Calculate required length for the temporary buffer
+ @param[in] arch Target architecture identification
+ @param[in] dt Data type of the input data
+ @param[in] nb_samples Number of samples in the input data
+ @param[in] buf_id Identification for the temporary buffer
+ @return Length in datatype elements (real numbers) for the temporary buffer
+
+ @note 0 means not applicable (temporary buffer not needed)
+ @note -1 means error : configuration not supported
+*/
+extern int32_t arm_cfft_tmp_buffer_size(arm_math_target_arch arch,
+ arm_math_datatype dt,
+ uint32_t nb_samples,
+ uint32_t buf_id);
+
+/**
+ @brief Calculate required length for the output buffer
+ @param[in] arch Target architecture identification
+ @param[in] dt Data type of the input data
+ @param[in] nb_samples Number of samples in the input data
+ @return Length in datatype elements (real numbers) for the temporary buffer
+
+ @note 0 means not applicable (temporary buffer not needed)
+ @note -1 means error : configuration not supported
+*/
+extern int32_t arm_cfft_output_buffer_size(arm_math_target_arch arch,
+ arm_math_datatype dt,
+ uint32_t nb_samples);
+
+/**
+ @brief Calculate required length for the output buffer
+ @param[in] arch Target architecture identification
+ @param[in] dt Data type of the input data
+ @param[in] nb_samples Number of samples in the input data
+ @return Length in datatype elements (real numbers) for the temporary buffer
+
+ @note 0 means not applicable (temporary buffer not needed)
+ @note -1 means error : configuration not supported
+*/
+extern int32_t arm_cifft_output_buffer_size(arm_math_target_arch arch,
+ arm_math_datatype dt,
+ uint32_t nb_samples);
+
+/**
+ @brief Calculate required length for the temporary buffer for both RFFT and RIFFT
+ @param[in] arch Target architecture identification
+ @param[in] dt Data type of the input data
+ @param[in] nb_samples Number of samples in the input data
+ @param[in] buf_id Identification for the temporary buffer
+ @return Length in datatype elements (real numbers) for the temporary buffer
+
+ @note 0 means not applicable (temporary buffer not needed)
+ @note -1 means error : configuration not supported
+*/
+extern int32_t arm_rfft_tmp_buffer_size(arm_math_target_arch arch,
+ arm_math_datatype dt,
+ uint32_t nb_samples,
+ uint32_t buf_id);
+
+/**
+ @brief Calculate required length for the output buffer
+ @param[in] arch Target architecture identification
+ @param[in] dt Data type of the input data
+ @param[in] nb_samples Number of samples in the input data
+ @return Length in datatype elements (real numbers) for the output buffer
+
+ @note 0 means not applicable (temporary buffer not needed)
+ @note -1 means error : configuration not supported
+*/
+extern int32_t arm_rfft_output_buffer_size(arm_math_target_arch arch,
+ arm_math_datatype dt,
+ uint32_t nb_samples);
+
+
+/**
+ * @brief Calculate required length for the input buffer
+ * @param[in] arch Target architecture identification
+ * @param[in] dt Data type of the input data
+ * @param[in] nb_samples RFFT length in samples
+ * @param[in] buf_id Identification for the temporary buffer
+ * @return Length in datatype elements (real numbers) for the input buffer
+ *
+ * @note 0 means not applicable (temporary buffer not needed)
+ * @note -1 means error : configuration not supported
+ */
+extern int32_t arm_rifft_input_buffer_size(arm_math_target_arch arch,
+ arm_math_datatype dt,
+ uint32_t nb_samples);
+
+/**
+ @brief Calculate required length for the temporary buffer
+ @param[in] arch Target architecture identification
+ @param[in] dt Data type of the input data
+ @param[in] nb_samples Number of samples in the input data
+ @param[in] buf_id Identification for the temporary buffer
+ @param[in] use_cfft 1 if implementastion uses CFFT, 0 if RFFT
+ @return Length in datatype elements (real numbers) for the temporary buffer
+
+ @note 0 means not applicable (temporary buffer not needed)
+ @note -1 means error : configuration not supported
+*/
+extern int32_t arm_mfcc_tmp_buffer_size(arm_math_target_arch arch,
+ arm_math_datatype dt,
+ uint32_t nb_samples,
+ uint32_t buf_id,
+ uint32_t use_cfft);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _TRANSFORM_FUNCTIONS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/transform_functions_f16.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/transform_functions_f16.h
new file mode 100755
index 0000000..cad9321
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/transform_functions_f16.h
@@ -0,0 +1,383 @@
+/******************************************************************************
+ * @file transform_functions_f16.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.10.0
+ * @date 08 July 2021
+ * 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.
+ */
+
+
+#ifndef TRANSFORM_FUNCTIONS_F16_H_
+#define TRANSFORM_FUNCTIONS_F16_H_
+
+#include "arm_math_types_f16.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+#if !defined(ARM_MIXED_RADIX_FFT)
+#define ARM_MIXED_RADIX_FFT 1
+#endif
+
+#if !defined(ARM_MATH_NEON)
+#if defined(ARM_MFCC_CFFT_BASED)
+#if !defined(ARM_MFCC_USE_CFFT)
+#define ARM_MFCC_USE_CFFT
+#endif
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+
+ /**
+ * @brief Instance structure for the floating-point CFFT/CIFFT function.
+ */
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+ uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+ const float16_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+ uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+ float16_t onebyfftLen; /**< value of 1/fftLen. */
+ } arm_cfft_radix2_instance_f16;
+
+ /**
+ * @brief Instance structure for the floating-point CFFT/CIFFT function.
+ */
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ uint8_t ifftFlag; /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+ uint8_t bitReverseFlag; /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+ const float16_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t twidCoefModifier; /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+ uint16_t bitRevFactor; /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+ float16_t onebyfftLen; /**< value of 1/fftLen. */
+ } arm_cfft_radix4_instance_f16;
+
+ /**
+ * @brief Instance structure for the floating-point CFFT/CIFFT function.
+ */
+#if defined(ARM_MATH_NEON_FLOAT16)
+typedef struct
+{
+ uint32_t fftLen; /**< length of the FFT. */
+ const float16_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const float16_t *last_twiddles; /**< last stage twiddle used for mixed radix */
+ const uint32_t *factors;
+ int32_t algorithm_flag;
+} arm_cfft_instance_f16;
+#else
+ typedef struct
+ {
+ uint16_t fftLen; /**< length of the FFT. */
+ const float16_t *pTwiddle; /**< points to the Twiddle factor table. */
+ const uint16_t *pBitRevTable; /**< points to the bit reversal table. */
+ uint16_t bitRevLength; /**< bit reversal table length. */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+ const uint32_t *rearranged_twiddle_tab_stride1_arr; /**< Per stage reordered twiddle pointer (offset 1) */ \
+ const uint32_t *rearranged_twiddle_tab_stride2_arr; /**< Per stage reordered twiddle pointer (offset 2) */ \
+ const uint32_t *rearranged_twiddle_tab_stride3_arr; /**< Per stage reordered twiddle pointer (offset 3) */ \
+ const float16_t *rearranged_twiddle_stride1; /**< reordered twiddle offset 1 storage */ \
+ const float16_t *rearranged_twiddle_stride2; /**< reordered twiddle offset 2 storage */ \
+ const float16_t *rearranged_twiddle_stride3;
+#endif
+ } arm_cfft_instance_f16;
+#endif
+
+arm_status arm_cfft_init_4096_f16(arm_cfft_instance_f16 * S);
+arm_status arm_cfft_init_2048_f16(arm_cfft_instance_f16 * S);
+arm_status arm_cfft_init_1024_f16(arm_cfft_instance_f16 * S);
+arm_status arm_cfft_init_512_f16(arm_cfft_instance_f16 * S);
+arm_status arm_cfft_init_256_f16(arm_cfft_instance_f16 * S);
+arm_status arm_cfft_init_128_f16(arm_cfft_instance_f16 * S);
+arm_status arm_cfft_init_64_f16(arm_cfft_instance_f16 * S);
+arm_status arm_cfft_init_32_f16(arm_cfft_instance_f16 * S);
+arm_status arm_cfft_init_16_f16(arm_cfft_instance_f16 * S);
+
+
+ arm_status arm_cfft_init_f16(
+ arm_cfft_instance_f16 * S,
+ uint16_t fftLen);
+
+#if defined(ARM_MATH_NEON_FLOAT16)
+
+extern arm_cfft_instance_f16 *arm_cfft_init_dynamic_f16(uint32_t fftLen);
+
+void arm_cfft_f16(
+ const arm_cfft_instance_f16 * S,
+ const float16_t * pIn,
+ float16_t * pOut,
+ float16_t * pBuffer, /* When used, `in` is not modified */
+ uint8_t ifftFlag);
+#else
+ void arm_cfft_f16(
+ const arm_cfft_instance_f16 * S,
+ float16_t * p1,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+#endif
+ /**
+ * @brief Instance structure for the floating-point RFFT/RIFFT function.
+ */
+#if defined(ARM_MATH_NEON_FLOAT16)
+ typedef struct
+ {
+ uint32_t nfft;
+ const float16_t *r_twiddles;
+ const uint32_t *r_factors;
+ const float16_t *r_twiddles_backward;
+ const float16_t *r_twiddles_neon;
+ const float16_t *r_twiddles_neon_backward;
+ const uint32_t *r_factors_neon;
+ const float16_t *r_super_twiddles_neon;
+ } arm_rfft_fast_instance_f16 ;
+#else
+typedef struct
+ {
+ arm_cfft_instance_f16 Sint; /**< Internal CFFT structure. */
+ uint16_t fftLenRFFT; /**< length of the real sequence */
+ const float16_t * pTwiddleRFFT; /**< Twiddle factors real stage */
+ } arm_rfft_fast_instance_f16 ;
+#endif
+
+arm_status arm_rfft_fast_init_32_f16( arm_rfft_fast_instance_f16 * S );
+arm_status arm_rfft_fast_init_64_f16( arm_rfft_fast_instance_f16 * S );
+arm_status arm_rfft_fast_init_128_f16( arm_rfft_fast_instance_f16 * S );
+arm_status arm_rfft_fast_init_256_f16( arm_rfft_fast_instance_f16 * S );
+arm_status arm_rfft_fast_init_512_f16( arm_rfft_fast_instance_f16 * S );
+arm_status arm_rfft_fast_init_1024_f16( arm_rfft_fast_instance_f16 * S );
+arm_status arm_rfft_fast_init_2048_f16( arm_rfft_fast_instance_f16 * S );
+arm_status arm_rfft_fast_init_4096_f16( arm_rfft_fast_instance_f16 * S );
+
+arm_status arm_rfft_fast_init_f16 (
+ arm_rfft_fast_instance_f16 * S,
+ uint16_t fftLen);
+
+#if defined(ARM_MATH_NEON_FLOAT16)
+
+extern arm_rfft_fast_instance_f16 *arm_rfft_fast_init_dynamic_f16 (uint32_t fftLen);
+
+void arm_rfft_fast_f16(
+ const arm_rfft_fast_instance_f16 * S,
+ const float16_t * p,
+ float16_t * pOut,
+ float16_t *tmpbuf,
+ uint8_t ifftFlag);
+#else
+ void arm_rfft_fast_f16(
+ const arm_rfft_fast_instance_f16 * S,
+ float16_t * p, float16_t * pOut,
+ uint8_t ifftFlag);
+#endif
+
+/* Deprecated */
+ arm_status arm_cfft_radix4_init_f16(
+ arm_cfft_radix4_instance_f16 * S,
+ uint16_t fftLen,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+
+/* Deprecated */
+ void arm_cfft_radix4_f16(
+ const arm_cfft_radix4_instance_f16 * S,
+ float16_t * pSrc);
+
+
+/* Deprecated */
+ arm_status arm_cfft_radix2_init_f16(
+ arm_cfft_radix2_instance_f16 * S,
+ uint16_t fftLen,
+ uint8_t ifftFlag,
+ uint8_t bitReverseFlag);
+
+/* Deprecated */
+ void arm_cfft_radix2_f16(
+ const arm_cfft_radix2_instance_f16 * S,
+ float16_t * pSrc);
+
+ /**
+ * @brief Instance structure for the Floating-point MFCC function.
+ */
+typedef struct
+ {
+ const float16_t *dctCoefs; /**< Internal DCT coefficients */
+ const float16_t *filterCoefs; /**< Internal Mel filter coefficients */
+ const float16_t *windowCoefs; /**< Windowing coefficients */
+ const uint32_t *filterPos; /**< Internal Mel filter positions in spectrum */
+ const uint32_t *filterLengths; /**< Internal Mel filter lengths */
+ uint32_t fftLen; /**< FFT length */
+ uint32_t nbMelFilters; /**< Number of Mel filters */
+ uint32_t nbDctOutputs; /**< Number of DCT outputs */
+#if defined(ARM_MFCC_USE_CFFT)
+ /* Implementation of the MFCC is using a CFFT */
+ arm_cfft_instance_f16 cfft; /**< Internal CFFT instance */
+#else
+ /* Implementation of the MFCC is using a RFFT (default) */
+ arm_rfft_fast_instance_f16 rfft;
+#endif
+ } arm_mfcc_instance_f16 ;
+
+arm_status arm_mfcc_init_32_f16(
+ arm_mfcc_instance_f16 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float16_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float16_t *filterCoefs,
+ const float16_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_64_f16(
+ arm_mfcc_instance_f16 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float16_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float16_t *filterCoefs,
+ const float16_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_128_f16(
+ arm_mfcc_instance_f16 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float16_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float16_t *filterCoefs,
+ const float16_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_256_f16(
+ arm_mfcc_instance_f16 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float16_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float16_t *filterCoefs,
+ const float16_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_512_f16(
+ arm_mfcc_instance_f16 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float16_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float16_t *filterCoefs,
+ const float16_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_1024_f16(
+ arm_mfcc_instance_f16 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float16_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float16_t *filterCoefs,
+ const float16_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_2048_f16(
+ arm_mfcc_instance_f16 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float16_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float16_t *filterCoefs,
+ const float16_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_4096_f16(
+ arm_mfcc_instance_f16 * S,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float16_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float16_t *filterCoefs,
+ const float16_t *windowCoefs
+ );
+
+arm_status arm_mfcc_init_f16(
+ arm_mfcc_instance_f16 * S,
+ uint32_t fftLen,
+ uint32_t nbMelFilters,
+ uint32_t nbDctOutputs,
+ const float16_t *dctCoefs,
+ const uint32_t *filterPos,
+ const uint32_t *filterLengths,
+ const float16_t *filterCoefs,
+ const float16_t *windowCoefs
+ );
+
+
+
+/**
+ @brief MFCC F16
+ @param[in] S points to the mfcc instance structure
+ @param[in] pSrc points to the input samples
+ @param[out] pDst points to the output MFCC values
+ @param[inout] pTmp points to a temporary buffer of complex
+ */
+#if defined(ARM_MATH_NEON_FLOAT16)
+void arm_mfcc_f16(
+ const arm_mfcc_instance_f16 * S,
+ float16_t *pSrc,
+ float16_t *pDst,
+ float16_t *pTmp,
+ float16_t *pTmp2
+ );
+#else
+ void arm_mfcc_f16(
+ const arm_mfcc_instance_f16 * S,
+ float16_t *pSrc,
+ float16_t *pDst,
+ float16_t *pTmp
+ );
+#endif
+
+#endif /* defined(ARM_FLOAT16_SUPPORTED)*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _TRANSFORM_FUNCTIONS_F16_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/utils.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/utils.h
new file mode 100755
index 0000000..348e878
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/utils.h
@@ -0,0 +1,272 @@
+/******************************************************************************
+ * @file arm_math_utils.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version V1.9.0
+ * @date 20. July 2020
+ ******************************************************************************/
+/*
+ * 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.
+ */
+
+#ifndef ARM_MATH_UTILS_H_
+
+#define ARM_MATH_UTILS_H_
+
+#include "arm_math_types.h"
+
+#ifdef __cplusplus
+#include
+extern "C"
+{
+#else
+#include
+#endif
+
+
+ /**
+ * @brief Macros required for reciprocal calculation in Normalized LMS
+ */
+
+#define INDEX_MASK 0x0000003F
+
+#ifndef MIN
+ #define MIN(x,y) ((x) < (y) ? (x) : (y))
+#endif
+
+#ifndef MAX
+ #define MAX(x,y) ((x) > (y) ? (x) : (y))
+#endif
+
+#ifndef ARM_SQ
+#define ARM_SQ(x) ((x) * (x))
+#endif
+
+#ifndef ARM_ROUND_UP
+ #define ARM_ROUND_UP(N, S) ((((N) + (S) - 1) / (S)) * (S))
+#endif
+
+
+ /**
+ * @brief Function to Calculates 1/in (reciprocal) value of Q31 Data type.
+ It should not be used with negative values.
+ */
+ __STATIC_FORCEINLINE uint32_t arm_recip_q31(
+ q31_t in,
+ q31_t * dst,
+ const q31_t * pRecipTable)
+ {
+ q31_t out;
+ uint32_t tempVal;
+ uint32_t index, i;
+ uint32_t signBits;
+
+ if (in > 0)
+ {
+ signBits = ((uint32_t) (__CLZ( (uint32_t)in) - 1));
+ }
+ else
+ {
+ signBits = ((uint32_t) (__CLZ((uint32_t)(-in)) - 1));
+ }
+
+ /* Convert input sample to 1.31 format */
+ in = (in << signBits);
+
+ /* calculation of index for initial approximated Val */
+ index = (uint32_t)(in >> 24);
+ index = (index & INDEX_MASK);
+
+ /* 1.31 with exp 1 */
+ out = pRecipTable[index];
+
+ /* calculation of reciprocal value */
+ /* running approximation for two iterations */
+ for (i = 0U; i < 2U; i++)
+ {
+ tempVal = (uint32_t) (((q63_t) in * out) >> 31);
+ tempVal = 0x7FFFFFFFu - tempVal;
+ /* 1.31 with exp 1 */
+ /* out = (q31_t) (((q63_t) out * tempVal) >> 30); */
+ out = clip_q63_to_q31(((q63_t) out * tempVal) >> 30);
+ }
+
+ /* write output */
+ *dst = out;
+
+ /* return num of signbits of out = 1/in value */
+ return (signBits + 1U);
+ }
+
+
+ /**
+ * @brief Function to Calculates 1/in (reciprocal) value of Q15 Data type.
+ It should not be used with negative values.
+ */
+ __STATIC_FORCEINLINE uint32_t arm_recip_q15(
+ q15_t in,
+ q15_t * dst,
+ const q15_t * pRecipTable)
+ {
+ q15_t out = 0;
+ int32_t tempVal = 0;
+ uint32_t index = 0, i = 0;
+ uint32_t signBits = 0;
+
+ if (in > 0)
+ {
+ signBits = ((uint32_t)(__CLZ( (uint32_t)in) - 17));
+ }
+ else
+ {
+ signBits = ((uint32_t)(__CLZ((uint32_t)(-in)) - 17));
+ }
+
+ /* Convert input sample to 1.15 format */
+ in = (q15_t)(in << signBits);
+
+ /* calculation of index for initial approximated Val */
+ index = (uint32_t)(in >> 8);
+ index = (index & INDEX_MASK);
+
+ /* 1.15 with exp 1 */
+ out = pRecipTable[index];
+
+ /* calculation of reciprocal value */
+ /* running approximation for two iterations */
+ for (i = 0U; i < 2U; i++)
+ {
+ tempVal = (((q31_t) in * out) >> 15);
+ tempVal = 0x7FFF - tempVal;
+ /* 1.15 with exp 1 */
+ out = (q15_t) (((q31_t) out * tempVal) >> 14);
+ /* out = clip_q31_to_q15(((q31_t) out * tempVal) >> 14); */
+ }
+
+ /* write output */
+ *dst = out;
+
+ /* return num of signbits of out = 1/in value */
+ return (signBits + 1);
+ }
+
+
+/**
+ * @brief 64-bit to 32-bit unsigned normalization
+ * @param[in] in is input unsigned long long value
+ * @param[out] normalized is the 32-bit normalized value
+ * @param[out] norm is norm scale
+ */
+__STATIC_INLINE void arm_norm_64_to_32u(uint64_t in, int32_t * normalized, int32_t *norm)
+{
+ int32_t n1;
+ int32_t hi = (int32_t) (in >> 32);
+ int32_t lo = (int32_t) ((in << 32) >> 32);
+
+ n1 = __CLZ((uint32_t)hi) - 32;
+ if (!n1)
+ {
+ /*
+ * input fits in 32-bit
+ */
+ n1 = __CLZ((uint32_t)lo);
+ if (!n1)
+ {
+ /*
+ * MSB set, need to scale down by 1
+ */
+ *norm = -1;
+ *normalized = (((uint32_t) lo) >> 1);
+ } else
+ {
+ if (n1 == 32)
+ {
+ /*
+ * input is zero
+ */
+ *norm = 0;
+ *normalized = 0;
+ } else
+ {
+ /*
+ * 32-bit normalization
+ */
+ *norm = n1 - 1;
+ *normalized = lo << *norm;
+ }
+ }
+ } else
+ {
+ /*
+ * input fits in 64-bit
+ */
+ n1 = 1 - n1;
+ *norm = -n1;
+ /*
+ * 64 bit normalization
+ */
+ *normalized = (int32_t)(((uint32_t)lo) >> n1) | (hi << (32 - n1));
+ }
+}
+
+/**
+ * arm_div_int64_to_int32 function performs division of a 64-bit integer by a 32-bit integer
+ * and returns a 32-bit integer result. The function saturates the result to fit within the 32-bit integer range.
+ * @param num The 64-bit integer numerator.
+ * @param den The 32-bit integer denominator.
+ * @return The saturated 32-bit integer result of the division.
+ */
+__STATIC_INLINE int32_t arm_div_int64_to_int32(int64_t num, int32_t den)
+{
+ int32_t result;
+ uint64_t absNum;
+ int32_t normalized;
+ int32_t norm;
+
+ /*
+ * if sum fits in 32bits
+ * avoid costly 64-bit division
+ */
+ if (num == LLONG_MIN)
+ {
+ absNum = LLONG_MAX;
+ }
+ else
+ {
+ absNum = (uint64_t) (num > 0 ? num : -num);
+ }
+ arm_norm_64_to_32u(absNum, &normalized, &norm);
+ if (norm > 0)
+ /*
+ * 32-bit division
+ */
+ result = (int32_t) num / den;
+ else
+ /*
+ * 64-bit division
+ */
+ result = clip_q63_to_q31(num / den);
+
+ return result;
+}
+
+#undef INDEX_MASK
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*ifndef _ARM_MATH_UTILS_H_ */
diff --git a/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/window_functions.h b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/window_functions.h
new file mode 100755
index 0000000..27f05a7
--- /dev/null
+++ b/Middlewares/Third_Party/ARM/ARM.CMSIS-DSP.1.17.1/Include/dsp/window_functions.h
@@ -0,0 +1,812 @@
+/******************************************************************************
+ * @file window_functions.h
+ * @brief Public header file for CMSIS DSP Library
+ * @version v1.15.0
+ * @date 15 December 2022
+ * Target Processor: Cortex-M and Cortex-A cores
+ ******************************************************************************/
+/*
+ * Copyright (c) 2010-2022 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.
+ */
+
+
+#ifndef WINDOW_FUNCTIONS_H_
+#define WINDOW_FUNCTIONS_H_
+
+#include "arm_math_types.h"
+#include "arm_math_memory.h"
+
+#include "dsp/none.h"
+#include "dsp/utils.h"
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/**
+ * @defgroup groupWindow Window Functions
+ */
+
+ /**
+ * @brief Welch window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 21.3 dB |
+ * | Normalized equivalent noise bandwidth | 1.2 bins |
+ * | Flatness | -2.2248 dB |
+ * | Recommended overlap | 29.3 % |
+ *
+ */
+ void arm_welch_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Welch window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 21.3 dB |
+ * | Normalized equivalent noise bandwidth | 1.2 bins |
+ * | Flatness | -2.2248 dB |
+ * | Recommended overlap | 29.3 % |
+ *
+ *
+ */
+ void arm_welch_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Bartlett window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 26.5 dB |
+ * | Normalized equivalent noise bandwidth | 1.3333 bins |
+ * | Flatness | -1.8242 dB |
+ * | Recommended overlap | 50.0 % |
+ *
+ */
+ void arm_bartlett_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Bartlett window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 26.5 dB |
+ * | Normalized equivalent noise bandwidth | 1.3333 bins |
+ * | Flatness | -1.8242 dB |
+ * | Recommended overlap | 50.0 % |
+ *
+ *
+ */
+ void arm_bartlett_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Hamming window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 42.7 dB |
+ * | Normalized equivalent noise bandwidth | 1.3628 bins |
+ * | Flatness | -1.7514 dB |
+ * | Recommended overlap | 50 % |
+ *
+ */
+ void arm_hamming_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Hamming window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 42.7 dB |
+ * | Normalized equivalent noise bandwidth | 1.3628 bins |
+ * | Flatness | -1.7514 dB |
+ * | Recommended overlap | 50 % |
+ *
+ *
+ */
+ void arm_hamming_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Hanning window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 31.5 dB |
+ * | Normalized equivalent noise bandwidth | 1.5 bins |
+ * | Flatness | -1.4236 dB |
+ * | Recommended overlap | 50 % |
+ *
+ */
+ void arm_hanning_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Hanning window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 31.5 dB |
+ * | Normalized equivalent noise bandwidth | 1.5 bins |
+ * | Flatness | -1.4236 dB |
+ * | Recommended overlap | 50 % |
+ *
+ *
+ */
+ void arm_hanning_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Nuttall3 window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 46.7 dB |
+ * | Normalized equivalent noise bandwidth | 1.9444 bins |
+ * | Flatness | -0.863 dB |
+ * | Recommended overlap | 64.7 % |
+ *
+ */
+ void arm_nuttall3_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Nuttall3 window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 46.7 dB |
+ * | Normalized equivalent noise bandwidth | 1.9444 bins |
+ * | Flatness | -0.863 dB |
+ * | Recommended overlap | 64.7 % |
+ *
+ *
+ */
+ void arm_nuttall3_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Nuttall4 window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 60.9 dB |
+ * | Normalized equivalent noise bandwidth | 2.31 bins |
+ * | Flatness | -0.6184 dB |
+ * | Recommended overlap | 70.5 % |
+ *
+ */
+ void arm_nuttall4_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Nuttall4 window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 60.9 dB |
+ * | Normalized equivalent noise bandwidth | 2.31 bins |
+ * | Flatness | -0.6184 dB |
+ * | Recommended overlap | 70.5 % |
+ *
+ *
+ */
+ void arm_nuttall4_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Nuttall3a window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 64.2 dB |
+ * | Normalized equivalent noise bandwidth | 1.7721 bins |
+ * | Flatness | -1.0453 dB |
+ * | Recommended overlap | 61.2 % |
+ *
+ */
+ void arm_nuttall3a_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Nuttall3a window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 64.2 dB |
+ * | Normalized equivalent noise bandwidth | 1.7721 bins |
+ * | Flatness | -1.0453 dB |
+ * | Recommended overlap | 61.2 % |
+ *
+ *
+ */
+ void arm_nuttall3a_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Nuttall3b window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 71.5 dB |
+ * | Normalized equivalent noise bandwidth | 1.7037 bins |
+ * | Flatness | -1.1352 dB |
+ * | Recommended overlap | 59.8 % |
+ *
+ */
+ void arm_nuttall3b_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Nuttall3b window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 71.5 dB |
+ * | Normalized equivalent noise bandwidth | 1.7037 bins |
+ * | Flatness | -1.1352 dB |
+ * | Recommended overlap | 59.8 % |
+ *
+ *
+ */
+ void arm_nuttall3b_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Nuttall4a window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 82.6 dB |
+ * | Normalized equivalent noise bandwidth | 2.1253 bins |
+ * | Flatness | -0.7321 dB |
+ * | Recommended overlap | 68.0 % |
+ *
+ */
+ void arm_nuttall4a_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Nuttall4a window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 82.6 dB |
+ * | Normalized equivalent noise bandwidth | 2.1253 bins |
+ * | Flatness | -0.7321 dB |
+ * | Recommended overlap | 68.0 % |
+ *
+ *
+ */
+ void arm_nuttall4a_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief 92 db blackman harris window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 92.0 dB |
+ * | Normalized equivalent noise bandwidth | 2.0044 bins |
+ * | Flatness | -0.8256 dB |
+ * | Recommended overlap | 66.1 % |
+ *
+ */
+ void arm_blackman_harris_92db_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief 92 db blackman harris window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 92.0 dB |
+ * | Normalized equivalent noise bandwidth | 2.0044 bins |
+ * | Flatness | -0.8256 dB |
+ * | Recommended overlap | 66.1 % |
+ *
+ *
+ */
+ void arm_blackman_harris_92db_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Nuttall4b window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 93.3 dB |
+ * | Normalized equivalent noise bandwidth | 2.0212 bins |
+ * | Flatness | -0.8118 dB |
+ * | Recommended overlap | 66.3 % |
+ *
+ */
+ void arm_nuttall4b_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Nuttall4b window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 93.3 dB |
+ * | Normalized equivalent noise bandwidth | 2.0212 bins |
+ * | Flatness | -0.8118 dB |
+ * | Recommended overlap | 66.3 % |
+ *
+ *
+ */
+ void arm_nuttall4b_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Nuttall4c window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 98.1 dB |
+ * | Normalized equivalent noise bandwidth | 1.9761 bins |
+ * | Flatness | -0.8506 dB |
+ * | Recommended overlap | 65.6 % |
+ *
+ */
+ void arm_nuttall4c_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Nuttall4c window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 98.1 dB |
+ * | Normalized equivalent noise bandwidth | 1.9761 bins |
+ * | Flatness | -0.8506 dB |
+ * | Recommended overlap | 65.6 % |
+ *
+ *
+ */
+ void arm_nuttall4c_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Hft90d window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 90.2 dB |
+ * | Normalized equivalent noise bandwidth | 3.8832 bins |
+ * | Flatness | -0.0039 dB |
+ * | Recommended overlap | 76.0 % |
+ *
+ */
+ void arm_hft90d_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Hft90d window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 90.2 dB |
+ * | Normalized equivalent noise bandwidth | 3.8832 bins |
+ * | Flatness | -0.0039 dB |
+ * | Recommended overlap | 76.0 % |
+ *
+ *
+ */
+ void arm_hft90d_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Hft95 window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 95.0 dB |
+ * | Normalized equivalent noise bandwidth | 3.8112 bins |
+ * | Flatness | 0.0044 dB |
+ * | Recommended overlap | 75.6 % |
+ *
+ */
+ void arm_hft95_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Hft95 window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 95.0 dB |
+ * | Normalized equivalent noise bandwidth | 3.8112 bins |
+ * | Flatness | 0.0044 dB |
+ * | Recommended overlap | 75.6 % |
+ *
+ *
+ */
+ void arm_hft95_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Hft116d window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 116.8 dB |
+ * | Normalized equivalent noise bandwidth | 4.2186 bins |
+ * | Flatness | -0.0028 dB |
+ * | Recommended overlap | 78.2 % |
+ *
+ */
+ void arm_hft116d_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Hft116d window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 116.8 dB |
+ * | Normalized equivalent noise bandwidth | 4.2186 bins |
+ * | Flatness | -0.0028 dB |
+ * | Recommended overlap | 78.2 % |
+ *
+ *
+ */
+ void arm_hft116d_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Hft144d window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 144.1 dB |
+ * | Normalized equivalent noise bandwidth | 4.5386 bins |
+ * | Flatness | 0.0021 dB |
+ * | Recommended overlap | 79.9 % |
+ *
+ */
+ void arm_hft144d_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Hft144d window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 144.1 dB |
+ * | Normalized equivalent noise bandwidth | 4.5386 bins |
+ * | Flatness | 0.0021 dB |
+ * | Recommended overlap | 79.9 % |
+ *
+ *
+ */
+ void arm_hft144d_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Hft169d window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 169.5 dB |
+ * | Normalized equivalent noise bandwidth | 4.8347 bins |
+ * | Flatness | 0.0017 dB |
+ * | Recommended overlap | 81.2 % |
+ *
+ */
+ void arm_hft169d_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Hft169d window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 169.5 dB |
+ * | Normalized equivalent noise bandwidth | 4.8347 bins |
+ * | Flatness | 0.0017 dB |
+ * | Recommended overlap | 81.2 % |
+ *
+ *
+ */
+ void arm_hft169d_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Hft196d window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 196.2 dB |
+ * | Normalized equivalent noise bandwidth | 5.1134 bins |
+ * | Flatness | 0.0013 dB |
+ * | Recommended overlap | 82.3 % |
+ *
+ */
+ void arm_hft196d_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Hft196d window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 196.2 dB |
+ * | Normalized equivalent noise bandwidth | 5.1134 bins |
+ * | Flatness | 0.0013 dB |
+ * | Recommended overlap | 82.3 % |
+ *
+ *
+ */
+ void arm_hft196d_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Hft223d window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 223.0 dB |
+ * | Normalized equivalent noise bandwidth | 5.3888 bins |
+ * | Flatness | 0.0011 dB |
+ * | Recommended overlap | 83.3 % |
+ *
+ */
+ void arm_hft223d_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Hft223d window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 223.0 dB |
+ * | Normalized equivalent noise bandwidth | 5.3888 bins |
+ * | Flatness | 0.0011 dB |
+ * | Recommended overlap | 83.3 % |
+ *
+ *
+ */
+ void arm_hft223d_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+ /**
+ * @brief Hft248d window (double).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 248.4 dB |
+ * | Normalized equivalent noise bandwidth | 5.6512 bins |
+ * | Flatness | 0.0009 dB |
+ * | Recommended overlap | 84.1 % |
+ *
+ */
+ void arm_hft248d_f64(
+ float64_t * pDst,
+ uint32_t blockSize);
+
+ /**
+ * @brief Hft248d window (float).
+ * @param[out] pDst points to the output generated window
+ * @param[in] blockSize number of samples in the window
+ *
+ * @par Parameters of the window
+ *
+ * | Parameter | Value |
+ * | ------------------------------------: | -----------------: |
+ * | Peak sidelobe level | 248.4 dB |
+ * | Normalized equivalent noise bandwidth | 5.6512 bins |
+ * | Flatness | 0.0009 dB |
+ * | Recommended overlap | 84.1 % |
+ *
+ *
+ */
+ void arm_hft248d_f32(
+ float32_t * pDst,
+ uint32_t blockSize);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ifndef _BASIC_MATH_FUNCTIONS_H_ */
--
cgit v1.2.3