CMSIS-DSP: Added some support functions.

entropy, Kullback-Leibler, LogSumExp, Dot product using LogSumExp weighted sum, barycenter.
7 years ago · aa43cfb6dd
parent 94b63664f2
commit aa43cfb6dd
61 changed files with 9972 additions and 399 deletions
--- a/Include/arm_math.h
+++ b/Include/arm_math.h
@ -7175,6 +7175,113 @@ uint32_t arm_gaussian_naive_bayes_predict_f32(const arm_gaussian_naive_bayes_ins
   const float32_t * in, 
   float32_t *pBuffer);

+/**
+ * @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 log 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 if extracted and the function is computing:
+ * xm + ln(exp(x1 - xm) + ... + exp(xn - xm))
+ *
+ * @param[in]    *in         points 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      points to an 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 Kullback-Leibler
+ *
+ * @param[in]  *pSrcA         points to an array of input values for probaility distribution A.
+ * @param[in]  *pSrcB         points to an array of input values for probaility 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 Weighted sum
+ *
+ *
+ * @param[in]    *in         points to an array of input values.
+ * @param[in]    *weigths    weights
+ * @param[in]  blockSize     number of samples in the input array.
+ * @return     Weighted sum
+ *
+ */
+float32_t arm_weighted_sum_f32(const float32_t *in
+  , const float32_t *weigths
+  , uint32_t blockSize);
+
+
+/**
+ * @brief Barycenter
+ *
+ *
+ * @param[in]    *in         List of points
+ * @param[in]    *in         List of weights
+ * @param[out]   *out        Barycenter
+ * @param[in]  nbVectors     number of vectors
+ * @param[in]  vecDim        Dimension of space
+ * @return     None
+ *
+ */
+void arm_barycenter_f32(const float32_t *in
+  , const float32_t *weights
+  , float32_t *out
+  , uint32_t nbVectors
+  , uint32_t vecDim);
+
+
  /**
   * @ingroup groupInterpolation
   */
--- a/Source/BayesFunctions/arm_gaussian_naive_bayes_predict_f32.c
+++ b/Source/BayesFunctions/arm_gaussian_naive_bayes_predict_f32.c
@ -4,7 +4,7 @@
 * Description:  Naive Gaussian Bayesian Estimator
 *
 *
- * Target Processor: Cortex-M cores
+ * Target Processor: Cortex-M and Cortex-A cores
 * -------------------------------------------------------------------- */
 /*
 * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
--- a/Source/SVMFunctions/arm_svm_linear_init_f32.c
+++ b/Source/SVMFunctions/arm_svm_linear_init_f32.c
@ -4,7 +4,7 @@
 * Description:  SVM Linear Instance Initialization
 *
 *
- * Target Processor: Cortex-M cores
+ * Target Processor: Cortex-M and Cortex-A cores
 * -------------------------------------------------------------------- */
 /*
 * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
--- a/Source/SVMFunctions/arm_svm_linear_predict_f32.c
+++ b/Source/SVMFunctions/arm_svm_linear_predict_f32.c
@ -4,7 +4,7 @@
 * Description:  SVM Linear Classifier
 *
 *
- * Target Processor: Cortex-M cores
+ * Target Processor: Cortex-M and Cortex-A cores
 * -------------------------------------------------------------------- */
 /*
 * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
--- a/Source/SVMFunctions/arm_svm_polynomial_init_f32.c
+++ b/Source/SVMFunctions/arm_svm_polynomial_init_f32.c
@ -4,7 +4,7 @@
 * Description:  SVM Polynomial Instance Initialization
 *
 *
- * Target Processor: Cortex-M cores
+ * Target Processor: Cortex-M and Cortex-A cores
 * -------------------------------------------------------------------- */
 /*
 * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
--- a/Source/SVMFunctions/arm_svm_polynomial_predict_f32.c
+++ b/Source/SVMFunctions/arm_svm_polynomial_predict_f32.c
@ -4,7 +4,7 @@
 * Description:  SVM Polynomial Classifier
 *
 *
- * Target Processor: Cortex-M cores
+ * Target Processor: Cortex-M and Cortex-A cores
 * -------------------------------------------------------------------- */
 /*
 * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
--- a/Source/SVMFunctions/arm_svm_rbf_init_f32.c
+++ b/Source/SVMFunctions/arm_svm_rbf_init_f32.c
@ -4,7 +4,7 @@
 * Description:  SVM Radial Basis Function Instance Initialization
 *
 *
- * Target Processor: Cortex-M cores
+ * Target Processor: Cortex-M and Cortex-A cores
 * -------------------------------------------------------------------- */
 /*
 * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
--- a/Source/SVMFunctions/arm_svm_rbf_predict_f32.c
+++ b/Source/SVMFunctions/arm_svm_rbf_predict_f32.c
@ -4,7 +4,7 @@
 * Description:  SVM Radial Basis Function Classifier
 *
 *
- * Target Processor: Cortex-M cores
+ * Target Processor: Cortex-M and Cortex-A cores
 * -------------------------------------------------------------------- */
 /*
 * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
--- a/Source/SVMFunctions/arm_svm_sigmoid_init_f32.c
+++ b/Source/SVMFunctions/arm_svm_sigmoid_init_f32.c
@ -4,7 +4,7 @@
 * Description:  SVM Sigmoid Instance Initialization
 *
 *
- * Target Processor: Cortex-M cores
+ * Target Processor: Cortex-M and Cortex-A cores
 * -------------------------------------------------------------------- */
 /*
 * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
--- a/Source/SVMFunctions/arm_svm_sigmoid_predict_f32.c
+++ b/Source/SVMFunctions/arm_svm_sigmoid_predict_f32.c
@ -4,7 +4,7 @@
 * Description:  SVM Sigmoid Classifier
 *
 *
- * Target Processor: Cortex-M cores
+ * Target Processor: Cortex-M and Cortex-A cores
 * -------------------------------------------------------------------- */
 /*
 * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
--- a/Source/StatisticsFunctions/arm_entropy_f32.c
+++ b/Source/StatisticsFunctions/arm_entropy_f32.c
@ -0,0 +1,124 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_logsumexp_f32.c
+ * Description:  LogSumExp
+ *
+ *
+ * Target Processor: Cortex-M and Cortex-A cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arm_math.h"
+#include <limits.h>
+#include <math.h>
+
+
+/**
+ * @addtogroup groupStats
+ * @{
+ */
+
+
+/**
+ * @brief Entropy
+ *
+ * Distribution may contain 0 probabilities with Neon version.
+ * Result will be right but some exception flags will be set.
+ *
+ * @param[in]  *pSrcA         points to an array of input values.
+ * @param[in]  blockSize   number of samples in the input array.
+ * @return Entropy -Sum(p ln p)
+ *
+ */
+
+#if defined(ARM_MATH_NEON)
+
+#include "NEMath.h"
+
+float32_t arm_entropy_f32(const float32_t * pSrcA,uint32_t blockSize)
+{
+    const float32_t *pIn;
+    uint32_t blkCnt;
+    float32_t accum, p;
+
+    float32x4_t accumV;
+    float32x2_t accumV2;
+    float32x4_t tmpV, tmpV2;
+ 
+    pIn = pSrcA;
+
+    accum = 0.0;
+    accumV = vdupq_n_f32(0.0);
+
+    blkCnt = blockSize >> 2;
+    while(blkCnt > 0)
+    {
+      tmpV = vld1q_f32(pIn);
+      pIn += 4;
+
+      tmpV2 = vlogq_f32(tmpV);
+      accumV = vmlaq_f32(accumV, tmpV, tmpV2);
+       
+      blkCnt--;
+    
+    }
+
+    accumV2 = vpadd_f32(vget_low_f32(accumV),vget_high_f32(accumV));
+    accum = accumV2[0] + accumV2[1];
+
+    blkCnt = blockSize & 3;
+    while(blkCnt > 0)
+    {
+       p = *pIn++;
+       accum += p * log(p);
+       
+       blkCnt--;
+    
+    }
+
+    return(-accum);
+}
+
+#else
+float32_t arm_entropy_f32(const float32_t * pSrcA,uint32_t blockSize)
+{
+    const float32_t *pIn;
+    uint32_t blkCnt;
+    float32_t accum, p;
+ 
+    pIn = pSrcA;
+    blkCnt = blockSize;
+
+    accum = 0.0;
+
+    while(blkCnt > 0)
+    {
+       p = *pIn++;
+       accum += p * log(p);
+       
+       blkCnt--;
+    
+    }
+
+    return(-accum);
+}
+#endif
+/**
+ * @} end of groupStats group
+ */
--- a/Source/StatisticsFunctions/arm_kullback_leibler_f32.c
+++ b/Source/StatisticsFunctions/arm_kullback_leibler_f32.c
@ -0,0 +1,137 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_logsumexp_f32.c
+ * Description:  LogSumExp
+ *
+ *
+ * Target Processor: Cortex-M and Cortex-A cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arm_math.h"
+#include <limits.h>
+#include <math.h>
+
+
+/**
+ * @addtogroup groupStats
+ * @{
+ */
+
+
+/**
+ * @brief Kullback-Leibler
+ *
+ * Distribution A may contain 0 with Neon version.
+ * Result will be right but some exception flags will be set.
+ *
+ * Distribution B must not contain 0 probability.
+ *
+ * @param[in]  *pSrcA         points to an array of input values for probaility distribution A.
+ * @param[in]  *pSrcB         points to an array of input values for probaility distribution B.
+ * @param[in]  blockSize      number of samples in the input array.
+ * @return Kullback-Leibler divergence D(A || B)
+ *
+ */
+
+#if defined(ARM_MATH_NEON)
+
+#include "NEMath.h"
+
+float32_t arm_kullback_leibler_f32(const float32_t * pSrcA,const float32_t * pSrcB,uint32_t blockSize)
+{
+    const float32_t *pInA, *pInB;
+    uint32_t blkCnt;
+    float32_t accum, pA,pB;
+
+    float32x4_t accumV;
+    float32x2_t accumV2;
+    float32x4_t tmpVA, tmpVB,tmpV;
+ 
+    pInA = pSrcA;
+    pInB = pSrcB;
+
+    accum = 0.0;
+    accumV = vdupq_n_f32(0.0);
+
+    blkCnt = blockSize >> 2;
+    while(blkCnt > 0)
+    {
+      tmpVA = vld1q_f32(pInA);
+      pInA += 4;
+
+      tmpVB = vld1q_f32(pInB);
+      pInB += 4;
+
+      tmpV = vinvq_f32(tmpVA);
+      tmpVB = vmulq_f32(tmpVB, tmpV);
+      tmpVB = vlogq_f32(tmpVB);
+
+      accumV = vmlaq_f32(accumV, tmpVA, tmpVB);
+       
+      blkCnt--;
+    
+    }
+
+    accumV2 = vpadd_f32(vget_low_f32(accumV),vget_high_f32(accumV));
+    accum = accumV2[0] + accumV2[1];
+
+    blkCnt = blockSize & 3;
+    while(blkCnt > 0)
+    {
+       pA = *pInA++;
+       pB = *pInB++;
+       accum += pA * log(pB/pA);
+       
+       blkCnt--;
+    
+    }
+
+    return(-accum);
+}
+
+#else
+float32_t arm_kullback_leibler_f32(const float32_t * pSrcA,const float32_t * pSrcB,uint32_t blockSize)
+{
+    const float32_t *pInA, *pInB;
+    uint32_t blkCnt;
+    float32_t accum, pA,pB;
+ 
+    pInA = pSrcA;
+    pInB = pSrcB;
+    blkCnt = blockSize;
+
+    accum = 0.0;
+
+    while(blkCnt > 0)
+    {
+       pA = *pInA++;
+       pB = *pInB++;
+       accum += pA * log(pB / pA);
+       
+       blkCnt--;
+    
+    }
+
+    return(-accum);
+}
+#endif
+/**
+ * @} end of groupStats group
+ */
--- a/Source/StatisticsFunctions/arm_logsumexp_dot_prod_f32.c
+++ b/Source/StatisticsFunctions/arm_logsumexp_dot_prod_f32.c
@ -0,0 +1,66 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_logsumexp_f32.c
+ * Description:  LogSumExp
+ *
+ *
+ * Target Processor: Cortex-M and Cortex-A cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arm_math.h"
+#include <limits.h>
+#include <math.h>
+
+
+/**
+ * @addtogroup groupStats
+ * @{
+ */
+
+
+/**
+ * @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)
+{
+    float32_t result;
+    arm_add_f32((float32_t*)pSrcA, (float32_t*)pSrcB, pTmpBuffer, blockSize);
+
+    result = arm_logsumexp_f32(pTmpBuffer, blockSize);
+    return(result);
+}
+
+/**
+ * @} end of groupStats group
+ */
--- a/Source/StatisticsFunctions/arm_logsumexp_f32.c
+++ b/Source/StatisticsFunctions/arm_logsumexp_f32.c
@ -0,0 +1,216 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_logsumexp_f32.c
+ * Description:  LogSumExp
+ *
+ *
+ * Target Processor: Cortex-M and Cortex-A cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arm_math.h"
+#include <limits.h>
+#include <math.h>
+
+
+/**
+ * @addtogroup groupStats
+ * @{
+ */
+
+
+/**
+ * @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 log 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 if extracted and the function is computing:
+ * xm + ln(exp(x1 - xm) + ... + exp(xn - xm))
+ *
+ * @param[in]    *in         points to an array of input values.
+ * @param[in]  blockSize     number of samples in the input array.
+ * @return LogSumExp
+ *
+ */
+
+#if defined(ARM_MATH_NEON)
+
+#include "NEMath.h"
+float32_t arm_logsumexp_f32(const float32_t *in, uint32_t blockSize)
+{
+    float32_t maxVal;
+    float32_t tmp;
+    float32x4_t tmpV, tmpVb;
+    float32x2_t tmpV2;
+    float32x4_t maxValV;
+    uint32x4_t idxV;
+    float32x4_t accumV;
+    float32x2_t accumV2;
+
+    const float32_t *pIn;
+    uint32_t blkCnt;
+    float32_t accum;
+ 
+    pIn = in;
+
+    blkCnt = blockSize;
+
+    if (blockSize <= 3)
+    {
+      maxVal = *pIn++;
+      blkCnt--;
+
+      while(blkCnt > 0)
+      {
+         tmp = *pIn++;
+  
+         if (tmp > maxVal)
+         {
+            maxVal = tmp;
+         }
+         blkCnt--;
+      }
+    }
+    else
+    {
+      maxValV = vld1q_f32(pIn);
+      pIn += 4;
+      blkCnt = (blockSize - 4) >> 2;
+
+      while(blkCnt > 0)
+      {
+         tmpVb = vld1q_f32(pIn);
+         pIn += 4;
+  
+         idxV = vcgtq_f32(tmpVb, maxValV);
+         maxValV = vbslq_f32(idxV, tmpVb, maxValV );
+
+         blkCnt--;
+      }
+
+      accumV2 = vpmax_f32(vget_low_f32(maxValV),vget_high_f32(maxValV));
+      accumV2 = vpmax_f32(accumV2,accumV2);
+      maxVal = accumV2[0];
+
+      blkCnt = (blockSize - 4) & 3;
+
+      while(blkCnt > 0)
+      {
+         tmp = *pIn++;
+  
+         if (tmp > maxVal)
+         {
+            maxVal = tmp;
+         }
+         blkCnt--;
+      }
+
+    }
+
+    
+
+    maxValV = vdupq_n_f32(maxVal);
+    pIn = in;
+    accum = 0;
+    accumV = vdupq_n_f32(0.0);
+
+    blkCnt = blockSize >> 2;
+
+    while(blkCnt > 0)
+    {
+       tmpV = vld1q_f32(pIn);
+       pIn += 4;
+       tmpV = vsubq_f32(tmpV, maxValV);
+       tmpV = vexpq_f32(tmpV);
+       accumV = vaddq_f32(accumV, tmpV);
+
+       blkCnt--;
+    
+    }
+    accumV2 = vpadd_f32(vget_low_f32(accumV),vget_high_f32(accumV));
+    accum = accumV2[0] + accumV2[1];
+
+    blkCnt = blockSize & 0x3;
+    while(blkCnt > 0)
+    {
+       tmp = *pIn++;
+       accum += exp(tmp - maxVal);
+       blkCnt--;
+    
+    }
+
+    accum = maxVal + log(accum);
+
+    return(accum);
+}
+#else
+float32_t arm_logsumexp_f32(const float32_t *in, uint32_t blockSize)
+{
+    float32_t maxVal;
+    float32_t tmp;
+    const float32_t *pIn;
+    uint32_t blkCnt;
+    float32_t accum;
+ 
+    pIn = in;
+    blkCnt = blockSize;
+
+    maxVal = *pIn++;
+    blkCnt--;
+
+    while(blkCnt > 0)
+    {
+       tmp = *pIn++;
+
+       if (tmp > maxVal)
+       {
+          maxVal = tmp;
+       }
+       blkCnt--;
+    
+    }
+
+    blkCnt = blockSize;
+    pIn = in;
+    accum = 0;
+    while(blkCnt > 0)
+    {
+       tmp = *pIn++;
+       accum += exp(tmp - maxVal);
+       blkCnt--;
+    
+    }
+    accum = maxVal + log(accum);
+
+    return(accum);
+}
+#endif
+/**
+ * @} end of groupStats group
+ */
--- a/Source/StatisticsFunctions/arm_max_f32.c
+++ b/Source/StatisticsFunctions/arm_max_f32.c
@ -6,7 +6,7 @@
 * $Date:        18. March 2019
 * $Revision:    V1.6.0
 *
- * Target Processor: Cortex-M cores
+ * Target Processor: Cortex-M and Cortex-A cores
 * -------------------------------------------------------------------- */
 /*
 * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
--- a/Source/SupportFunctions/arm_barycenter_f32.c
+++ b/Source/SupportFunctions/arm_barycenter_f32.c
@ -0,0 +1,265 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_barycenter_f32.c
+ * Description:  Barycenter
+ *
+ *
+ * Target Processor: Cortex-M and Cortex-A cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arm_math.h"
+#include <limits.h>
+#include <math.h>
+
+
+/**
+  @ingroup groupSupport
+ */
+
+
+/**
+ * @brief Barycenter
+ *
+ *
+ * @param[in]    *in         List of points
+ * @param[out]   *out        Barycenter
+ * @param[in]  nbVectors     number of vectors
+ * @param[in]  vecDim        Dimension of space
+ * @return     None
+ *
+ */
+
+#if defined(ARM_MATH_NEON)
+
+#include "NEMath.h"
+void arm_barycenter_f32(const float32_t *in, const float32_t *weights, float32_t *out, uint32_t nbVectors,uint32_t vecDim)
+{
+
+   const float32_t *pIn,*pW, *pIn1, *pIn2, *pIn3, *pIn4;
+   float32_t *pOut;
+   uint32_t blkCntVector,blkCntSample;
+   float32_t accum, w,w1,w2,w3,w4;
+
+   float32x4_t tmp, inV,outV, inV1, inV2, inV3, inV4;
+
+   blkCntVector = nbVectors;
+   blkCntSample = vecDim;
+
+   accum = 0.0;
+
+   pW = weights;
+   pIn = in;
+
+   /* Set counters to 0 */
+   tmp = vdupq_n_f32(0.0);
+   pOut = out;
+
+   blkCntSample = vecDim >> 2;
+   while(blkCntSample > 0)
+   {
+         vst1q_f32(pOut, tmp);
+         pOut += 4;
+         blkCntSample--;
+   }
+
+   blkCntSample = vecDim & 3;
+   while(blkCntSample > 0)
+   {
+         *pOut = 0.0;
+         pOut++;
+         blkCntSample--;
+   }
+
+   /* Sum */
+  
+   pIn1 = pIn;
+   pIn2 = pIn1 + vecDim;
+   pIn3 = pIn2 + vecDim;
+   pIn4 = pIn3 + vecDim;
+   
+   blkCntVector = nbVectors >> 2;
+   while(blkCntVector > 0)
+   {
+      pOut = out;
+      w1 = *pW++;
+      w2 = *pW++;
+      w3 = *pW++;
+      w4 = *pW++;
+      accum += w1 + w2 + w3 + w4;
+
+      blkCntSample = vecDim >> 2;
+      while(blkCntSample > 0)
+      {
+          outV = vld1q_f32(pOut);
+          inV1 = vld1q_f32(pIn1);
+          inV2 = vld1q_f32(pIn2);
+          inV3 = vld1q_f32(pIn3);
+          inV4 = vld1q_f32(pIn4);
+          outV = vmlaq_n_f32(outV,inV1,w1);
+          outV = vmlaq_n_f32(outV,inV2,w2);
+          outV = vmlaq_n_f32(outV,inV3,w3);
+          outV = vmlaq_n_f32(outV,inV4,w4);
+          vst1q_f32(pOut, outV);
+          pOut += 4;
+          pIn1 += 4;
+          pIn2 += 4;
+          pIn3 += 4;
+          pIn4 += 4;
+
+          blkCntSample--;
+      }
+
+      blkCntSample = vecDim & 3;
+      while(blkCntSample > 0)
+      {
+          *pOut = *pOut + *pIn1++ * w1;
+          *pOut = *pOut + *pIn2++ * w2;
+          *pOut = *pOut + *pIn3++ * w3;
+          *pOut = *pOut + *pIn4++ * w4;
+          pOut++;
+          blkCntSample--;
+      }
+
+      pIn1 += 3*vecDim;
+      pIn2 += 3*vecDim;
+      pIn3 += 3*vecDim;
+      pIn4 += 3*vecDim;
+
+      blkCntVector--;
+   }
+
+   pIn = pIn1;
+
+   blkCntVector = nbVectors & 3;
+   while(blkCntVector > 0)
+   {
+      pOut = out;
+      w = *pW++;
+      accum += w;
+
+      blkCntSample = vecDim >> 2;
+      while(blkCntSample > 0)
+      {
+          outV = vld1q_f32(pOut);
+          inV = vld1q_f32(pIn);
+          outV = vmlaq_n_f32(outV,inV,w);
+          vst1q_f32(pOut, outV);
+          pOut += 4;
+          pIn += 4;
+
+          blkCntSample--;
+      }
+      
+      blkCntSample = vecDim & 3;
+      while(blkCntSample > 0)
+      {
+          *pOut = *pOut + *pIn++ * w;
+          pOut++;
+          blkCntSample--;
+      }
+
+      blkCntVector--;
+   }
+
+   /* Normalize */
+   pOut = out;
+   accum = 1.0 / accum;
+
+   blkCntSample = vecDim >> 2;
+   while(blkCntSample > 0)
+   {
+         tmp = vld1q_f32(pOut);
+         tmp = vmulq_n_f32(tmp,accum);
+         vst1q_f32(pOut, tmp);
+         pOut += 4;
+         blkCntSample--;
+   }
+
+   blkCntSample = vecDim & 3;
+   while(blkCntSample > 0)
+   {
+         *pOut = *pOut * accum;
+         pOut++;
+         blkCntSample--;
+   }
+
+}
+#else
+void arm_barycenter_f32(const float32_t *in, const float32_t *weights, float32_t *out, uint32_t nbVectors,uint32_t vecDim)
+{
+
+   const float32_t *pIn,*pW;
+   float32_t *pOut;
+   uint32_t blkCntVector,blkCntSample;
+   float32_t accum, w;
+
+   blkCntVector = nbVectors;
+   blkCntSample = vecDim;
+
+   accum = 0.0;
+
+   pW = weights;
+   pIn = in;
+
+   /* Set counters to 0 */
+   blkCntSample = vecDim;
+   pOut = out;
+
+   while(blkCntSample > 0)
+   {
+         *pOut = 0.0;
+         pOut++;
+         blkCntSample--;
+   }
+
+   /* Sum */
+   while(blkCntVector > 0)
+   {
+      pOut = out;
+      w = *pW++;
+      accum += w;
+
+      blkCntSample = vecDim;
+      while(blkCntSample > 0)
+      {
+          *pOut = *pOut + *pIn++ * w;
+          pOut++;
+          blkCntSample--;
+      }
+
+      blkCntVector--;
+   }
+
+   /* Normalize */
+   blkCntSample = vecDim;
+   pOut = out;
+
+   while(blkCntSample > 0)
+   {
+         *pOut = *pOut / accum;
+         pOut++;
+         blkCntSample--;
+   }
+
+}
+#endif
+/**
+ * @} end of groupSupport group
+ */
--- a/Source/SupportFunctions/arm_weighted_sum_f32.c
+++ b/Source/SupportFunctions/arm_weighted_sum_f32.c
@ -0,0 +1,133 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_weighted_sum_f32.c
+ * Description:  Weighted Sum
+ *
+ *
+ * Target Processor: Cortex-M and Cortex-A cores
+ * -------------------------------------------------------------------- */
+/*
+ * Copyright (C) 2010-2019 ARM Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "arm_math.h"
+#include <limits.h>
+#include <math.h>
+
+
+/**
+ * @addtogroup groupSupport
+ * @{
+ */
+
+
+/**
+ * @brief Weighted sum
+ *
+ *
+ * @param[in]    *in         points to an array of input values.
+ * @param[in]    *weigths    weights
+ * @param[in]  blockSize     number of samples in the input array.
+ * @return     Weighted sum
+ *
+ */
+
+#if defined(ARM_MATH_NEON)
+
+#include "NEMath.h"
+float32_t arm_weighted_sum_f32(const float32_t *in,const float32_t *weigths, uint32_t blockSize)
+{
+
+    float32_t accum1, accum2;
+    float32x4_t accum1V, accum2V;
+    float32x2_t tempV;
+
+    float32x4_t inV,wV;
+
+    const float32_t *pIn, *pW;
+    uint32_t blkCnt;
+
+
+    pIn = in;
+    pW = weigths;
+
+    accum1=0.0;
+    accum2=0.0;
+
+    accum1V = vdupq_n_f32(0.0);
+    accum2V = vdupq_n_f32(0.0);
+
+    blkCnt = blockSize >> 2;
+    while(blkCnt > 0)
+    {
+        inV = vld1q_f32(pIn);
+        wV = vld1q_f32(pW);
+
+        pIn += 4; 
+        pW += 4;
+
+        accum1V = vmlaq_f32(accum1V,inV,wV);
+        accum2V = vaddq_f32(accum2V,wV);
+        blkCnt--;
+    }
+
+    tempV = vpadd_f32(vget_low_f32(accum1V),vget_high_f32(accum1V));
+    accum1 = tempV[0] + tempV[1];
+
+    tempV = vpadd_f32(vget_low_f32(accum2V),vget_high_f32(accum2V));
+    accum2 = tempV[0] + tempV[1];
+
+    blkCnt = blockSize & 3;
+    while(blkCnt > 0)
+    {
+        accum1 += *pIn++ * *pW;
+        accum2 += *pW++;
+        blkCnt--;
+    }
+
+
+    return(accum1 / accum2);
+}
+#else
+float32_t arm_weighted_sum_f32(const float32_t *in, const float32_t *weigths, uint32_t blockSize)
+{
+
+    float32_t accum1, accum2;
+    const float32_t *pIn, *pW;
+    uint32_t blkCnt;
+
+
+    pIn = in;
+    pW = weigths;
+
+    accum1=0.0;
+    accum2=0.0;
+
+    blkCnt = blockSize;
+    while(blkCnt > 0)
+    {
+        accum1 += *pIn++ * *pW;
+        accum2 += *pW++;
+        blkCnt--;
+    }
+
+    return(accum1 / accum2);
+}
+#endif
+/**
+ * @} end of groupSupport group
+ */
--- a/Testing/CMakeLists.txt
+++ b/Testing/CMakeLists.txt
@ -85,6 +85,8 @@ set(TESTSRC testmain.cpp
  Source/BasicMathsBenchmarksQ7.cpp
  Source/SVMF32.cpp
  Source/BayesF32.cpp
+  Source/StatsTestsF32.cpp
+  Source/SupportTestsF32.cpp
  Source/FullyConnected.cpp
  Source/FullyConnectedBench.cpp
  GeneratedSource/TestDesc.cpp
--- a/Testing/GeneratedInclude/Patterns.h
+++ b/Testing/GeneratedInclude/Patterns.h
--- a/Testing/GeneratedInclude/StatsTestsF32_decl.h
+++ b/Testing/GeneratedInclude/StatsTestsF32_decl.h
@ -0,0 +1,30 @@
+void test_entropy_f32();
+void test_logsumexp_f32();
+void test_kullback_leibler_f32();
+void test_logsumexp_dot_prod_f32();
+
+// Pattern IDs
+static const int INPUT1_F32_ID=0;
+static const int DIM1_S16_ID=1;
+static const int REF1_ENTROPY_F32_ID=2;
+static const int INPUT2_F32_ID=3;
+static const int DIM2_S16_ID=4;
+static const int REF2_LOGSUMEXP_F32_ID=5;
+static const int INPUTA3_F32_ID=6;
+static const int INPUTB3_F32_ID=7;
+static const int DIM3_S16_ID=8;
+static const int REF3_KL_F32_ID=9;
+static const int INPUTA4_F32_ID=10;
+static const int INPUTB4_F32_ID=11;
+static const int DIM4_S16_ID=12;
+static const int REF4_LOGSUMEXP_DOT_F32_ID=13;
+
+// Output IDs
+static const int OUT_F32_ID=0;
+static const int TMP_F32_ID=1;
+
+// Test IDs
+static const int TEST_ENTROPY_F32_1=1;
+static const int TEST_LOGSUMEXP_F32_2=2;
+static const int TEST_KULLBACK_LEIBLER_F32_3=3;
+static const int TEST_LOGSUMEXP_DOT_PROD_F32_4=4;
--- a/Testing/GeneratedInclude/SupportTestsF32_decl.h
+++ b/Testing/GeneratedInclude/SupportTestsF32_decl.h
@ -0,0 +1,19 @@
+void test_barycenter_f32();
+void test_weighted_sum_f32();
+
+// Pattern IDs
+static const int INPUTS1_F32_ID=0;
+static const int DIMS1_S16_ID=1;
+static const int WEIGHTS1_F32_ID=2;
+static const int REF1_F32_ID=3;
+static const int INPUTS2_F32_ID=4;
+static const int DIMS2_S16_ID=5;
+static const int WEIGHTS2_F32_ID=6;
+static const int REF2_F32_ID=7;
+
+// Output IDs
+static const int OUT_F32_ID=0;
+
+// Test IDs
+static const int TEST_BARYCENTER_F32_1=1;
+static const int TEST_WEIGHTED_SUM_F32_2=2;
--- a/Testing/GeneratedInclude/TestDesc.h
+++ b/Testing/GeneratedInclude/TestDesc.h
@ -1,32 +1,32 @@
 #include "Test.h"
 #include "Pattern.h"
-#include "BayesF32.h"
-class BayesTests : public Client::Group
+#include "SupportTestsF32.h"
+class SupportTests : public Client::Group
 {
   public:
-     BayesTests(Testing::testID_t id):Client::Group(id)
- ,BayesF32Var(1)
+     SupportTests(Testing::testID_t id):Client::Group(id)
+ ,SupportTestsF32Var(1)

     { 
-        this->addContainer(&BayesF32Var);
+        this->addContainer(&SupportTestsF32Var);

     }
    private:
-        BayesF32 BayesF32Var;
+        SupportTestsF32 SupportTestsF32Var;
 ;
 };
 class DSPTests : public Client::Group
 {
   public:
     DSPTests(Testing::testID_t id):Client::Group(id)
- ,BayesTestsVar(3)
+ ,SupportTestsVar(2)

     { 
-        this->addContainer(NULL);this->addContainer(NULL);this->addContainer(&BayesTestsVar);
-
+        this->addContainer(NULL);this->addContainer(&SupportTestsVar);
+this->addContainer(NULL);this->addContainer(NULL);this->addContainer(NULL);
     }
    private:
-        BayesTests BayesTestsVar;
+        SupportTests SupportTestsVar;
 ;
 };
 class Root : public Client::Group
--- a/Testing/GeneratedInclude/TestDrive.h
+++ b/Testing/GeneratedInclude/TestDrive.h
@ -8,29 +8,37 @@ __ALIGNED(8) const char testDesc[]={
 1,0,0,0,
 'n','y','D','S','P','\0',
 3,0,0,0,
-3,0,0,0,
-'n','y','B','a','y','e','s','\0',
+2,0,0,0,
+'n','y','S','u','p','p','o','r','t','\0',
 2,0,0,0,
 1,0,0,0,
-'n','y','B','a','y','e','s','F','3','2','\0',
+'n','y','S','u','p','p','o','r','t','F','3','2','\0',
 0,0,0,0,
-5,0,0,0,
+8,0,0,0,
 0,0,0,0,
+120,5,0,0,
+224,21,0,0,
 3,0,0,0,
-8,0,0,0,
+232,21,0,0,
+100,0,0,0,
+120,23,0,0,
 140,0,0,0,
-56,2,0,0,
-146,0,0,0,
-128,4,0,0,
-50,0,0,0,
-72,5,0,0,
-10,0,0,0,
+168,25,0,0,
+200,0,0,0,
+200,28,0,0,
 2,0,0,0,
-'P','r','o','b','a','s','\0',
-'P','r','e','d','i','c','t','s','\0',
+208,28,0,0,
+200,0,0,0,
+240,31,0,0,
+10,0,0,0,
+1,0,0,0,
+'O','u','t','p','u','t','\0',
 0,0,0,0,
 1,0,0,0,
 1,0,0,0,
 'n','n',
+1,0,0,0,
+2,0,0,0,
+'n','n',
 };
 #endif
--- a/Testing/GeneratedSource/TestDesc.cpp
+++ b/Testing/GeneratedSource/TestDesc.cpp
@ -1,8 +1,9 @@
 #include "Test.h"

-#include "BayesF32.h"
-    BayesF32::BayesF32(Testing::testID_t id):Client::Suite(id)
+#include "SupportTestsF32.h"
+    SupportTestsF32::SupportTestsF32(Testing::testID_t id):Client::Suite(id)
    {
-        this->addTest(1,(Client::test)&BayesF32::test_gaussian_naive_bayes_predict_f32);
+        this->addTest(1,(Client::test)&SupportTestsF32::test_barycenter_f32);
+this->addTest(2,(Client::test)&SupportTestsF32::test_weighted_sum_f32);

    }
--- a/Testing/Include/StatsTestsF32.h
+++ b/Testing/Include/StatsTestsF32.h
@ -0,0 +1,27 @@
+#include "Test.h"
+#include "Pattern.h"
+class StatsTestsF32:public Client::Suite
+    {
+        public:
+            StatsTestsF32(Testing::testID_t id);
+            void setUp(Testing::testID_t,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr);
+            void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "StatsTestsF32_decl.h"
+            
+            Client::Pattern<float32_t> inputA;
+            Client::Pattern<float32_t> inputB;
+            Client::Pattern<int16_t> dims;
+
+            Client::LocalPattern<float32_t> output;
+            Client::LocalPattern<float32_t> tmp;
+
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<float32_t> ref;
+
+            int nbPatterns;
+            int vecDim;
+
+           
+
+    };
--- a/Testing/Include/SupportTestsF32.h
+++ b/Testing/Include/SupportTestsF32.h
@ -0,0 +1,27 @@
+#include "Test.h"
+#include "Pattern.h"
+class SupportTestsF32:public Client::Suite
+    {
+        public:
+            SupportTestsF32(Testing::testID_t id);
+            void setUp(Testing::testID_t,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr);
+            void tearDown(Testing::testID_t,Client::PatternMgr *mgr);
+        private:
+            #include "SupportTestsF32_decl.h"
+            
+            Client::Pattern<float32_t> input;
+            Client::Pattern<float32_t> coefs;
+            Client::Pattern<int16_t> dims;
+
+            Client::LocalPattern<float32_t> output;
+
+            // Reference patterns are not loaded when we are in dump mode
+            Client::RefPattern<float32_t> ref;
+
+            int vecDim;
+            int nbPatterns;
+            int nbVectors;
+
+           
+
+    };
--- a/Testing/Output/DSP/Stats/StatsF32/Output_1.txt
+++ b/Testing/Output/DSP/Stats/StatsF32/Output_1.txt
@ -0,0 +1,10 @@
+0x401ae843
+0x401e4a55
+0x4012db14
+0x401c29fe
+0x4010f7d4
+0x401a117c
+0x4021c4f2
+0x402484ef
+0x401afb9b
+0x401d2ddb
--- a/Testing/Output/DSP/Stats/StatsF32/Output_2.txt
+++ b/Testing/Output/DSP/Stats/StatsF32/Output_2.txt
@ -0,0 +1,10 @@
+0x4042f2f9
+0x4042f30e
+0x4042fa4e
+0x4042ef8e
+0x4042f2ba
+0x4042f3a3
+0x4042f198
+0x4042f27a
+0x4042f3ae
+0x4042f33f
--- a/Testing/Output/DSP/Stats/StatsF32/Output_3.txt
+++ b/Testing/Output/DSP/Stats/StatsF32/Output_3.txt
@ -0,0 +1,10 @@
+0x3f751811
+0x3ed01c22
+0x3eb6ebe3
+0x3f2fcb50
+0x3ee59dc6
+0x3e52b16c
+0x3f100d62
+0x3f1b4d00
+0x3e9681e9
+0x3e757fd8
--- a/Testing/Output/DSP/Stats/StatsF32/Output_4.txt
+++ b/Testing/Output/DSP/Stats/StatsF32/Output_4.txt
@ -0,0 +1,10 @@
+0xc028b15a
+0xc02503e3
+0xc02bd4e1
+0xc027c558
+0xc02a7f3f
+0xc0213507
+0xc02958d2
+0xc02a74f2
+0xc0218d7f
+0xc02a4ab4
--- a/Testing/Output/DSP/Support/SupportF32/Output_1.txt
+++ b/Testing/Output/DSP/Support/SupportF32/Output_1.txt
@ -0,0 +1,140 @@
+0x3ecb1758
+0x3efa1868
+0x3f108d5d
+0x3e970961
+0x3f0989c1
+0x3ed08f29
+0x3eaa1fa0
+0x3eb744e4
+0x3f0854f9
+0x3f07a424
+0x3efb241b
+0x3ef5935d
+0x3f03ac07
+0x3ec4b299
+0x3f159fac
+0x3f007587
+0x3ec10ee1
+0x3ed893ed
+0x3f0dc752
+0x3edc89f6
+0x3f0bff7a
+0x3f201032
+0x3f016f98
+0x3f2eb21a
+0x3f07f8da
+0x3f1e0ac9
+0x3f233364
+0x3ebbe3ac
+0x3f1612f2
+0x3f289919
+0x3f29692f
+0x3f1625ad
+0x3f030018
+0x3ece57a2
+0x3f1a5c31
+0x3ed4ea48
+0x3ef41088
+0x3ee4d923
+0x3ebde95f
+0x3f0c56f2
+0x3f060859
+0x3ea86348
+0x3f1794ec
+0x3f12374b
+0x3ed6e2df
+0x3ee24abb
+0x3ee92a5d
+0x3ec2cdf8
+0x3f046f70
+0x3f10ebb2
+0x3f13e5bc
+0x3eedd520
+0x3f0d98e4
+0x3f4ba8c7
+0x3ed25c55
+0x3f099b6b
+0x3e4592b7
+0x3eafa84a
+0x3f19622e
+0x3f0333a9
+0x3f3fb9ef
+0x3ee2992c
+0x3f1da533
+0x3e5336d0
+0x3e9178c0
+0x3edc1abd
+0x3f1e7dbe
+0x3f32fd6b
+0x3f0aeb4b
+0x3ee8226e
+0x3eb57e7d
+0x3e198b47
+0x3f1c5515
+0x3e71d915
+0x3e977080
+0x3ef8f068
+0x3ec54490
+0x3ece7d1e
+0x3e995ca2
+0x3ee4a7da
+0x3f1d332e
+0x3f025430
+0x3f2db2a4
+0x3e93b099
+0x3f14a044
+0x3ee02e2b
+0x3eee0fba
+0x3f0d00fb
+0x3f0cf9f7
+0x3f05fcc2
+0x3eb8dfbc
+0x3ed73290
+0x3ef1fadf
+0x3f050159
+0x3ea45a88
+0x3ef3e487
+0x3f129341
+0x3f0a8287
+0x3edf89b2
+0x3f09e25e
+0x3f0f71ed
+0x3f177ecc
+0x3f208375
+0x3edf972b
+0x3f2b47d7
+0x3f15d210
+0x3f196a03
+0x3e9872e7
+0x3eff2859
+0x3f13fb21
+0x3f02eb26
+0x3ed7d632
+0x3f0d9c57
+0x3eba911d
+0x3ef46ecc
+0x3f113c4c
+0x3eeee305
+0x3f06237d
+0x3efd0cbf
+0x3efbe3b8
+0x3f2294f0
+0x3f0353f7
+0x3ecb0a4e
+0x3efa74c7
+0x3f0425c2
+0x3ec93370
+0x3ef5abb9
+0x3eef5d8c
+0x3eca3775
+0x3f14e046
+0x3f0087e8
+0x3f17d0d2
+0x3ec9e720
+0x3ef5cdad
+0x3f020c09
+0x3f14ed0e
+0x3f0dabf0
+0x3f06084a
+0x3efc104f
+0x3eeeb652
--- a/Testing/Output/DSP/Support/SupportF32/Output_2.txt
+++ b/Testing/Output/DSP/Support/SupportF32/Output_2.txt
@ -0,0 +1,10 @@
+0x3eaddab7
+0x3f1705f4
+0x3f0eaf4a
+0x3efd997e
+0x3f0e3547
+0x3ead87b6
+0x3ef3c4dd
+0x3eeb167c
+0x3ef2eef8
+0x3f096e03
--- a/Testing/PatternGeneration/Stats.py
+++ b/Testing/PatternGeneration/Stats.py
@ -0,0 +1,115 @@
+import os.path
+import itertools
+import Tools
+import random
+import numpy as np
+import scipy
+import scipy.stats
+
+NBTESTS = 10
+VECDIM = [12,14,20]
+
+def entropyTest(config,nb):
+    inputs = [] 
+    outputs = [] 
+    vecDim = VECDIM[nb % len(VECDIM)]
+    dims=np.array([NBTESTS,vecDim])
+    for _ in range(0,NBTESTS):
+       v = np.random.rand(vecDim)
+       v = v / np.sum(v)
+       e = scipy.stats.entropy(v)
+       inputs += list(v)
+       outputs.append(e)
+    inputs = np.array(inputs)
+    outputs = np.array(outputs)
+    config.writeInput(nb, inputs,"Input")
+    config.writeInputS16(nb, dims,"Dims")
+    config.writeReference(nb, outputs,"RefEntropy")
+
+def logsumexpTest(config,nb):
+    inputs = [] 
+    outputs = [] 
+    vecDim = VECDIM[nb % len(VECDIM)]
+    dims=np.array([NBTESTS,vecDim])
+    for _ in range(0,NBTESTS):
+       v = np.random.rand(vecDim)
+       v = v / np.sum(v)
+       e = scipy.special.logsumexp(v)
+       inputs += list(v)
+       outputs.append(e)
+    inputs = np.array(inputs)
+    outputs = np.array(outputs)
+    config.writeInput(nb, inputs,"Input")
+    config.writeInputS16(nb, dims,"Dims")
+    config.writeReference(nb, outputs,"RefLogSumExp")
+
+def klTest(config,nb):
+    inputsA = [] 
+    inputsB = [] 
+    outputs = [] 
+    vecDim = VECDIM[nb % len(VECDIM)]
+    dims=np.array([NBTESTS,vecDim])
+    for _ in range(0,NBTESTS):
+       va = np.random.rand(vecDim)
+       va = va / np.sum(va)
+
+       vb = np.random.rand(vecDim)
+       vb = vb / np.sum(vb)
+
+       e = scipy.stats.entropy(va,vb)
+       inputsA += list(va)
+       inputsB += list(vb)
+       outputs.append(e)
+    inputsA = np.array(inputsA)
+    inputsB = np.array(inputsB)
+    outputs = np.array(outputs)
+    config.writeInput(nb, inputsA,"InputA")
+    config.writeInput(nb, inputsB,"InputB")
+    config.writeInputS16(nb, dims,"Dims")
+    config.writeReference(nb, outputs,"RefKL")
+
+def logSumExpDotTest(config,nb):
+    inputsA = [] 
+    inputsB = [] 
+    outputs = [] 
+    vecDim = VECDIM[nb % len(VECDIM)]
+    dims=np.array([NBTESTS,vecDim])
+    for _ in range(0,NBTESTS):
+       va = np.random.rand(vecDim)
+       va = va / np.sum(va)
+
+       vb = np.random.rand(vecDim)
+       vb = vb / np.sum(vb)
+
+       d = 0.001
+       # It is a proba so must be in [0,1]
+       # But restricted to ]d,1] so that the log exists
+       va = (1-d)*va + d
+       vb = (1-d)*vb + d
+       e = np.log(np.dot(va,vb))
+       va = np.log(va)
+       vb = np.log(vb)
+
+       inputsA += list(va)
+       inputsB += list(vb)
+       outputs.append(e)
+    inputsA = np.array(inputsA)
+    inputsB = np.array(inputsB)
+    outputs = np.array(outputs)
+    config.writeInput(nb, inputsA,"InputA")
+    config.writeInput(nb, inputsB,"InputB")
+    config.writeInputS16(nb, dims,"Dims")
+    config.writeReference(nb, outputs,"RefLogSumExpDot")
+
+def writeTests(config):
+    entropyTest(config,1)
+    logsumexpTest(config,2)
+    klTest(config,3)
+    logSumExpDotTest(config,4)
+
+PATTERNDIR = os.path.join("Patterns","DSP","Stats","Stats")
+PARAMDIR = os.path.join("Parameters","DSP","Stats","Stats")
+
+configf32=Tools.Config(PATTERNDIR,PARAMDIR,"f32")
+
+writeTests(configf32)
--- a/Testing/PatternGeneration/Support.py
+++ b/Testing/PatternGeneration/Support.py
@ -0,0 +1,84 @@
+import os.path
+import itertools
+import Tools
+import random
+import numpy as np
+
+NBTESTSAMPLES = 10
+
+# Nb vectors for barycenter
+NBVECTORS = [4,10,16]
+
+VECDIM = [12,14,20]
+
+def genWsum(config,nb):
+    dims=[] 
+    inputs=[] 
+    weights=[]
+    output=[] 
+    vecDim = VECDIM[nb % len(VECDIM)]
+
+    dims.append(NBTESTSAMPLES)
+    dims.append(vecDim)
+
+    for _ in range(0,NBTESTSAMPLES):
+      va = np.random.rand(vecDim)
+      vb = np.random.rand(vecDim)
+      e = np.sum(va.T * vb) / np.sum(vb) 
+      inputs += list(va)
+      weights += list(vb)
+      output.append(e)
+    inputs=np.array(inputs)
+    weights=np.array(weights)
+    output=np.array(output)
+    config.writeInput(nb, inputs,"Inputs")
+    config.writeInputS16(nb, dims,"Dims")
+    config.writeInput(nb, weights,"Weights")
+    config.writeReference(nb, output,"Ref")
+
+def genBarycenter(config,nb):
+    dims=[] 
+    inputs=[] 
+    weights=[]
+    output=[] 
+    vecDim = VECDIM[nb % len(VECDIM)]
+    nbVecs = NBVECTORS[nb % len(NBVECTORS)]
+
+    dims.append(NBTESTSAMPLES)
+    dims.append(nbVecs)
+    dims.append(vecDim)
+
+    for _ in range(0,NBTESTSAMPLES):
+      
+      vecs = []
+      b = np.zeros(vecDim)
+      coefs = np.random.rand(nbVecs)
+  
+      for i in range(nbVecs):
+            va = np.random.rand(vecDim)
+            b += va * coefs[i]
+            vecs += list(va)
+                     
+      b = b / np.sum(coefs)
+     
+      inputs += list(vecs)
+      weights += list(coefs)
+      output += list(b)
+    inputs=np.array(inputs)
+    weights=np.array(weights)
+    output=np.array(output)
+    config.writeInput(nb, inputs,"Inputs")
+    config.writeInputS16(nb, dims,"Dims")
+    config.writeInput(nb, weights,"Weights")
+    config.writeReference(nb, output,"Ref")
+
+def writeTests(config):
+    genBarycenter(config,1)
+    genWsum(config,2)
+
+PATTERNDIR = os.path.join("Patterns","DSP","Support","Support")
+PARAMDIR = os.path.join("Parameters","DSP","Support","Support")
+
+configf32=Tools.Config(PATTERNDIR,PARAMDIR,"f32")
+
+writeTests(configf32)
--- a/Testing/Patterns/DSP/Stats/StatsF32/Dims1_s16.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/Dims1_s16.txt
@ -0,0 +1,6 @@
+H
+2
+// 10
+0x000A
+// 14
+0x000E
--- a/Testing/Patterns/DSP/Stats/StatsF32/Dims2_s16.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/Dims2_s16.txt
@ -0,0 +1,6 @@
+H
+2
+// 10
+0x000A
+// 20
+0x0014
--- a/Testing/Patterns/DSP/Stats/StatsF32/Dims3_s16.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/Dims3_s16.txt
@ -0,0 +1,6 @@
+H
+2
+// 10
+0x000A
+// 12
+0x000C
--- a/Testing/Patterns/DSP/Stats/StatsF32/Dims4_s16.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/Dims4_s16.txt
@ -0,0 +1,6 @@
+H
+2
+// 10
+0x000A
+// 14
+0x000E
--- a/Testing/Patterns/DSP/Stats/StatsF32/Input1_f32.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/Input1_f32.txt
@ -0,0 +1,282 @@
+W
+140
+// 0.096126
+0x3dc4ddd0
+// 0.054879
+0x3d60c8d1
+// 0.035373
+0x3d10e2d3
+// 0.080156
+0x3da428ff
+// 0.015274
+0x3c7a4135
+// 0.123553
+0x3dfd0939
+// 0.020653
+0x3ca9303a
+// 0.101714
+0x3dd04f6e
+// 0.040169
+0x3d24885b
+// 0.138936
+0x3e0e4521
+// 0.129785
+0x3e04e66e
+// 0.015031
+0x3c764619
+// 0.024280
+0x3cc6e608
+// 0.124071
+0x3dfe18f2
+// 0.015211
+0x3c793604
+// 0.077605
+0x3d9eef79
+// 0.093893
+0x3dc04ac8
+// 0.049594
+0x3d4b2324
+// 0.074563
+0x3d98b488
+// 0.069522
+0x3d8e6150
+// 0.108617
+0x3dde72c5
+// 0.119865
+0x3df57ba7
+// 0.051507
+0x3d52f88b
+// 0.008593
+0x3c0cc915
+// 0.122105
+0x3dfa1248
+// 0.085292
+0x3daeadd3
+// 0.107960
+0x3ddd1a01
+// 0.015674
+0x3c806693
+// 0.161033
+0x3e24e5bf
+// 0.002654
+0x3b2df0d7
+// 0.012806
+0x3c51d19c
+// 0.014205
+0x3c68baac
+// 0.164592
+0x3e288ad7
+// 0.068758
+0x3d8cd0d6
+// 0.110863
+0x3de30c30
+// 0.135928
+0x3e0b30c9
+// 0.011206
+0x3c379b4c
+// 0.120655
+0x3df71a21
+// 0.010775
+0x3c3088b6
+// 0.062895
+0x3d80cf41
+// 0.062579
+0x3d802954
+// 0.061050
+0x3d7a0fed
+// 0.031948
+0x3d02db7d
+// 0.024362
+0x3cc79334
+// 0.101570
+0x3dd003c0
+// 0.103529
+0x3dd406de
+// 0.090873
+0x3dba1bde
+// 0.004786
+0x3b9cd3f3
+// 0.046927
+0x3d4036e2
+// 0.004842
+0x3b9eabbb
+// 0.068125
+0x3d8b8542
+// 0.090070
+0x3db876c0
+// 0.126675
+0x3e01b719
+// 0.110761
+0x3de2d6c2
+// 0.103435
+0x3dd3d58c
+// 0.092096
+0x3dbc9d0b
+// 0.145594
+0x3e151688
+// 0.126616
+0x3e01a7b0
+// 0.024383
+0x3cc7be82
+// 0.015570
+0x3c7f194e
+// 0.053057
+0x3d59522e
+// 0.058314
+0x3d6eda75
+// 0.044683
+0x3d3705de
+// 0.150977
+0x3e1a99c4
+// 0.107335
+0x3ddbd265
+// 0.172803
+0x3e30f326
+// 0.003024
+0x3b462896
+// 0.004310
+0x3b8d3e21
+// 0.003969
+0x3b820a96
+// 0.089366
+0x3db7057b
+// 0.102876
+0x3dd2b07e
+// 0.083029
+0x3daa0b3f
+// 0.059170
+0x3d725c12
+// 0.016977
+0x3c8b1456
+// 0.146734
+0x3e164174
+// 0.015161
+0x3c7864b9
+// 0.082400
+0x3da8c178
+// 0.026597
+0x3cd9e1fd
+// 0.036095
+0x3d13d7f2
+// 0.124590
+0x3dff28d1
+// 0.132641
+0x3e07d32c
+// 0.128042
+0x3e031d85
+// 0.020782
+0x3caa3ee9
+// 0.024906
+0x3ccc0724
+// 0.055786
+0x3d64805a
+// 0.039608
+0x3d223be6
+// 0.103623
+0x3dd4382c
+// 0.024213
+0x3cc65ade
+// 0.051646
+0x3d538b20
+// 0.094721
+0x3dc1fd45
+// 0.130185
+0x3e054f49
+// 0.065448
+0x3d860968
+// 0.099440
+0x3dcba70e
+// 0.120493
+0x3df6c54b
+// 0.074504
+0x3d9895c3
+// 0.044909
+0x3d37f2e2
+// 0.072976
+0x3d957479
+// 0.022446
+0x3cb7e0a3
+// 0.087826
+0x3db3de05
+// 0.070806
+0x3d9102ca
+// 0.039142
+0x3d205330
+// 0.068876
+0x3d8d0efc
+// 0.095886
+0x3dc45ff9
+// 0.046935
+0x3d403ecc
+// 0.104755
+0x3dd689c1
+// 0.085944
+0x3db00346
+// 0.025268
+0x3cceffcb
+// 0.051143
+0x3d517b83
+// 0.053822
+0x3d5c74eb
+// 0.108343
+0x3ddde2fa
+// 0.058181
+0x3d6e4f44
+// 0.103072
+0x3dd31772
+// 0.121733
+0x3df94eef
+// 0.097422
+0x3dc784fb
+// 0.048325
+0x3d45f022
+// 0.021655
+0x3cb165fd
+// 0.043063
+0x3d306264
+// 0.074061
+0x3d97ad50
+// 0.117680
+0x3df10229
+// 0.114582
+0x3deaa9d9
+// 0.122754
+0x3dfb6661
+// 0.060175
+0x3d7679b7
+// 0.049308
+0x3d49f78d
+// 0.119300
+0x3df453b6
+// 0.003159
+0x3b4f03c2
+// 0.006785
+0x3bde52a3
+// 0.117153
+0x3defee00
+// 0.019708
+0x3ca171c9
+// 0.082308
+0x3da8914b
+// 0.061496
+0x3d7be378
+// 0.039050
+0x3d1ff2f3
+// 0.036299
+0x3d14ae53
+// 0.104578
+0x3dd62cfa
+// 0.038682
+0x3d1e70e8
+// 0.002466
+0x3b219720
+// 0.146722
+0x3e163e5b
+// 0.076524
+0x3d9cb864
+// 0.060454
+0x3d779e40
+// 0.101473
+0x3dcfd10e
+// 0.113088
+0x3de79a73
--- a/Testing/Patterns/DSP/Stats/StatsF32/Input2_f32.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/Input2_f32.txt
@ -0,0 +1,402 @@
+W
+200
+// 0.056235
+0x3d66572c
+// 0.077805
+0x3d9f5833
+// 0.043943
+0x3d33fd8f
+// 0.063779
+0x3d829e5c
+// 0.064986
+0x3d851773
+// 0.054177
+0x3d5de8d5
+// 0.037718
+0x3d1a7ea1
+// 0.060158
+0x3d7667c4
+// 0.086482
+0x3db11d8a
+// 0.082833
+0x3da9a440
+// 0.050966
+0x3d50c1f6
+// 0.005996
+0x3bc47d21
+// 0.087289
+0x3db2c47c
+// 0.016967
+0x3c8aff60
+// 0.014258
+0x3c699986
+// 0.026259
+0x3cd71c4d
+// 0.077756
+0x3d9f3eb9
+// 0.018830
+0x3c9a4143
+// 0.008146
+0x3c05756c
+// 0.065417
+0x3d85f91d
+// 0.017280
+0x3c8d8f86
+// 0.006173
+0x3bca442f
+// 0.031528
+0x3d0123fb
+// 0.045332
+0x3d39ada6
+// 0.060593
+0x3d782fef
+// 0.012308
+0x3c49a7dc
+// 0.059121
+0x3d72295e
+// 0.070851
+0x3d911a18
+// 0.084293
+0x3daca201
+// 0.101793
+0x3dd078a1
+// 0.038845
+0x3d1f1be0
+// 0.063282
+0x3d819a1c
+// 0.013683
+0x3c603040
+// 0.061395
+0x3d7b7990
+// 0.049085
+0x3d490ce0
+// 0.074528
+0x3d98a234
+// 0.053696
+0x3d5bf0af
+// 0.083965
+0x3dabf60c
+// 0.014367
+0x3c6b6278
+// 0.057881
+0x3d6d14f9
+// 0.075077
+0x3d99c22b
+// 0.063741
+0x3d828ac9
+// 0.006331
+0x3bcf70fc
+// 0.062521
+0x3d800ad1
+// 0.014482
+0x3c6d47e5
+// 0.000047
+0x38464452
+// 0.081241
+0x3da66174
+// 0.021053
+0x3cac77f4
+// 0.026764
+0x3cdb4023
+// 0.116510
+0x3dee9c96
+// 0.013493
+0x3c5d10e5
+// 0.089995
+0x3db84f41
+// 0.000171
+0x3932fbe2
+// 0.086223
+0x3db09572
+// 0.106877
+0x3ddae292
+// 0.004089
+0x3b85fa3a
+// 0.057155
+0x3d6a1b1c
+// 0.111539
+0x3de46eaf
+// 0.060647
+0x3d7868ea
+// 0.002045
+0x3b060414
+// 0.060276
+0x3d76e424
+// 0.003055
+0x3b483ae7
+// 0.040906
+0x3d278d5c
+// 0.061561
+0x3d7c27de
+// 0.035198
+0x3d102bbc
+// 0.069424
+0x3d8e2e1f
+// 0.055495
+0x3d634e71
+// 0.060152
+0x3d7661c2
+// 0.059809
+0x3d74f9f8
+// 0.056055
+0x3d659a1e
+// 0.056583
+0x3d67c319
+// 0.038416
+0x3d1d5a6d
+// 0.038873
+0x3d1f39bc
+// 0.051058
+0x3d5121fb
+// 0.064343
+0x3d83c630
+// 0.045519
+0x3d3a71f1
+// 0.044943
+0x3d3815ad
+// 0.061532
+0x3d7c088b
+// 0.020923
+0x3cab678f
+// 0.075879
+0x3d9b6692
+// 0.011548
+0x3c3d3392
+// 0.070785
+0x3d90f7d7
+// 0.054558
+0x3d5f77d9
+// 0.013389
+0x3c5b5bbc
+// 0.014933
+0x3c74ab8e
+// 0.015557
+0x3c7ee3ca
+// 0.085977
+0x3db014d6
+// 0.051554
+0x3d5329da
+// 0.090497
+0x3db9567a
+// 0.034857
+0x3d0ec5e8
+// 0.067221
+0x3d89ab4d
+// 0.094795
+0x3dc223f3
+// 0.050355
+0x3d4e409a
+// 0.047586
+0x3d42e96c
+// 0.048152
+0x3d453b73
+// 0.035092
+0x3d0fbc77
+// 0.032954
+0x3d06fadd
+// 0.061213
+0x3d7aba1d
+// 0.084998
+0x3dae134c
+// 0.033980
+0x3d0b2e6a
+// 0.038308
+0x3d1ce87d
+// 0.037561
+0x3d19d98c
+// 0.018229
+0x3c955521
+// 0.050508
+0x3d4ee1e7
+// 0.080445
+0x3da4c042
+// 0.081487
+0x3da6e2ad
+// 0.006107
+0x3bc81974
+// 0.051214
+0x3d51c5ff
+// 0.098546
+0x3dc9d293
+// 0.095200
+0x3dc2f864
+// 0.081929
+0x3da7ca61
+// 0.028955
+0x3ced33e2
+// 0.045321
+0x3d39a24d
+// 0.034107
+0x3d0bb37d
+// 0.035228
+0x3d104b96
+// 0.013547
+0x3c5df3d7
+// 0.030927
+0x3cfd5af4
+// 0.078610
+0x3da0fe78
+// 0.073860
+0x3d9743a9
+// 0.019911
+0x3ca31b7c
+// 0.042311
+0x3d2d4e09
+// 0.019992
+0x3ca3c590
+// 0.061218
+0x3d7ac03d
+// 0.067824
+0x3d8ae749
+// 0.056913
+0x3d691d90
+// 0.033024
+0x3d0744b1
+// 0.013628
+0x3c5f48e1
+// 0.011932
+0x3c437fc1
+// 0.020891
+0x3cab22c3
+// 0.081911
+0x3da7c0fe
+// 0.081018
+0x3da5ec91
+// 0.036514
+0x3d159006
+// 0.067579
+0x3d8a66dc
+// 0.025495
+0x3cd0db37
+// 0.081557
+0x3da70744
+// 0.050548
+0x3d4f0bad
+// 0.054135
+0x3d5dbd04
+// 0.064251
+0x3d83962e
+// 0.049079
+0x3d490732
+// 0.080179
+0x3da434aa
+// 0.017069
+0x3c8bd443
+// 0.032430
+0x3d04d4ee
+// 0.040662
+0x3d268cd9
+// 0.003388
+0x3b5e07db
+// 0.047310
+0x3d41c7dd
+// 0.027722
+0x3ce31980
+// 0.074089
+0x3d97bc1f
+// 0.054994
+0x3d614168
+// 0.096348
+0x3dc55252
+// 0.064836
+0x3d84c8fd
+// 0.015399
+0x3c7c4d7b
+// 0.072098
+0x3d93a81f
+// 0.058293
+0x3d6ec516
+// 0.037538
+0x3d19c0fb
+// 0.059715
+0x3d749806
+// 0.063750
+0x3d828f81
+// 0.018897
+0x3c9ace2b
+// 0.067245
+0x3d89b7d6
+// 0.052338
+0x3d566066
+// 0.095878
+0x3dc45b6d
+// 0.055513
+0x3d63620e
+// 0.063981
+0x3d8308b2
+// 0.045226
+0x3d393ea6
+// 0.073588
+0x3d96b511
+// 0.037877
+0x3d1b2473
+// 0.082377
+0x3da8b57c
+// 0.087027
+0x3db23b4a
+// 0.008888
+0x3c119e14
+// 0.086347
+0x3db0d6c6
+// 0.064021
+0x3d831d65
+// 0.067012
+0x3d893d95
+// 0.019129
+0x3c9cb3f2
+// 0.033592
+0x3d0997b0
+// 0.018059
+0x3c93ef83
+// 0.028626
+0x3cea8107
+// 0.075945
+0x3d9b8944
+// 0.076121
+0x3d9be56e
+// 0.000857
+0x3a60a1c1
+// 0.069906
+0x3d8f2aad
+// 0.005909
+0x3bc19c70
+// 0.092776
+0x3dbe016e
+// 0.040213
+0x3d24b6c8
+// 0.021631
+0x3cb13284
+// 0.093571
+0x3dbfa23a
+// 0.023001
+0x3cbc6d0b
+// 0.074200
+0x3d97f63e
+// 0.061399
+0x3d7b7df3
+// 0.055935
+0x3d651c2f
+// 0.044264
+0x3d354ddd
+// 0.030839
+0x3cfca237
+// 0.010192
+0x3c26fd09
+// 0.094557
+0x3dc1a758
+// 0.054240
+0x3d5e2b02
+// 0.035270
+0x3d1077af
+// 0.080850
+0x3da594ad
+// 0.044644
+0x3d36dc90
+// 0.027236
+0x3cdf1cff
+// 0.044468
+0x3d3623b0
+// 0.001583
+0x3acf71c8
+// 0.069130
+0x3d8d9421
--- a/Testing/Patterns/DSP/Stats/StatsF32/InputA3_f32.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/InputA3_f32.txt
@ -0,0 +1,242 @@
+W
+120
+// 0.006047
+0x3bc628bc
+// 0.126348
+0x3e01615a
+// 0.132721
+0x3e07e81b
+// 0.079188
+0x3da22d7c
+// 0.052569
+0x3d575298
+// 0.053801
+0x3d5c5df9
+// 0.111303
+0x3de3f2bd
+// 0.036834
+0x3d16df24
+// 0.145668
+0x3e152a00
+// 0.031233
+0x3cffdce9
+// 0.131107
+0x3e0640c9
+// 0.093181
+0x3dbed5ab
+// 0.091800
+0x3dbc019a
+// 0.167721
+0x3e2bbf04
+// 0.085843
+0x3dafce3b
+// 0.058460
+0x3d6f73af
+// 0.144506
+0x3e13f96c
+// 0.029775
+0x3cf3eaaf
+// 0.020261
+0x3ca5f9d1
+// 0.001844
+0x3af1a775
+// 0.073163
+0x3d95d66e
+// 0.179610
+0x3e37eba3
+// 0.007988
+0x3c02dfb6
+// 0.139031
+0x3e0e5e06
+// 0.106405
+0x3dd9eaa2
+// 0.000267
+0x398bd62b
+// 0.098791
+0x3dca52bc
+// 0.118489
+0x3df2aa84
+// 0.022028
+0x3cb473f4
+// 0.060337
+0x3d77241c
+// 0.056541
+0x3d6797b3
+// 0.036456
+0x3d1552fb
+// 0.147647
+0x3e1730cc
+// 0.156344
+0x3e2018b2
+// 0.123088
+0x3dfc155e
+// 0.073608
+0x3d96bf8c
+// 0.012738
+0x3c50b3c7
+// 0.127402
+0x3e0275c6
+// 0.019504
+0x3c9fc654
+// 0.202326
+0x3e4f2e8f
+// 0.024988
+0x3cccb3af
+// 0.183719
+0x3e3c20b9
+// 0.179076
+0x3e375f97
+// 0.138144
+0x3e0d75a8
+// 0.010974
+0x3c33caea
+// 0.084679
+0x3dad6bf1
+// 0.007287
+0x3beec8c1
+// 0.009164
+0x3c162495
+// 0.019588
+0x3ca076e6
+// 0.071888
+0x3d9339f6
+// 0.103017
+0x3dd2fa67
+// 0.052992
+0x3d590e5d
+// 0.062562
+0x3d8020be
+// 0.032107
+0x3d0382bb
+// 0.122831
+0x3dfb8eb7
+// 0.123690
+0x3dfd511f
+// 0.146890
+0x3e166a73
+// 0.003692
+0x3b71f9b4
+// 0.034373
+0x3d0ccae1
+// 0.226369
+0x3e67cd53
+// 0.055306
+0x3d62882b
+// 0.111249
+0x3de3d67e
+// 0.114484
+0x3dea7688
+// 0.043314
+0x3d3169ad
+// 0.081992
+0x3da7eb7f
+// 0.028787
+0x3cebd2b2
+// 0.137284
+0x3e0c941c
+// 0.101281
+0x3dcf6c63
+// 0.153498
+0x3e1d2e77
+// 0.006570
+0x3bd74669
+// 0.063099
+0x3d8139dc
+// 0.103138
+0x3dd33a17
+// 0.070770
+0x3d90f00b
+// 0.138918
+0x3e0e4075
+// 0.026604
+0x3cd9efa8
+// 0.073999
+0x3d978ce7
+// 0.044662
+0x3d36ef23
+// 0.010329
+0x3c293b9d
+// 0.154825
+0x3e1e8a61
+// 0.108104
+0x3ddd65be
+// 0.172945
+0x3e31189b
+// 0.131701
+0x3e06dc8f
+// 0.018779
+0x3c99d6c5
+// 0.048364
+0x3d461960
+// 0.004625
+0x3b9790d5
+// 0.017069
+0x3c8bd34c
+// 0.052701
+0x3d57dd21
+// 0.174354
+0x3e3289cd
+// 0.012914
+0x3c539477
+// 0.067136
+0x3d897ec8
+// 0.106958
+0x3ddb0cf0
+// 0.111712
+0x3de4c94f
+// 0.107299
+0x3ddbbf6a
+// 0.108561
+0x3dde5535
+// 0.125588
+0x3e009a1d
+// 0.111083
+0x3de37f86
+// 0.119331
+0x3df46406
+// 0.032154
+0x3d03b40b
+// 0.122062
+0x3df9fbcb
+// 0.136589
+0x3e0bddeb
+// 0.034387
+0x3d0cd9a8
+// 0.021967
+0x3cb3f40a
+// 0.131967
+0x3e07227a
+// 0.082378
+0x3da8b5ab
+// 0.125468
+0x3e007a9e
+// 0.013779
+0x3c61c0f3
+// 0.086054
+0x3db03d01
+// 0.093864
+0x3dc03b84
+// 0.155477
+0x3e1f355a
+// 0.131485
+0x3e06a3e2
+// 0.102287
+0x3dd17ba6
+// 0.061280
+0x3d7b0122
+// 0.104429
+0x3dd5dea7
+// 0.014807
+0x3c729aae
+// 0.022420
+0x3cb7aacd
+// 0.093206
+0x3dbee2b8
+// 0.037411
+0x3d193bf3
+// 0.138661
+0x3e0dfd3a
+// 0.109075
+0x3ddf6291
+// 0.029463
+0x3cf15baf
--- a/Testing/Patterns/DSP/Stats/StatsF32/InputA4_f32.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/InputA4_f32.txt
@ -0,0 +1,282 @@
+W
+140
+// -2.937437
+0xc03bfef9
+// -2.319812
+0xc01477cb
+// -2.122321
+0xc007d41b
+// -2.132953
+0xc008824d
+// -3.902897
+0xc079c912
+// -2.485666
+0xc01f1525
+// -4.837458
+0xc09acc75
+// -2.200258
+0xc00cd109
+// -2.456678
+0xc01d3a37
+// -3.386361
+0xc058ba22
+// -2.968888
+0xc03e0244
+// -4.159550
+0xc0851b08
+// -2.225123
+0xc00e686c
+// -2.237442
+0xc00f323e
+// -3.657517
+0xc06a14c3
+// -2.159819
+0xc00a3a79
+// -2.212901
+0xc00da02b
+// -4.361059
+0xc08b8dcb
+// -2.275099
+0xc0119b3b
+// -2.597107
+0xc02636ff
+// -2.722921
+0xc02e4457
+// -2.461961
+0xc01d90c4
+// -3.440021
+0xc05c294c
+// -2.342257
+0xc015e78a
+// -3.155328
+0xc049f0e6
+// -2.345418
+0xc0161b54
+// -2.688389
+0xc02c0e8f
+// -2.443140
+0xc01c5c67
+// -2.237181
+0xc00f2df7
+// -3.140883
+0xc049043a
+// -2.614217
+0xc0274f56
+// -2.262157
+0xc010c72d
+// -2.193239
+0xc00c5e06
+// -2.168818
+0xc00acdea
+// -2.639748
+0xc028f1a2
+// -2.848019
+0xc03645f0
+// -2.765049
+0xc030f68f
+// -2.451468
+0xc01ce4d8
+// -2.340835
+0xc015d03d
+// -4.669080
+0xc095691a
+// -2.642343
+0xc0291c25
+// -5.408748
+0xc0ad1477
+// -2.177459
+0xc00b5b7d
+// -4.037190
+0xc08130a9
+// -2.304983
+0xc01384d8
+// -2.407948
+0xc01a1bd2
+// -2.709700
+0xc02d6bb8
+// -2.814918
+0xc03427a0
+// -2.310880
+0xc013e577
+// -3.337622
+0xc0559b99
+// -2.731337
+0xc02ece38
+// -3.139665
+0xc048f046
+// -3.555456
+0xc0638c96
+// -2.414098
+0xc01a8094
+// -2.219262
+0xc00e0863
+// -2.343753
+0xc016000b
+// -3.213300
+0xc04da6b4
+// -1.912427
+0xbff4ca68
+// -3.482994
+0xc05ee960
+// -2.939992
+0xc03c28d3
+// -1.809478
+0xbfe79cfb
+// -3.655081
+0xc069ecda
+// -4.050159
+0xc0819ae7
+// -1.694885
+0xbfd8f1fe
+// -3.928383
+0xc07b6aa0
+// -2.764698
+0xc030f0d0
+// -1.816547
+0xbfe8849b
+// -3.480855
+0xc05ec655
+// -2.743057
+0xc02f8e3e
+// -4.563702
+0xc09209d9
+// -2.808479
+0xc033be20
+// -2.783835
+0xc0322a5a
+// -2.732837
+0xc02ee6cc
+// -2.400041
+0xc0199a44
+// -4.563638
+0xc0920953
+// -1.775404
+0xbfe34074
+// -2.062098
+0xc003f96b
+// -2.370733
+0xc017ba17
+// -3.405902
+0xc059fa4d
+// -2.032680
+0xc002176d
+// -3.162956
+0xc04a6de0
+// -3.425999
+0xc05b4393
+// -2.642872
+0xc02924cf
+// -3.705794
+0xc06d2bbb
+// -5.242547
+0xc0a7c2f3
+// -2.154788
+0xc009e80c
+// -2.468035
+0xc01df44a
+// -2.349867
+0xc0166437
+// -2.247067
+0xc00fcff1
+// -2.493350
+0xc01f930b
+// -2.635539
+0xc028acac
+// -3.137631
+0xc048cef1
+// -3.559765
+0xc063d32f
+// -2.133347
+0xc00888c2
+// -2.899370
+0xc0398f45
+// -2.939320
+0xc03c1dd4
+// -2.655540
+0xc029f45d
+// -2.487244
+0xc01f2f00
+// -2.315065
+0xc0142a08
+// -2.705430
+0xc02d25c5
+// -2.427825
+0xc01b617d
+// -2.094550
+0xc0060d1b
+// -2.815774
+0xc03435a5
+// -2.682923
+0xc02bb501
+// -2.298131
+0xc0131492
+// -4.220838
+0xc087111a
+// -3.138187
+0xc048d80e
+// -3.368468
+0xc05794fa
+// -3.296028
+0xc052f21f
+// -2.145281
+0xc0094c48
+// -1.969823
+0xbffc2328
+// -3.847174
+0xc0763818
+// -2.517131
+0xc02118ab
+// -2.840606
+0xc035cc7f
+// -3.264118
+0xc050e750
+// -4.499197
+0xc08ff96b
+// -2.433933
+0xc01bc58e
+// -2.641747
+0xc0291264
+// -2.178451
+0xc00b6bbd
+// -4.503685
+0xc0901e30
+// -2.408603
+0xc01a268f
+// -2.355837
+0xc016c607
+// -4.063132
+0xc082052c
+// -2.087104
+0xc005931f
+// -1.950742
+0xbff9b1e8
+// -2.614655
+0xc0275681
+// -2.652767
+0xc029c6ed
+// -2.603648
+0xc026a22c
+// -6.083038
+0xc0c2a83f
+// -3.105599
+0xc046c223
+// -4.137948
+0xc0846a12
+// -2.020449
+0xc0014f07
+// -1.941666
+0xbff88882
+// -2.259635
+0xc0109ddd
+// -3.241031
+0xc04f6d0d
+// -2.669383
+0xc02ad72b
+// -2.728630
+0xc02ea1e0
+// -2.028120
+0xc001ccba
+// -3.992279
+0xc07f817e
+// -2.289771
+0xc0128b9b
--- a/Testing/Patterns/DSP/Stats/StatsF32/InputB3_f32.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/InputB3_f32.txt
@ -0,0 +1,242 @@
+W
+120
+// 0.044983
+0x3d384090
+// 0.063204
+0x3d817126
+// 0.014184
+0x3c68646a
+// 0.119876
+0x3df5815b
+// 0.202342
+0x3e4f32d3
+// 0.145255
+0x3e14bdbf
+// 0.029081
+0x3cee3abb
+// 0.175435
+0x3e33a51e
+// 0.073557
+0x3d96a4fa
+// 0.102909
+0x3dd2c21a
+// 0.003713
+0x3b7359dd
+// 0.025461
+0x3cd092d9
+// 0.027952
+0x3ce4fc04
+// 0.121727
+0x3df94bf7
+// 0.150883
+0x3e1a810a
+// 0.137462
+0x3e0cc2e5
+// 0.177950
+0x3e363893
+// 0.025627
+0x3cd1eec3
+// 0.057045
+0x3d69a84b
+// 0.028221
+0x3ce72fc6
+// 0.050590
+0x3d4f37a3
+// 0.035918
+0x3d131ea9
+// 0.118421
+0x3df286f7
+// 0.068203
+0x3d8bae1d
+// 0.031919
+0x3d02bd42
+// 0.051377
+0x3d5270f2
+// 0.095771
+0x3dc4235d
+// 0.112689
+0x3de6c972
+// 0.124770
+0x3dff876b
+// 0.129501
+0x3e049bfb
+// 0.061095
+0x3d7a3f14
+// 0.109398
+0x3de00c11
+// 0.060844
+0x3d793729
+// 0.109745
+0x3de0c21d
+// 0.102047
+0x3dd0fdf0
+// 0.010844
+0x3c31abc7
+// 0.025053
+0x3ccd3c7a
+// 0.104917
+0x3dd6de92
+// 0.101331
+0x3dcf86bb
+// 0.066291
+0x3d87c37f
+// 0.109169
+0x3ddf9419
+// 0.107543
+0x3ddc3fc2
+// 0.027078
+0x3cddd245
+// 0.030607
+0x3cfabc0a
+// 0.074828
+0x3d993f39
+// 0.206119
+0x3e5310d4
+// 0.037497
+0x3d1996b2
+// 0.109567
+0x3de0646f
+// 0.179149
+0x3e3772d6
+// 0.102167
+0x3dd13ce3
+// 0.081166
+0x3da63a5e
+// 0.015204
+0x3c791a5c
+// 0.180793
+0x3e3921db
+// 0.042993
+0x3d3019e2
+// 0.032140
+0x3d03a551
+// 0.042215
+0x3d2ce9b6
+// 0.066584
+0x3d885d27
+// 0.079089
+0x3da1f99d
+// 0.019153
+0x3c9ce730
+// 0.159346
+0x3e232b87
+// 0.096565
+0x3dc5c41d
+// 0.081082
+0x3da60e67
+// 0.147438
+0x3e16f9f4
+// 0.078555
+0x3da0e1a0
+// 0.077076
+0x3d9dd9fc
+// 0.015722
+0x3c80cafb
+// 0.165153
+0x3e291dcd
+// 0.093546
+0x3dbf94cd
+// 0.034683
+0x3d0e0f9e
+// 0.055575
+0x3d63a319
+// 0.023973
+0x3cc463b2
+// 0.130632
+0x3e05c445
+// 0.020764
+0x3caa1a04
+// 0.103480
+0x3dd3ed5b
+// 0.138688
+0x3e0e0446
+// 0.098501
+0x3dc9bae5
+// 0.024754
+0x3ccac9eb
+// 0.090573
+0x3db97e34
+// 0.153524
+0x3e1d3568
+// 0.099521
+0x3dcbd17a
+// 0.012342
+0x3c4a3526
+// 0.061270
+0x3d7af6a9
+// 0.042894
+0x3d2fb16c
+// 0.153689
+0x3e1d6085
+// 0.022284
+0x3cb68ce3
+// 0.003680
+0x3b71257c
+// 0.004948
+0x3ba22640
+// 0.082520
+0x3da90018
+// 0.060753
+0x3d78d882
+// 0.146602
+0x3e161ec3
+// 0.161830
+0x3e25b6dc
+// 0.001966
+0x3b00d470
+// 0.130081
+0x3e0533f4
+// 0.194115
+0x3e46c607
+// 0.146537
+0x3e160dab
+// 0.044685
+0x3d370763
+// 0.126425
+0x3e017593
+// 0.001232
+0x3aa180bf
+// 0.069823
+0x3d8eff7e
+// 0.078981
+0x3da1c0e7
+// 0.139521
+0x3e0ede8e
+// 0.128575
+0x3e03a929
+// 0.119353
+0x3df46f48
+// 0.086768
+0x3db1b384
+// 0.070929
+0x3d91436c
+// 0.003132
+0x3b4d3c69
+// 0.035408
+0x3d110872
+// 0.139852
+0x3e0f3558
+// 0.058214
+0x3d6e715e
+// 0.113633
+0x3de8b830
+// 0.128412
+0x3e037e4e
+// 0.088403
+0x3db50cb1
+// 0.035593
+0x3d11c99e
+// 0.108979
+0x3ddf3058
+// 0.079775
+0x3da360de
+// 0.064459
+0x3d840350
+// 0.052166
+0x3d55ac70
+// 0.087890
+0x3db3ffa7
+// 0.107610
+0x3ddc62b1
+// 0.074867
+0x3d9953ed
--- a/Testing/Patterns/DSP/Stats/StatsF32/InputB4_f32.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/InputB4_f32.txt
@ -0,0 +1,282 @@
+W
+140
+// -4.880571
+0xc09c2da4
+// -2.310025
+0xc013d775
+// -4.722834
+0xc0972175
+// -2.375864
+0xc0180e29
+// -2.499043
+0xc01ff051
+// -2.617184
+0xc0277ff3
+// -2.500725
+0xc0200bdf
+// -3.125170
+0xc04802ca
+// -2.044707
+0xc002dc79
+// -2.245046
+0xc00faed7
+// -3.789078
+0xc0728042
+// -2.422561
+0xc01b0b3f
+// -2.542340
+0xc022b5b4
+// -2.324173
+0xc014bf3f
+// -4.319170
+0xc08a36a5
+// -2.162495
+0xc00a6653
+// -2.362773
+0xc01737ae
+// -2.666671
+0xc02aaabd
+// -4.811499
+0xc099f7cd
+// -2.457236
+0xc01d435c
+// -2.344153
+0xc016069c
+// -4.008705
+0xc0804750
+// -2.106636
+0xc006d322
+// -2.220302
+0xc00e196f
+// -4.220413
+0xc0870d9f
+// -4.033934
+0xc08115fc
+// -2.067383
+0xc0045003
+// -2.087627
+0xc0059baf
+// -2.514702
+0xc020f0df
+// -2.498742
+0xc01feb64
+// -3.535087
+0xc0623edc
+// -2.905015
+0xc039ebc2
+// -2.178259
+0xc00b689b
+// -2.434247
+0xc01bcab4
+// -3.826071
+0xc074de5b
+// -2.162461
+0xc00a65c1
+// -2.644227
+0xc0293b02
+// -2.566446
+0xc02440a5
+// -6.060368
+0xc0c1ee89
+// -1.916264
+0xbff54823
+// -2.803304
+0xc0336954
+// -2.654779
+0xc029e7e7
+// -2.335184
+0xc01573a9
+// -2.341243
+0xc015d6eb
+// -3.759905
+0xc070a249
+// -2.242762
+0xc00f8968
+// -2.621021
+0xc027becd
+// -2.491564
+0xc01f75c9
+// -2.746422
+0xc02fc562
+// -4.311164
+0xc089f50e
+// -2.260324
+0xc010a927
+// -2.347152
+0xc01637be
+// -2.541638
+0xc022aa32
+// -3.833711
+0xc0755b85
+// -2.269105
+0xc0113903
+// -2.923681
+0xc03b1d98
+// -2.488858
+0xc01f4971
+// -3.593271
+0xc065f828
+// -3.544676
+0xc062dbf7
+// -5.131858
+0xc0a4382e
+// -3.911178
+0xc07a50bd
+// -2.151457
+0xc009b17b
+// -2.580359
+0xc025249a
+// -2.104187
+0xc006aaff
+// -2.370529
+0xc017b6be
+// -2.044771
+0xc002dd86
+// -2.300521
+0xc0133bbe
+// -2.801055
+0xc033447e
+// -3.684200
+0xc06bc9ee
+// -2.081287
+0xc00533ce
+// -3.916425
+0xc07aa6b5
+// -2.163027
+0xc00a6f09
+// -3.035936
+0xc0424cc6
+// -3.616765
+0xc0677914
+// -3.256338
+0xc05067d7
+// -2.049571
+0xc0032c2a
+// -2.793543
+0xc032c967
+// -2.093242
+0xc005f7af
+// -2.377697
+0xc0182c2e
+// -2.534072
+0xc0222e3d
+// -3.141081
+0xc0490779
+// -3.026531
+0xc041b2ae
+// -2.539031
+0xc0227f7d
+// -2.219713
+0xc00e0fc9
+// -2.519878
+0xc02145ae
+// -2.222879
+0xc00e43a5
+// -3.318352
+0xc0545fe0
+// -6.141658
+0xc0c48877
+// -2.532739
+0xc0221866
+// -2.849836
+0xc03663b7
+// -2.203600
+0xc00d07c7
+// -2.386310
+0xc018b94d
+// -2.907326
+0xc03a11a2
+// -2.721533
+0xc02e2d97
+// -2.622819
+0xc027dc42
+// -2.159328
+0xc00a326f
+// -2.286669
+0xc01258c8
+// -3.318666
+0xc0546508
+// -3.334933
+0xc0556f8a
+// -3.479360
+0xc05eadd6
+// -2.436450
+0xc01beecc
+// -2.304555
+0xc0137dd5
+// -3.350386
+0xc0566cba
+// -3.987784
+0xc07f37dc
+// -2.255624
+0xc0105c25
+// -2.225388
+0xc00e6cc3
+// -2.499332
+0xc01ff50f
+// -2.662503
+0xc02a6674
+// -2.355506
+0xc016c09e
+// -2.669696
+0xc02adc4c
+// -2.785439
+0xc03244a1
+// -2.161930
+0xc00a5d0e
+// -2.800365
+0xc033392f
+// -2.776937
+0xc031b954
+// -1.891957
+0xbff22ba3
+// -5.177098
+0xc0a5aaca
+// -2.583016
+0xc0255023
+// -2.938910
+0xc03c171a
+// -2.537616
+0xc022684b
+// -5.884942
+0xc0bc5171
+// -2.104592
+0xc006b1a3
+// -3.753596
+0xc0703aea
+// -2.346414
+0xc0162ba6
+// -2.309552
+0xc013cfb2
+// -2.469240
+0xc01e0807
+// -2.320116
+0xc0147cc8
+// -3.702086
+0xc06ceefa
+// -2.564086
+0xc02419fe
+// -2.339059
+0xc015b325
+// -2.062204
+0xc003fb27
+// -3.666694
+0xc06aab1e
+// -2.273782
+0xc01185a4
+// -5.516875
+0xc0b08a3d
+// -4.206650
+0xc0869ce0
+// -2.816358
+0xc0343f36
+// -2.399771
+0xc01995d9
+// -2.635137
+0xc028a616
+// -2.263880
+0xc010e367
+// -2.297445
+0xc0130959
+// -2.174929
+0xc00b3209
--- a/Testing/Patterns/DSP/Stats/StatsF32/RefEntropy1_f32.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/RefEntropy1_f32.txt
@ -0,0 +1,22 @@
+W
+10
+// 2.420426
+0x401ae842
+// 2.473287
+0x401e4a55
+// 2.294621
+0x4012db14
+// 2.440063
+0x401c29fe
+// 2.265126
+0x4010f7d3
+// 2.407317
+0x401a117d
+// 2.527646
+0x4021c4f2
+// 2.570614
+0x402484f0
+// 2.421607
+0x401afb9b
+// 2.455924
+0x401d2ddb
--- a/Testing/Patterns/DSP/Stats/StatsF32/RefKL3_f32.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/RefKL3_f32.txt
@ -0,0 +1,22 @@
+W
+10
+// 0.957399
+0x3f751812
+// 0.406465
+0x3ed01c21
+// 0.357268
+0x3eb6ebe3
+// 0.686696
+0x3f2fcb50
+// 0.448469
+0x3ee59dc7
+// 0.205755
+0x3e52b16b
+// 0.562704
+0x3f100d63
+// 0.606644
+0x3f1b4d00
+// 0.293960
+0x3e9681e7
+// 0.239745
+0x3e757fd5
--- a/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp1_f32.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp1_f32.txt
@ -0,0 +1,22 @@
+W
+10
+// 2.711102
+0x402d82b0
+// 2.711427
+0x402d8804
+// 2.711261
+0x402d854c
+// 2.711538
+0x402d89d8
+// 2.711763
+0x402d8d88
+// 2.711499
+0x402d8935
+// 2.710971
+0x402d808c
+// 2.711208
+0x402d8470
+// 2.711304
+0x402d8602
+// 2.711338
+0x402d8691
--- a/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp2_f32.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExp2_f32.txt
@ -0,0 +1,22 @@
+W
+10
+// 3.046080
+0x4042f2f9
+// 3.046085
+0x4042f30e
+// 3.046527
+0x4042fa4e
+// 3.045871
+0x4042ef8e
+// 3.046065
+0x4042f2ba
+// 3.046120
+0x4042f3a3
+// 3.045996
+0x4042f199
+// 3.046050
+0x4042f27b
+// 3.046123
+0x4042f3ae
+// 3.046097
+0x4042f33f
--- a/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExpDot4_f32.txt
+++ b/Testing/Patterns/DSP/Stats/StatsF32/RefLogSumExpDot4_f32.txt
@ -0,0 +1,22 @@
+W
+10
+// -2.635825
+0xc028b15a
+// -2.578362
+0xc02503e3
+// -2.684868
+0xc02bd4e2
+// -2.621420
+0xc027c558
+// -2.664016
+0xc02a7f3f
+// -2.518862
+0xc0213507
+// -2.646046
+0xc02958d1
+// -2.663388
+0xc02a74f1
+// -2.524261
+0xc0218d7f
+// -2.660810
+0xc02a4ab5
--- a/Testing/Patterns/DSP/Support/SupportF32/Dims1_s16.txt
+++ b/Testing/Patterns/DSP/Support/SupportF32/Dims1_s16.txt
@ -0,0 +1,8 @@
+H
+3
+// 10
+0x000A
+// 10
+0x000A
+// 14
+0x000E
--- a/Testing/Patterns/DSP/Support/SupportF32/Dims2_s16.txt
+++ b/Testing/Patterns/DSP/Support/SupportF32/Dims2_s16.txt
@ -0,0 +1,6 @@
+H
+2
+// 10
+0x000A
+// 20
+0x0014
--- a/Testing/Patterns/DSP/Support/SupportF32/Inputs1_f32.txt
+++ b/Testing/Patterns/DSP/Support/SupportF32/Inputs1_f32.txt
--- a/Testing/Patterns/DSP/Support/SupportF32/Inputs2_f32.txt
+++ b/Testing/Patterns/DSP/Support/SupportF32/Inputs2_f32.txt
@ -0,0 +1,402 @@
+W
+200
+// 0.443424
+0x3ee30871
+// 0.886256
+0x3f62e1b2
+// 0.163454
+0x3e276075
+// 0.839323
+0x3f56dde7
+// 0.136944
+0x3e0c3b1c
+// 0.638549
+0x3f2377fb
+// 0.092405
+0x3dbd3ec2
+// 0.361663
+0x3eb92bd5
+// 0.312741
+0x3ea01fa0
+// 0.518389
+0x3f04b520
+// 0.680725
+0x3f2e43fc
+// 0.244531
+0x3e7a663d
+// 0.539128
+0x3f0a044e
+// 0.202043
+0x3e4ee47b
+// 0.837784
+0x3f567903
+// 0.125087
+0x3e0016c2
+// 0.108872
+0x3ddef820
+// 0.235270
+0x3e70ea99
+// 0.071163
+0x3d91be27
+// 0.247372
+0x3e7d4f27
+// 0.905132
+0x3f67b6ba
+// 0.435782
+0x3edf1ec3
+// 0.413214
+0x3ed390d5
+// 0.502824
+0x3f00b912
+// 0.675129
+0x3f2cd544
+// 0.653377
+0x3f2743b7
+// 0.114356
+0x3dea3365
+// 0.477438
+0x3ef472c8
+// 0.476851
+0x3ef425d9
+// 0.134899
+0x3e0a22f5
+// 0.456654
+0x3ee9ce9c
+// 0.340581
+0x3eae609e
+// 0.947603
+0x3f729616
+// 0.953657
+0x3f7422e2
+// 0.616823
+0x3f1de81f
+// 0.598133
+0x3f191f3e
+// 0.478492
+0x3ef4fcf6
+// 0.555079
+0x3f0e19b0
+// 0.883830
+0x3f6242ab
+// 0.672335
+0x3f2c1e2b
+// 0.563156
+0x3f102afe
+// 0.862030
+0x3f5cadfa
+// 0.048379
+0x3d46294c
+// 0.512465
+0x3f0330ec
+// 0.585846
+0x3f15fa07
+// 0.107536
+0x3ddc3b94
+// 0.808403
+0x3f4ef382
+// 0.432530
+0x3edd7492
+// 0.577879
+0x3f13efdb
+// 0.356267
+0x3eb668ab
+// 0.067064
+0x3d8958a5
+// 0.570843
+0x3f1222c6
+// 0.017565
+0x3c8fe3c6
+// 0.231999
+0x3e6d9130
+// 0.924089
+0x3f6c911d
+// 0.410634
+0x3ed23ea3
+// 0.576704
+0x3f13a2e0
+// 0.160696
+0x3e248d93
+// 0.932314
+0x3f6eac29
+// 0.659542
+0x3f28d7bf
+// 0.876899
+0x3f607c73
+// 0.397653
+0x3ecb9926
+// 0.448903
+0x3ee5d6a5
+// 0.514886
+0x3f03cf94
+// 0.715136
+0x3f37132d
+// 0.215398
+0x3e5c9162
+// 0.808191
+0x3f4ee5a3
+// 0.098072
+0x3dc8da3c
+// 0.723347
+0x3f392d43
+// 0.638847
+0x3f238b81
+// 0.725843
+0x3f39d0d9
+// 0.176922
+0x3e352b26
+// 0.652296
+0x3f26fcd7
+// 0.615175
+0x3f1d7c1d
+// 0.007382
+0x3bf1e4e5
+// 0.193999
+0x3e46a79c
+// 0.627257
+0x3f2093f1
+// 0.046974
+0x3d4067c8
+// 0.534540
+0x3f08d795
+// 0.076811
+0x3d9d4f2f
+// 0.333476
+0x3eaabd5c
+// 0.686808
+0x3f2fd2aa
+// 0.268706
+0x3e8993d6
+// 0.684808
+0x3f2f4f92
+// 0.626360
+0x3f205921
+// 0.797450
+0x3f4c25ab
+// 0.673802
+0x3f2c7e47
+// 0.803060
+0x3f4d9550
+// 0.156331
+0x3e201543
+// 0.759910
+0x3f428974
+// 0.348787
+0x3eb29434
+// 0.264688
+0x3e87853f
+// 0.432266
+0x3edd51e9
+// 0.176968
+0x3e353718
+// 0.783641
+0x3f489cb3
+// 0.755757
+0x3f417948
+// 0.217481
+0x3e5eb36c
+// 0.262280
+0x3e864994
+// 0.570642
+0x3f121591
+// 0.361058
+0x3eb8dc99
+// 0.031490
+0x3d00fbde
+// 0.132971
+0x3e082982
+// 0.156141
+0x3e1fe358
+// 0.550506
+0x3f0cedfd
+// 0.918988
+0x3f6b42c8
+// 0.977866
+0x3f7a5570
+// 0.738988
+0x3f3d2e4d
+// 0.189446
+0x3e41fe27
+// 0.036582
+0x3d15d778
+// 0.206300
+0x3e53403b
+// 0.414931
+0x3ed471dc
+// 0.622640
+0x3f1f655d
+// 0.252938
+0x3e818110
+// 0.429426
+0x3edbddb7
+// 0.156353
+0x3e201ae2
+// 0.813185
+0x3f502ce8
+// 0.887680
+0x3f633f03
+// 0.497651
+0x3efecc0c
+// 0.297173
+0x3e98271e
+// 0.462716
+0x3eece928
+// 0.861982
+0x3f5caadc
+// 0.160051
+0x3e23e46a
+// 0.893911
+0x3f64d754
+// 0.936248
+0x3f6fadee
+// 0.980871
+0x3f7b1a5f
+// 0.054465
+0x3d5f1680
+// 0.359278
+0x3eb7f348
+// 0.229955
+0x3e6b7970
+// 0.297627
+0x3e98629f
+// 0.410227
+0x3ed20947
+// 0.264262
+0x3e874d4e
+// 0.302338
+0x3e9acc08
+// 0.318933
+0x3ea34b37
+// 0.431904
+0x3edd228b
+// 0.830392
+0x3f549499
+// 0.584340
+0x3f15974a
+// 0.095801
+0x3dc43387
+// 0.522968
+0x3f05e139
+// 0.574628
+0x3f131ad9
+// 0.967691
+0x3f77ba97
+// 0.847407
+0x3f58efad
+// 0.096857
+0x3dc65cdf
+// 0.724253
+0x3f3968ab
+// 0.130844
+0x3e05fc13
+// 0.039399
+0x3d2160fc
+// 0.411625
+0x3ed2c08b
+// 0.924243
+0x3f6c9b29
+// 0.145452
+0x3e14f156
+// 0.462620
+0x3eecdc88
+// 0.332197
+0x3eaa15b9
+// 0.200683
+0x3e4d7fb7
+// 0.292438
+0x3e95ba6d
+// 0.820983
+0x3f522be9
+// 0.949966
+0x3f7330f8
+// 0.070020
+0x3d8f6674
+// 0.130093
+0x3e053731
+// 0.982888
+0x3f7b9e89
+// 0.442152
+0x3ee261be
+// 0.557978
+0x3f0ed7a8
+// 0.058403
+0x3d6f3776
+// 0.766554
+0x3f443cdb
+// 0.159897
+0x3e23bc17
+// 0.488649
+0x3efa3038
+// 0.733687
+0x3f3bd2f0
+// 0.932029
+0x3f6e9975
+// 0.784209
+0x3f48c1f4
+// 0.016317
+0x3c85ab6f
+// 0.987727
+0x3f7cdba5
+// 0.752869
+0x3f40bc07
+// 0.872834
+0x3f5f7211
+// 0.134889
+0x3e0a2064
+// 0.086838
+0x3db1d80c
+// 0.885384
+0x3f62a88e
+// 0.140062
+0x3e0f6c70
+// 0.048918
+0x3d485e79
+// 0.789513
+0x3f4a1d8a
+// 0.448198
+0x3ee57a33
+// 0.548526
+0x3f0c6c31
+// 0.045601
+0x3d3ac864
+// 0.413648
+0x3ed3c9b6
+// 0.299164
+0x3e992c12
+// 0.465300
+0x3eee3bd6
+// 0.392167
+0x3ec8ca24
+// 0.822582
+0x3f5294c4
+// 0.657099
+0x3f2837aa
+// 0.548129
+0x3f0c522a
+// 0.534058
+0x3f08b80e
+// 0.286084
+0x3e9279aa
+// 0.079868
+0x3da39215
+// 0.876835
+0x3f607848
+// 0.203092
+0x3e4ff73b
+// 0.883773
+0x3f623eeb
+// 0.373121
+0x3ebf09b1
+// 0.853466
+0x3f5a7cbb
+// 0.250589
+0x3e804d2f
+// 0.370841
+0x3ebddee5
+// 0.997505
+0x3f7f5c79
+// 0.577818
+0x3f13ebdd
+// 0.879050
+0x3f610973
+// 0.725164
+0x3f39a457
--- a/Testing/Patterns/DSP/Support/SupportF32/Ref1_f32.txt
+++ b/Testing/Patterns/DSP/Support/SupportF32/Ref1_f32.txt
@ -0,0 +1,282 @@
+W
+140
+// 0.396663
+0x3ecb1759
+// 0.488467
+0x3efa1867
+// 0.564657
+0x3f108d5c
+// 0.294993
+0x3e970960
+// 0.537258
+0x3f0989c1
+// 0.407342
+0x3ed08f28
+// 0.332273
+0x3eaa1f9f
+// 0.357947
+0x3eb744e4
+// 0.532547
+0x3f0854f9
+// 0.529848
+0x3f07a423
+// 0.490510
+0x3efb241b
+// 0.479640
+0x3ef5935c
+// 0.514344
+0x3f03ac07
+// 0.384175
+0x3ec4b298
+// 0.584468
+0x3f159fae
+// 0.501793
+0x3f007588
+// 0.377067
+0x3ec10ee2
+// 0.423004
+0x3ed893ee
+// 0.553823
+0x3f0dc753
+// 0.430740
+0x3edc89f8
+// 0.546867
+0x3f0bff7b
+// 0.625247
+0x3f201033
+// 0.505609
+0x3f016f99
+// 0.682405
+0x3f2eb21b
+// 0.531141
+0x3f07f8db
+// 0.617352
+0x3f1e0acb
+// 0.637503
+0x3f233366
+// 0.366971
+0x3ebbe3ac
+// 0.586227
+0x3f1612f2
+// 0.658586
+0x3f289918
+// 0.661761
+0x3f29692f
+// 0.586512
+0x3f1625ad
+// 0.511720
+0x3f030018
+// 0.403012
+0x3ece57a3
+// 0.602969
+0x3f1a5c32
+// 0.415850
+0x3ed4ea48
+// 0.476689
+0x3ef41089
+// 0.446969
+0x3ee4d922
+// 0.370921
+0x3ebde960
+// 0.548202
+0x3f0c56f3
+// 0.523565
+0x3f060859
+// 0.328882
+0x3ea86349
+// 0.592116
+0x3f1794ec
+// 0.571156
+0x3f12374b
+// 0.419700
+0x3ed6e2de
+// 0.441976
+0x3ee24abb
+// 0.455401
+0x3ee92a5c
+// 0.380478
+0x3ec2cdf8
+// 0.517325
+0x3f046f70
+// 0.566096
+0x3f10ebb2
+// 0.577724
+0x3f13e5bb
+// 0.464517
+0x3eedd520
+// 0.553114
+0x3f0d98e4
+// 0.795544
+0x3f4ba8c7
+// 0.410861
+0x3ed25c57
+// 0.537528
+0x3f099b6b
+// 0.192942
+0x3e4592b7
+// 0.343081
+0x3eafa84b
+// 0.599154
+0x3f19622f
+// 0.512507
+0x3f0333a9
+// 0.748931
+0x3f3fb9f0
+// 0.442575
+0x3ee2992d
+// 0.615802
+0x3f1da533
+// 0.206264
+0x3e5336d1
+// 0.284124
+0x3e9178c1
+// 0.429892
+0x3edc1abe
+// 0.619106
+0x3f1e7dbe
+// 0.699179
+0x3f32fd6b
+// 0.542653
+0x3f0aeb4b
+// 0.453388
+0x3ee8226f
+// 0.354481
+0x3eb57e7e
+// 0.149945
+0x3e198b46
+// 0.610673
+0x3f1c5515
+// 0.236180
+0x3e71d915
+// 0.295780
+0x3e977080
+// 0.486209
+0x3ef8f067
+// 0.385289
+0x3ec54490
+// 0.403298
+0x3ece7d1c
+// 0.299535
+0x3e995ca2
+// 0.446593
+0x3ee4a7da
+// 0.614062
+0x3f1d332e
+// 0.509097
+0x3f025430
+// 0.678507
+0x3f2db2a5
+// 0.288457
+0x3e93b098
+// 0.580570
+0x3f14a042
+// 0.437852
+0x3ee02e2a
+// 0.464964
+0x3eee0fb9
+// 0.550796
+0x3f0d00fa
+// 0.550689
+0x3f0cf9f6
+// 0.523388
+0x3f05fcc2
+// 0.361082
+0x3eb8dfbc
+// 0.420308
+0x3ed73290
+// 0.472617
+0x3ef1fadf
+// 0.519552
+0x3f050158
+// 0.321003
+0x3ea45a87
+// 0.476353
+0x3ef3e487
+// 0.572559
+0x3f12933f
+// 0.541054
+0x3f0a8287
+// 0.436597
+0x3edf89b3
+// 0.538610
+0x3f09e25e
+// 0.560332
+0x3f0f71ed
+// 0.591778
+0x3f177ecc
+// 0.627006
+0x3f208375
+// 0.436700
+0x3edf972d
+// 0.669065
+0x3f2b47d6
+// 0.585237
+0x3f15d210
+// 0.599274
+0x3f196a04
+// 0.297752
+0x3e9872e6
+// 0.498355
+0x3eff2857
+// 0.578051
+0x3f13fb21
+// 0.511401
+0x3f02eb26
+// 0.421556
+0x3ed7d632
+// 0.553167
+0x3f0d9c57
+// 0.364388
+0x3eba911c
+// 0.477408
+0x3ef46ecd
+// 0.567326
+0x3f113c4c
+// 0.466576
+0x3eeee304
+// 0.523979
+0x3f06237d
+// 0.494238
+0x3efd0cc1
+// 0.491972
+0x3efbe3b9
+// 0.635085
+0x3f2294f1
+// 0.513000
+0x3f0353f8
+// 0.396563
+0x3ecb0a4e
+// 0.489172
+0x3efa74c6
+// 0.516201
+0x3f0425c2
+// 0.392971
+0x3ec9336f
+// 0.479826
+0x3ef5abb8
+// 0.467511
+0x3eef5d8c
+// 0.394954
+0x3eca3776
+// 0.581547
+0x3f14e044
+// 0.502074
+0x3f0087e8
+// 0.593030
+0x3f17d0d1
+// 0.394341
+0x3ec9e720
+// 0.480085
+0x3ef5cdad
+// 0.507996
+0x3f020c09
+// 0.581742
+0x3f14ed0d
+// 0.553405
+0x3f0dabf0
+// 0.523564
+0x3f060849
+// 0.492312
+0x3efc104f
+// 0.466235
+0x3eeeb652
--- a/Testing/Patterns/DSP/Support/SupportF32/Ref2_f32.txt
+++ b/Testing/Patterns/DSP/Support/SupportF32/Ref2_f32.txt
@ -0,0 +1,22 @@
+W
+10
+// 0.339559
+0x3eaddab6
+// 0.589935
+0x3f1705f4
+// 0.557362
+0x3f0eaf4a
+// 0.495312
+0x3efd997d
+// 0.555500
+0x3f0e3546
+// 0.338926
+0x3ead87b5
+// 0.476111
+0x3ef3c4df
+// 0.459156
+0x3eeb167c
+// 0.474479
+0x3ef2eef8
+// 0.536835
+0x3f096e03
--- a/Testing/Patterns/DSP/Support/SupportF32/Weights1_f32.txt
+++ b/Testing/Patterns/DSP/Support/SupportF32/Weights1_f32.txt
@ -0,0 +1,202 @@
+W
+100
+// 0.505882
+0x3f01817c
+// 0.694938
+0x3f31e77d
+// 0.834184
+0x3f558d1d
+// 0.216891
+0x3e5e18a8
+// 0.861617
+0x3f5c92f1
+// 0.373753
+0x3ebf5c80
+// 0.407281
+0x3ed08723
+// 0.699954
+0x3f333031
+// 0.979094
+0x3f7aa5ec
+// 0.630861
+0x3f21801b
+// 0.679985
+0x3f2e1386
+// 0.932848
+0x3f6ecf19
+// 0.811971
+0x3f4fdd4e
+// 0.645507
+0x3f253fee
+// 0.875696
+0x3f602d96
+// 0.191781
+0x3e44621c
+// 0.204298
+0x3e51336b
+// 0.772702
+0x3f45cfcf
+// 0.167709
+0x3e2bbbff
+// 0.309124
+0x3e9e4580
+// 0.313483
+0x3ea080cd
+// 0.433754
+0x3ede14f6
+// 0.675088
+0x3f2cd298
+// 0.562244
+0x3f0fef3b
+// 0.793795
+0x3f4b361f
+// 0.362285
+0x3eb97d6e
+// 0.492851
+0x3efc56f8
+// 0.444063
+0x3ee35c3c
+// 0.174411
+0x3e3298ad
+// 0.849831
+0x3f598e89
+// 0.773278
+0x3f45f591
+// 0.457876
+0x3eea6eb1
+// 0.812354
+0x3f4ff66d
+// 0.199501
+0x3e4c4a00
+// 0.129128
+0x3e043a2e
+// 0.388451
+0x3ec6e302
+// 0.877912
+0x3f60bedb
+// 0.399625
+0x3ecc9ba6
+// 0.687600
+0x3f300688
+// 0.941738
+0x3f7115c6
+// 0.961782
+0x3f76375b
+// 0.220845
+0x3e62253a
+// 0.088035
+0x3db44bd0
+// 0.280936
+0x3e8fd6e1
+// 0.478691
+0x3ef516f2
+// 0.393297
+0x3ec95e37
+// 0.151429
+0x3e1b1014
+// 0.896004
+0x3f656082
+// 0.070551
+0x3d907ccf
+// 0.418561
+0x3ed64d96
+// 0.148954
+0x3e18877d
+// 0.090889
+0x3dba23e0
+// 0.588984
+0x3f16c7a3
+// 0.343351
+0x3eafcbad
+// 0.228429
+0x3e69e92d
+// 0.894738
+0x3f650d93
+// 0.211258
+0x3e5853f4
+// 0.998758
+0x3f7fae9c
+// 0.216538
+0x3e5dbc20
+// 0.000103
+0x38d71c9b
+// 0.742580
+0x3f3e19bb
+// 0.757969
+0x3f420a49
+// 0.964287
+0x3f76db83
+// 0.286232
+0x3e928d0e
+// 0.235296
+0x3e70f170
+// 0.001907
+0x3af9fa3a
+// 0.721577
+0x3f38b944
+// 0.542959
+0x3f0aff5e
+// 0.115242
+0x3dec043e
+// 0.332174
+0x3eaa12c1
+// 0.277826
+0x3e8e3f30
+// 0.752389
+0x3f409c97
+// 0.968473
+0x3f77eddb
+// 0.953890
+0x3f743229
+// 0.952828
+0x3f73ec8a
+// 0.834935
+0x3f55be50
+// 0.175639
+0x3e33dab2
+// 0.339723
+0x3eadf020
+// 0.745878
+0x3f3ef1d4
+// 0.510702
+0x3f02bd63
+// 0.120267
+0x3df64e61
+// 0.446761
+0x3ee4bdea
+// 0.761876
+0x3f430a50
+// 0.348787
+0x3eb2943d
+// 0.536032
+0x3f093960
+// 0.495650
+0x3efdc5ca
+// 0.942759
+0x3f7158a4
+// 0.463760
+0x3eed71ee
+// 0.172052
+0x3e302e81
+// 0.748209
+0x3f3f8aa1
+// 0.500300
+0x3f0013af
+// 0.557571
+0x3f0ebcfe
+// 0.620976
+0x3f1ef842
+// 0.967769
+0x3f77bfb3
+// 0.359497
+0x3eb80ff3
+// 0.837588
+0x3f566c25
+// 0.260518
+0x3e856296
+// 0.808148
+0x3f4ee2c9
+// 0.649916
+0x3f2660e8
+// 0.720985
+0x3f38927e
--- a/Testing/Patterns/DSP/Support/SupportF32/Weights2_f32.txt
+++ b/Testing/Patterns/DSP/Support/SupportF32/Weights2_f32.txt
@ -0,0 +1,402 @@
+W
+200
+// 0.638129
+0x3f235c6f
+// 0.254472
+0x3e824a37
+// 0.723874
+0x3f394fcc
+// 0.020313
+0x3ca667ba
+// 0.726854
+0x3f3a1319
+// 0.315436
+0x3ea180dc
+// 0.397950
+0x3ecbc01a
+// 0.420919
+0x3ed782b4
+// 0.015265
+0x3c7a1967
+// 0.650127
+0x3f266eb4
+// 0.514076
+0x3f039a81
+// 0.054432
+0x3d5ef43b
+// 0.895423
+0x3f653a78
+// 0.088654
+0x3db5907b
+// 0.008649
+0x3c0db410
+// 0.037870
+0x3d1b1dd7
+// 0.260093
+0x3e852ad9
+// 0.571302
+0x3f1240d2
+// 0.779836
+0x3f47a358
+// 0.715233
+0x3f371988
+// 0.477539
+0x3ef48008
+// 0.669333
+0x3f2b5969
+// 0.538544
+0x3f09de06
+// 0.007252
+0x3beda19d
+// 0.843210
+0x3f57dc9a
+// 0.897662
+0x3f65cd2e
+// 0.112237
+0x3de5dca3
+// 0.194572
+0x3e473de5
+// 0.412749
+0x3ed353d5
+// 0.340319
+0x3eae3e4b
+// 0.064651
+0x3d84678e
+// 0.588245
+0x3f169739
+// 0.397727
+0x3ecba2e5
+// 0.282922
+0x3e90db1d
+// 0.532793
+0x3f086519
+// 0.927444
+0x3f6d6cf9
+// 0.161669
+0x3e258c97
+// 0.535777
+0x3f0928ab
+// 0.389989
+0x3ec7aca0
+// 0.082042
+0x3da80573
+// 0.600067
+0x3f199df7
+// 0.767204
+0x3f446777
+// 0.225625
+0x3e670a5f
+// 0.919176
+0x3f6b4f1e
+// 0.345623
+0x3eb0f574
+// 0.902107
+0x3f66f07c
+// 0.913051
+0x3f69bdb2
+// 0.168229
+0x3e2c4444
+// 0.861636
+0x3f5c942c
+// 0.494293
+0x3efd13ec
+// 0.282606
+0x3e90b1be
+// 0.324541
+0x3ea62a36
+// 0.038708
+0x3d1e8c8a
+// 0.689617
+0x3f308ac4
+// 0.575708
+0x3f136196
+// 0.344006
+0x3eb02193
+// 0.611973
+0x3f1caa3d
+// 0.017655
+0x3c90a111
+// 0.931044
+0x3f6e58df
+// 0.520844
+0x3f05560d
+// 0.766831
+0x3f444f04
+// 0.020616
+0x3ca8e385
+// 0.582073
+0x3f1502c0
+// 0.917408
+0x3f6adb47
+// 0.923362
+0x3f6c616c
+// 0.050413
+0x3d4e7e25
+// 0.116369
+0x3dee5315
+// 0.095357
+0x3dc34ab0
+// 0.188270
+0x3e40c9d0
+// 0.116561
+0x3deeb7bb
+// 0.880322
+0x3f615ccd
+// 0.497289
+0x3efe9c99
+// 0.348279
+0x3eb25192
+// 0.350309
+0x3eb35bb9
+// 0.285099
+0x3e91f87c
+// 0.970068
+0x3f78565b
+// 0.836976
+0x3f564409
+// 0.747299
+0x3f3f4ef6
+// 0.545895
+0x3f0bbfc4
+// 0.084308
+0x3daca998
+// 0.799546
+0x3f4caf0d
+// 0.213169
+0x3e5a48e2
+// 0.168221
+0x3e2c421d
+// 0.687065
+0x3f2fe377
+// 0.931590
+0x3f6e7cab
+// 0.993652
+0x3f7e5ffd
+// 0.813116
+0x3f50285a
+// 0.481569
+0x3ef69041
+// 0.235736
+0x3e7164d9
+// 0.134703
+0x3e09ef8a
+// 0.033671
+0x3d09eaa4
+// 0.329538
+0x3ea8b945
+// 0.256791
+0x3e837a29
+// 0.533936
+0x3f08b003
+// 0.665121
+0x3f2a455d
+// 0.084276
+0x3dac98f2
+// 0.020354
+0x3ca6bd6f
+// 0.233638
+0x3e6f3ed4
+// 0.385820
+0x3ec58a2d
+// 0.559866
+0x3f0f535d
+// 0.806840
+0x3f4e8d09
+// 0.892163
+0x3f6464d0
+// 0.840442
+0x3f572734
+// 0.093045
+0x3dbe8e98
+// 0.159565
+0x3e2364f0
+// 0.008332
+0x3c088134
+// 0.261533
+0x3e85e7a1
+// 0.718751
+0x3f38000d
+// 0.908373
+0x3f688b24
+// 0.286196
+0x3e928857
+// 0.386615
+0x3ec5f266
+// 0.032316
+0x3d045e07
+// 0.561888
+0x3f0fd7e2
+// 0.678582
+0x3f2db793
+// 0.429907
+0x3edc1cc5
+// 0.989010
+0x3f7d2fc3
+// 0.270092
+0x3e8a4989
+// 0.991199
+0x3f7dbf35
+// 0.189608
+0x3e42287c
+// 0.350798
+0x3eb39bd0
+// 0.986667
+0x3f7c9634
+// 0.811062
+0x3f4fa1c8
+// 0.764458
+0x3f43b387
+// 0.276976
+0x3e8dcfd6
+// 0.543240
+0x3f0b11c3
+// 0.833602
+0x3f5566f2
+// 0.462286
+0x3eecb0cd
+// 0.278448
+0x3e8e90b6
+// 0.580846
+0x3f14b254
+// 0.556519
+0x3f0e780f
+// 0.358635
+0x3eb79f07
+// 0.953307
+0x3f740bec
+// 0.964943
+0x3f770686
+// 0.754165
+0x3f4110f3
+// 0.711142
+0x3f360d65
+// 0.587141
+0x3f164edf
+// 0.663216
+0x3f29c882
+// 0.558406
+0x3f0ef3ae
+// 0.486692
+0x3ef92fbc
+// 0.118436
+0x3df28ebf
+// 0.494508
+0x3efd3024
+// 0.518392
+0x3f04b552
+// 0.461293
+0x3eec2ea7
+// 0.033888
+0x3d0ace9d
+// 0.588277
+0x3f169953
+// 0.953013
+0x3f73f8b0
+// 0.022612
+0x3cb93be2
+// 0.000183
+0x39403be1
+// 0.546595
+0x3f0beda8
+// 0.209698
+0x3e56bb25
+// 0.796810
+0x3f4bfbb9
+// 0.361966
+0x3eb95397
+// 0.609215
+0x3f1bf58a
+// 0.532554
+0x3f085572
+// 0.463366
+0x3eed3e4d
+// 0.139539
+0x3e0ee340
+// 0.628848
+0x3f20fc36
+// 0.775611
+0x3f468e6e
+// 0.025205
+0x3cce7a5e
+// 0.291387
+0x3e9530ab
+// 0.802305
+0x3f4d63d7
+// 0.474789
+0x3ef31786
+// 0.106620
+0x3dda5b7e
+// 0.745083
+0x3f3ebdbb
+// 0.177656
+0x3e35eb91
+// 0.230110
+0x3e6ba209
+// 0.770730
+0x3f454e88
+// 0.085663
+0x3daf7021
+// 0.791534
+0x3f4aa1f6
+// 0.525241
+0x3f06762a
+// 0.283966
+0x3e916406
+// 0.823068
+0x3f52b49c
+// 0.589594
+0x3f16efaa
+// 0.473409
+0x3ef262a0
+// 0.337025
+0x3eac8e7f
+// 0.956632
+0x3f74e5d2
+// 0.151366
+0x3e1affaf
+// 0.686284
+0x3f2fb050
+// 0.885888
+0x3f62c990
+// 0.754843
+0x3f413d6c
+// 0.687155
+0x3f2fe95e
+// 0.477210
+0x3ef454d6
+// 0.154914
+0x3e1ea1e1
+// 0.832549
+0x3f5521eb
+// 0.482492
+0x3ef70921
+// 0.190564
+0x3e432344
+// 0.644851
+0x3f2514f0
+// 0.411574
+0x3ed2b9cf
+// 0.838661
+0x3f56b282
+// 0.996485
+0x3f7f199e
+// 0.158135
+0x3e21ee25
+// 0.006741
+0x3bdce54a
+// 0.401145
+0x3ecd62ea
+// 0.084242
+0x3dac8726
+// 0.423921
+0x3ed90c27
+// 0.755393
+0x3f41616b
+// 0.689148
+0x3f306c08
+// 0.520759
+0x3f05506f
+// 0.160668
+0x3e24860b
+// 0.072175
+0x3d93d045
--- a/Testing/Source/StatsTestsF32.cpp
+++ b/Testing/Source/StatsTestsF32.cpp
@ -0,0 +1,155 @@
+#include "StatsTestsF32.h"
+#include "Error.h"
+#include "arm_math.h"
+#include "Test.h"
+
+#include <cstdio>
+
+
+    void StatsTestsF32::test_entropy_f32()
+    {
+      const float32_t *inp  = inputA.ptr();
+
+      float32_t *refp         = ref.ptr();
+      float32_t *outp         = output.ptr();
+      float32_t *result;
+
+      for(int i=0;i < this->nbPatterns; i++)
+      {
+         *outp = arm_entropy_f32(inp,this->vecDim);
+         outp++;
+         inp += vecDim;
+      }
+
+      ASSERT_NEAR_EQ(ref,output,(float32_t)1e-6);
+    } 
+
+    void StatsTestsF32::test_logsumexp_f32()
+    {
+      const float32_t *inp  = inputA.ptr();
+
+      float32_t *refp         = ref.ptr();
+      float32_t *outp         = output.ptr();
+      float32_t *result;
+
+      for(int i=0;i < this->nbPatterns; i++)
+      {
+         *outp = arm_logsumexp_f32(inp,this->vecDim);
+         outp++;
+         inp += vecDim;
+      }
+
+      ASSERT_NEAR_EQ(ref,output,(float32_t)1e-6);
+    } 
+
+
+    void StatsTestsF32::test_kullback_leibler_f32()
+    {
+      const float32_t *inpA  = inputA.ptr();
+      const float32_t *inpB  = inputB.ptr();
+
+      float32_t *refp         = ref.ptr();
+      float32_t *outp         = output.ptr();
+      float32_t *result;
+
+      for(int i=0;i < this->nbPatterns; i++)
+      {
+         *outp = arm_kullback_leibler_f32(inpA,inpB,this->vecDim);
+         outp++;
+         inpA += vecDim;
+         inpB += vecDim;
+      }
+
+      ASSERT_NEAR_EQ(ref,output,(float32_t)1e-6);
+    } 
+
+    void StatsTestsF32::test_logsumexp_dot_prod_f32()
+    {
+      const float32_t *inpA  = inputA.ptr();
+      const float32_t *inpB  = inputB.ptr();
+
+      float32_t *refp         = ref.ptr();
+      float32_t *outp         = output.ptr();
+      float32_t *tmpp         = tmp.ptr();
+      float32_t *result;
+
+      for(int i=0;i < this->nbPatterns; i++)
+      {
+         *outp = arm_logsumexp_dot_prod_f32(inpA,inpB,this->vecDim,tmpp);
+         outp++;
+         inpA += vecDim;
+         inpB += vecDim;
+      }
+
+      ASSERT_NEAR_EQ(ref,output,(float32_t)1e-6);
+    } 
+
+   
+  
+    void StatsTestsF32::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
+    {
+        switch(id)
+        {
+            case StatsTestsF32::TEST_ENTROPY_F32_1:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr);
+               dims.reload(StatsTestsF32::DIM1_S16_ID,mgr);
+               ref.reload(StatsTestsF32::REF1_ENTROPY_F32_ID,mgr);
+               output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr);
+
+               const int16_t *dimsp  = dims.ptr();
+               this->nbPatterns=dimsp[0];
+               this->vecDim=dimsp[1];
+            }
+            break;
+
+            case StatsTestsF32::TEST_LOGSUMEXP_F32_2:
+            {
+               inputA.reload(StatsTestsF32::INPUT2_F32_ID,mgr);
+               dims.reload(StatsTestsF32::DIM2_S16_ID,mgr);
+               ref.reload(StatsTestsF32::REF2_LOGSUMEXP_F32_ID,mgr);
+               output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr);
+
+               const int16_t *dimsp  = dims.ptr();
+               this->nbPatterns=dimsp[0];
+               this->vecDim=dimsp[1];
+            }
+            break;
+
+            case StatsTestsF32::TEST_KULLBACK_LEIBLER_F32_3:
+            {
+               inputA.reload(StatsTestsF32::INPUTA3_F32_ID,mgr);
+               inputB.reload(StatsTestsF32::INPUTB3_F32_ID,mgr);
+               dims.reload(StatsTestsF32::DIM3_S16_ID,mgr);
+               ref.reload(StatsTestsF32::REF3_KL_F32_ID,mgr);
+               output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr);
+
+               const int16_t *dimsp  = dims.ptr();
+               this->nbPatterns=dimsp[0];
+               this->vecDim=dimsp[1];
+            }
+            break;
+
+            case StatsTestsF32::TEST_LOGSUMEXP_DOT_PROD_F32_4:
+            {
+               inputA.reload(StatsTestsF32::INPUTA4_F32_ID,mgr);
+               inputB.reload(StatsTestsF32::INPUTB4_F32_ID,mgr);
+               dims.reload(StatsTestsF32::DIM4_S16_ID,mgr);
+               ref.reload(StatsTestsF32::REF4_LOGSUMEXP_DOT_F32_ID,mgr);
+               output.create(ref.nbSamples(),StatsTestsF32::OUT_F32_ID,mgr);
+
+               const int16_t *dimsp  = dims.ptr();
+               this->nbPatterns=dimsp[0];
+               this->vecDim=dimsp[1];
+
+               tmp.create(this->vecDim,StatsTestsF32::TMP_F32_ID,mgr);
+            }
+            break;
+        }
+        
+    }
+
+    void StatsTestsF32::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
+    {
+       output.dump(mgr);
+    }
--- a/Testing/Source/SupportTestsF32.cpp
+++ b/Testing/Source/SupportTestsF32.cpp
@ -0,0 +1,94 @@
+#include "SupportTestsF32.h"
+#include "Error.h"
+#include "arm_math.h"
+#include "Test.h"
+
+#include <cstdio>
+
+
+    void SupportTestsF32::test_barycenter_f32()
+    {
+       const float32_t *inp = input.ptr();
+       const float32_t *coefsp = coefs.ptr();
+
+       float32_t *outp = output.ptr();
+       
+       for(int i=0; i < this->nbPatterns ; i ++)
+       {
+        arm_barycenter_f32(inp, coefsp,
+            outp, 
+            this->nbVectors, 
+            this->vecDim);
+         
+          inp += this->vecDim * this->nbVectors;
+          coefsp += this->nbVectors;
+          outp += this->vecDim;
+       }
+
+        ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
+    } 
+
+    void SupportTestsF32::test_weighted_sum_f32()
+    {
+       const float32_t *inp = input.ptr();
+       const float32_t *coefsp = coefs.ptr();
+
+       float32_t *outp = output.ptr();
+       
+       for(int i=0; i < this->nbPatterns ; i ++)
+       {
+          *outp=arm_weighted_sum_f32(inp, coefsp,
+            this->vecDim);
+         
+          inp += this->vecDim;
+          coefsp += this->vecDim;
+          outp++;
+       }
+
+        ASSERT_NEAR_EQ(output,ref,(float32_t)1e-3);
+    } 
+
+  
+    void SupportTestsF32::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
+    {
+
+        switch(id)
+        {
+            case TEST_BARYCENTER_F32_1:
+            {
+              input.reload(SupportTestsF32::INPUTS1_F32_ID,mgr);
+              coefs.reload(SupportTestsF32::WEIGHTS1_F32_ID,mgr);
+              dims.reload(SupportTestsF32::DIMS1_S16_ID,mgr);
+              ref.reload(SupportTestsF32::REF1_F32_ID,mgr);
+
+              const int16_t   *dimsp = dims.ptr();
+
+              this->nbPatterns=dimsp[0];
+              this->nbVectors=dimsp[1];
+              this->vecDim=dimsp[2];
+              output.create(this->nbPatterns*this->vecDim,SupportTestsF32::OUT_F32_ID,mgr);
+            }
+            break;
+
+            case TEST_WEIGHTED_SUM_F32_2:
+              input.reload(SupportTestsF32::INPUTS2_F32_ID,mgr);
+              coefs.reload(SupportTestsF32::WEIGHTS2_F32_ID,mgr);
+              dims.reload(SupportTestsF32::DIMS2_S16_ID,mgr);
+              ref.reload(SupportTestsF32::REF2_F32_ID,mgr);
+
+              const int16_t   *dimsp = dims.ptr();
+
+              this->nbPatterns=dimsp[0];
+              this->vecDim=dimsp[1];
+              output.create(this->nbPatterns,SupportTestsF32::OUT_F32_ID,mgr);
+            break;
+        }
+
+       
+
+    }
+
+    void SupportTestsF32::tearDown(Testing::testID_t id,Client::PatternMgr *mgr)
+    {
+       output.dump(mgr);
+    }
--- a/Testing/TestDesc.txt
+++ b/Testing/TestDesc.txt
@ -5,25 +5,30 @@ n
 n
 y
 DSP
-3 3
+3 2
 n
 y
-Bayes
+Support
 2 1
 n
 y
-BayesF32
+SupportF32
 0
-5
-Dims1_s16.txt
+8
 Inputs1_f32.txt
-Params1_f32.txt
-Probas1_f32.txt
-Predicts1_s16.txt
-2
-Probas
-Predicts
+Dims1_s16.txt
+Weights1_f32.txt
+Ref1_f32.txt
+Inputs2_f32.txt
+Dims2_s16.txt
+Weights2_f32.txt
+Ref2_f32.txt
+1
+Output
 0
 1 1
 n
 n
+1 2
+n
+n
--- a/Testing/desc.txt
+++ b/Testing/desc.txt
@ -5,6 +5,73 @@ group Root {
        class = DSPTests
        folder = DSP

+        group Statistics Tests {
+           class = StatsTests
+           folder = Stats
+
+           suite Statistics Tests F32 {
+              class = StatsTestsF32
+              folder = StatsF32
+
+              Pattern INPUT1_F32_ID : Input1_f32.txt 
+              Pattern DIM1_S16_ID : Dims1_s16.txt 
+              Pattern REF1_ENTROPY_F32_ID : RefEntropy1_f32.txt
+
+              Pattern INPUT2_F32_ID : Input2_f32.txt 
+              Pattern DIM2_S16_ID : Dims2_s16.txt 
+              Pattern REF2_LOGSUMEXP_F32_ID : RefLogSumExp2_f32.txt
+
+              Pattern INPUTA3_F32_ID : InputA3_f32.txt 
+              Pattern INPUTB3_F32_ID : InputB3_f32.txt
+              Pattern DIM3_S16_ID : Dims3_s16.txt 
+              Pattern REF3_KL_F32_ID : RefKL3_f32.txt
+
+              Pattern INPUTA4_F32_ID : InputA4_f32.txt 
+              Pattern INPUTB4_F32_ID : InputB4_f32.txt
+              Pattern DIM4_S16_ID : Dims4_s16.txt 
+              Pattern REF4_LOGSUMEXP_DOT_F32_ID : RefLogSumExpDot4_f32.txt
+
+              Output  OUT_F32_ID : Output
+              Output  TMP_F32_ID : Temp
+
+              Functions {
+                arm_entropy_f32:test_entropy_f32
+                arm_logsumexp_f32:test_logsumexp_f32
+                arm_kullback_leibler_f32:test_kullback_leibler_f32
+                arm_logsumexp_dot_prod_f32:test_logsumexp_dot_prod_f32
+              }
+
+           }
+        }
+
+        group Support Tests {
+           class = SupportTests
+           folder = Support
+
+           suite Support Tests F32 {
+              class = SupportTestsF32
+              folder = SupportF32
+
+              Pattern INPUTS1_F32_ID : Inputs1_f32.txt 
+              Pattern DIMS1_S16_ID : Dims1_s16.txt 
+              Pattern WEIGHTS1_F32_ID : Weights1_f32.txt 
+              Pattern REF1_F32_ID : Ref1_f32.txt
+
+              Pattern INPUTS2_F32_ID : Inputs2_f32.txt 
+              Pattern DIMS2_S16_ID : Dims2_s16.txt 
+              Pattern WEIGHTS2_F32_ID : Weights2_f32.txt 
+              Pattern REF2_F32_ID : Ref2_f32.txt
+
+              Output  OUT_F32_ID : Output
+
+              Functions {
+                arm_barycenter_f32:test_barycenter_f32
+                arm_weighted_sum_f32:test_weighted_sum_f32
+              }
+
+           }
+        }
+
        group Basic Tests {
           class = BasicTests
           folder = BasicMaths