add l476 implementationl476

1 files changed, 268 insertions, 363 deletions

diff --git a/Drivers/CMSIS/DSP/Source/StatisticsFunctions/arm_min_f32.c b/Drivers/CMSIS/DSP/Source/StatisticsFunctions/arm_min_f32.c
index ad8a472..f6504aa 100644
--- a/Drivers/CMSIS/DSP/Source/StatisticsFunctions/arm_min_f32.c
+++ b/Drivers/CMSIS/DSP/Source/StatisticsFunctions/arm_min_f32.c
@@ -1,363 +1,268 @@
-/* ----------------------------------------------------------------------
- * Project:      CMSIS DSP Library
- * Title:        arm_min_f32.c
- * Description:  Minimum value of a floating-point vector
- *
- * $Date:        23 April 2021
- * $Revision:    V1.9.0
- *
- * Target Processor: Cortex-M and Cortex-A cores
- * -------------------------------------------------------------------- */
-/*
- * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
- *
- * SPDX-License-Identifier: Apache-2.0
- *
- * Licensed under the Apache License, Version 2.0 (the License); you may
- * not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "dsp/statistics_functions.h"
-
-#if (defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF)) && !defined(ARM_MATH_AUTOVECTORIZE)
-#include <limits.h>
-#endif
-
-
-/**
-  @ingroup groupStats
- */
-
-/**
-  @defgroup Min Minimum
-
-  Computes the minimum value of an array of data.
-  The function returns both the minimum value and its position within the array.
-  There are separate functions for floating-point, Q31, Q15, and Q7 data types.
- */
-
-/**
-  @addtogroup Min
-  @{
- */
-
-/**
-  @brief         Minimum value of a floating-point vector.
-  @param[in]     pSrc       points to the input vector
-  @param[in]     blockSize  number of samples in input vector
-  @param[out]    pResult    minimum value returned here
-  @param[out]    pIndex     index of minimum value returned here
-  @return        none
- */
-
-#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
-
-void arm_min_f32(
-  const float32_t * pSrc,
-  uint32_t blockSize,
-  float32_t * pResult,
-  uint32_t * pIndex)
-{
-    uint32_t  blkCnt;           /* loop counters */
-    f32x4_t vecSrc;
-    float32_t const *pSrcVec;
-    f32x4_t curExtremValVec = vdupq_n_f32(F32_MAX);
-    float32_t minValue = F32_MAX;
-    uint32_t  idx = blockSize;
-    uint32x4_t indexVec;
-    uint32x4_t curExtremIdxVec;
-    float32_t tmp;
-    mve_pred16_t p0;
-
-    indexVec = vidupq_u32((uint32_t)0, 1);
-    curExtremIdxVec = vdupq_n_u32(0);
-
-    pSrcVec = (float32_t const *) pSrc;
-    /* Compute 4 outputs at a time */
-    blkCnt = blockSize >> 2U;
-    while (blkCnt > 0U)
-    {
-        vecSrc = vldrwq_f32(pSrcVec);  
-        pSrcVec += 4;
-        /*
-         * Get current max per lane and current index per lane
-         * when a max is selected
-         */
-        p0 = vcmpleq(vecSrc, curExtremValVec);
-        curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
-        curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
-
-        indexVec = indexVec +  4;
-        /*
-         * Decrement the blockSize loop counter
-         */
-        blkCnt--;
-    }
-    
-    /*
-     * Get min value across the vector
-     */
-    minValue = vminnmvq(minValue, curExtremValVec);
-    /*
-     * set index for lower values to max possible index
-     */
-    p0 = vcmpleq(curExtremValVec, minValue);
-    indexVec = vpselq(curExtremIdxVec, vdupq_n_u32(blockSize), p0);
-    /*
-     * Get min index which is thus for a max value
-     */
-    idx = vminvq(idx, indexVec);
-
-    /*
-     * tail
-     */
-    blkCnt = blockSize & 0x3;
-
-    while (blkCnt > 0U)
-    {
-      /* Initialize minVal to the next consecutive values one by one */
-      tmp = *pSrc++;
-  
-      /* compare for the minimum value */
-      if (minValue > tmp)
-      {
-        /* Update the minimum value and it's index */
-        minValue = tmp;
-        idx = blockSize - blkCnt;
-      }
-      blkCnt--;
-    }
-    /*
-     * Save result
-     */
-    *pIndex = idx;
-    *pResult = minValue;
-}
-
-#else
-#if defined(ARM_MATH_NEON) && !defined(ARM_MATH_AUTOVECTORIZE)
-void arm_min_f32(
-  const float32_t * pSrc,
-  uint32_t blockSize,
-  float32_t * pResult,
-  uint32_t * pIndex)
-{
-  float32_t maxVal1, out;               /* Temporary variables to store the output value. */
-  uint32_t blkCnt, outIndex;              /* loop counter */
-
-  float32x4_t outV, srcV;
-  float32x2_t outV2;
-
-  uint32x4_t idxV;
-  static const uint32_t indexInit[4]={4,5,6,7};
-  static const uint32_t countVInit[4]={0,1,2,3};
-  uint32x4_t maxIdx;
-  uint32x4_t index;
-  uint32x4_t delta;
-  uint32x4_t countV;
-  uint32x2_t countV2;
-
-  maxIdx = vdupq_n_u32(ULONG_MAX);
-  delta = vdupq_n_u32(4);
-  index = vld1q_u32(indexInit);
-  countV = vld1q_u32(countVInit);
-
-  /* Initialise the index value to zero. */
-  outIndex = 0U;
-
-  /* Load first input value that act as reference value for comparison */
-  if (blockSize <= 3)
-  {
-      out = *pSrc++;
-
-      blkCnt = blockSize - 1;
-
-      while (blkCnt > 0U)
-      {
-        /* Initialize maxVal to the next consecutive values one by one */
-        maxVal1 = *pSrc++;
-    
-        /* compare for the maximum value */
-        if (out > maxVal1)
-        {
-          /* Update the maximum value and it's index */
-          out = maxVal1;
-          outIndex = blockSize - blkCnt;
-        }
-    
-        /* Decrement the loop counter */
-        blkCnt--;
-      }
-  }
-  else
-  {
-      outV = vld1q_f32(pSrc);
-      pSrc += 4;
-    
-      /* Compute 4 outputs at a time */
-      blkCnt = (blockSize - 4 ) >> 2U;
-    
-      while (blkCnt > 0U)
-      {
-        srcV = vld1q_f32(pSrc);
-        pSrc += 4;
-    
-        idxV = vcltq_f32(srcV, outV);
-        outV = vbslq_f32(idxV, srcV, outV );
-        countV = vbslq_u32(idxV, index,countV );
-    
-        index = vaddq_u32(index,delta);
-    
-        /* Decrement the loop counter */
-        blkCnt--;
-      }
-    
-      outV2 = vpmin_f32(vget_low_f32(outV),vget_high_f32(outV));
-      outV2 = vpmin_f32(outV2,outV2);
-      out = vget_lane_f32(outV2,0); 
-    
-      idxV = vceqq_f32(outV, vdupq_n_f32(out));
-      countV = vbslq_u32(idxV, countV,maxIdx);
-      
-      countV2 = vpmin_u32(vget_low_u32(countV),vget_high_u32(countV));
-      countV2 = vpmin_u32(countV2,countV2);
-      outIndex = vget_lane_u32(countV2,0); 
-    
-      /* if (blockSize - 1U) is not multiple of 4 */
-      blkCnt = (blockSize - 4 ) % 4U;
-    
-      while (blkCnt > 0U)
-      {
-        /* Initialize maxVal to the next consecutive values one by one */
-        maxVal1 = *pSrc++;
-    
-        /* compare for the maximum value */
-        if (out > maxVal1)
-        {
-          /* Update the maximum value and it's index */
-          out = maxVal1;
-          outIndex = blockSize - blkCnt ;
-        }
-    
-        /* Decrement the loop counter */
-        blkCnt--;
-      }
-  }
-
-  /* Store the maximum value and it's index into destination pointers */
-  *pResult = out;
-  *pIndex = outIndex;
-}
-#else
-void arm_min_f32(
-  const float32_t * pSrc,
-        uint32_t blockSize,
-        float32_t * pResult,
-        uint32_t * pIndex)
-{
-        float32_t minVal, out;                         /* Temporary variables to store the output value. */
-        uint32_t blkCnt, outIndex;                     /* Loop counter */
-
-#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
-        uint32_t index;                                /* index of maximum value */
-#endif
-
-  /* Initialise index value to zero. */
-  outIndex = 0U;
-
-  /* Load first input value that act as reference value for comparision */
-  out = *pSrc++;
-
-#if defined (ARM_MATH_LOOPUNROLL) && !defined(ARM_MATH_AUTOVECTORIZE)
-  /* Initialise index of maximum value. */
-  index = 0U;
-
-  /* Loop unrolling: Compute 4 outputs at a time */
-  blkCnt = (blockSize - 1U) >> 2U;
-
-  while (blkCnt > 0U)
-  {
-    /* Initialize minVal to next consecutive values one by one */
-    minVal = *pSrc++;
-
-    /* compare for the minimum value */
-    if (out > minVal)
-    {
-      /* Update the minimum value and it's index */
-      out = minVal;
-      outIndex = index + 1U;
-    }
-
-    minVal = *pSrc++;
-    if (out > minVal)
-    {
-      out = minVal;
-      outIndex = index + 2U;
-    }
-
-    minVal = *pSrc++;
-    if (out > minVal)
-    {
-      out = minVal;
-      outIndex = index + 3U;
-    }
-
-    minVal = *pSrc++;
-    if (out > minVal)
-    {
-      out = minVal;
-      outIndex = index + 4U;
-    }
-
-    index += 4U;
-
-    /* Decrement loop counter */
-    blkCnt--;
-  }
-
-  /* Loop unrolling: Compute remaining outputs */
-  blkCnt = (blockSize - 1U) % 4U;
-
-#else
-
-  /* Initialize blkCnt with number of samples */
-  blkCnt = (blockSize - 1U);
-
-#endif /* #if defined (ARM_MATH_LOOPUNROLL) */
-
-  while (blkCnt > 0U)
-  {
-    /* Initialize minVal to the next consecutive values one by one */
-    minVal = *pSrc++;
-
-    /* compare for the minimum value */
-    if (out > minVal)
-    {
-      /* Update the minimum value and it's index */
-      out = minVal;
-      outIndex = blockSize - blkCnt;
-    }
-
-    /* Decrement loop counter */
-    blkCnt--;
-  }
-
-  /* Store the minimum value and it's index into destination pointers */
-  *pResult = out;
-  *pIndex = outIndex;
-}
-#endif /* #if defined(ARM_MATH_NEON) */
-#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
-
-/**
-  @} end of Min group
- */
+/* ----------------------------------------------------------------------

+ * Project:      CMSIS DSP Library

+ * Title:        arm_min_f32.c

+ * Description:  Minimum value of a floating-point vector

+ *

+ * $Date:        18. March 2019

+ * $Revision:    V1.6.0

+ *

+ * Target Processor: Cortex-M 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>

+

+/**

+  @ingroup groupStats

+ */

+

+/**

+  @defgroup Min Minimum

+

+  Computes the minimum value of an array of data.

+  The function returns both the minimum value and its position within the array.

+  There are separate functions for floating-point, Q31, Q15, and Q7 data types.

+ */

+

+/**

+  @addtogroup Min

+  @{

+ */

+

+/**

+  @brief         Minimum value of a floating-point vector.

+  @param[in]     pSrc       points to the input vector

+  @param[in]     blockSize  number of samples in input vector

+  @param[out]    pResult    minimum value returned here

+  @param[out]    pIndex     index of minimum value returned here

+  @return        none

+ */

+#if defined(ARM_MATH_NEON)

+void arm_min_f32(

+  const float32_t * pSrc,

+  uint32_t blockSize,

+  float32_t * pResult,

+  uint32_t * pIndex)

+{

+  float32_t maxVal1, maxVal2, out;               /* Temporary variables to store the output value. */

+  uint32_t blkCnt, outIndex, count;              /* loop counter */

+

+  float32x4_t outV, srcV;

+  float32x2_t outV2;

+

+  uint32x4_t idxV;

+  uint32x4_t maxIdx={ULONG_MAX,ULONG_MAX,ULONG_MAX,ULONG_MAX};

+  uint32x4_t index={4,5,6,7};

+  uint32x4_t delta={4,4,4,4};

+  uint32x4_t countV={0,1,2,3};

+  uint32x2_t countV2;

+

+  /* Initialise the count value. */

+  count = 0U;

+

+  /* Initialise the index value to zero. */

+  outIndex = 0U;

+

+  /* Load first input value that act as reference value for comparison */

+  if (blockSize <= 3)

+  {

+      out = *pSrc++;

+

+      blkCnt = blockSize - 1;

+

+      while (blkCnt > 0U)

+      {

+        /* Initialize maxVal to the next consecutive values one by one */

+        maxVal1 = *pSrc++;

+    

+        /* compare for the maximum value */

+        if (out > maxVal1)

+        {

+          /* Update the maximum value and it's index */

+          out = maxVal1;

+          outIndex = blockSize - blkCnt;

+        }

+    

+        /* Decrement the loop counter */

+        blkCnt--;

+      }

+  }

+  else

+  {

+      outV = vld1q_f32(pSrc);

+      pSrc += 4;

+    

+      /* Compute 4 outputs at a time */

+      blkCnt = (blockSize - 4 ) >> 2U;

+    

+      while (blkCnt > 0U)

+      {

+        srcV = vld1q_f32(pSrc);

+        pSrc += 4;

+    

+        idxV = vcltq_f32(srcV, outV);

+        outV = vbslq_f32(idxV, srcV, outV );

+        countV = vbslq_u32(idxV, index,countV );

+    

+        index = vaddq_u32(index,delta);

+    

+        /* Decrement the loop counter */

+        blkCnt--;

+      }

+    

+      outV2 = vpmin_f32(vget_low_f32(outV),vget_high_f32(outV));

+      outV2 = vpmin_f32(outV2,outV2);

+      out = outV2[0];

+    

+      idxV = vceqq_f32(outV, vdupq_n_f32(out));

+      countV = vbslq_u32(idxV, countV,maxIdx);

+      

+      countV2 = vpmin_u32(vget_low_u32(countV),vget_high_u32(countV));

+      countV2 = vpmin_u32(countV2,countV2);

+      outIndex = countV2[0];

+    

+      /* if (blockSize - 1U) is not multiple of 4 */

+      blkCnt = (blockSize - 4 ) % 4U;

+    

+      while (blkCnt > 0U)

+      {

+        /* Initialize maxVal to the next consecutive values one by one */

+        maxVal1 = *pSrc++;

+    

+        /* compare for the maximum value */

+        if (out > maxVal1)

+        {

+          /* Update the maximum value and it's index */

+          out = maxVal1;

+          outIndex = blockSize - blkCnt ;

+        }

+    

+        /* Decrement the loop counter */

+        blkCnt--;

+      }

+  }

+

+  /* Store the maximum value and it's index into destination pointers */

+  *pResult = out;

+  *pIndex = outIndex;

+}

+#else

+void arm_min_f32(

+  const float32_t * pSrc,

+        uint32_t blockSize,

+        float32_t * pResult,

+        uint32_t * pIndex)

+{

+        float32_t minVal, out;                         /* Temporary variables to store the output value. */

+        uint32_t blkCnt, outIndex;                     /* Loop counter */

+

+#if defined (ARM_MATH_LOOPUNROLL)

+        uint32_t index;                                /* index of maximum value */

+#endif

+

+  /* Initialise index value to zero. */

+  outIndex = 0U;

+

+  /* Load first input value that act as reference value for comparision */

+  out = *pSrc++;

+

+#if defined (ARM_MATH_LOOPUNROLL)

+  /* Initialise index of maximum value. */

+  index = 0U;

+

+  /* Loop unrolling: Compute 4 outputs at a time */

+  blkCnt = (blockSize - 1U) >> 2U;

+

+  while (blkCnt > 0U)

+  {

+    /* Initialize minVal to next consecutive values one by one */

+    minVal = *pSrc++;

+

+    /* compare for the minimum value */

+    if (out > minVal)

+    {

+      /* Update the minimum value and it's index */

+      out = minVal;

+      outIndex = index + 1U;

+    }

+

+    minVal = *pSrc++;

+    if (out > minVal)

+    {

+      out = minVal;

+      outIndex = index + 2U;

+    }

+

+    minVal = *pSrc++;

+    if (out > minVal)

+    {

+      out = minVal;

+      outIndex = index + 3U;

+    }

+

+    minVal = *pSrc++;

+    if (out > minVal)

+    {

+      out = minVal;

+      outIndex = index + 4U;

+    }

+

+    index += 4U;

+

+    /* Decrement loop counter */

+    blkCnt--;

+  }

+

+  /* Loop unrolling: Compute remaining outputs */

+  blkCnt = (blockSize - 1U) % 4U;

+

+#else

+

+  /* Initialize blkCnt with number of samples */

+  blkCnt = (blockSize - 1U);

+

+#endif /* #if defined (ARM_MATH_LOOPUNROLL) */

+

+  while (blkCnt > 0U)

+  {

+    /* Initialize minVal to the next consecutive values one by one */

+    minVal = *pSrc++;

+

+    /* compare for the minimum value */

+    if (out > minVal)

+    {

+      /* Update the minimum value and it's index */

+      out = minVal;

+      outIndex = blockSize - blkCnt;

+    }

+

+    /* Decrement loop counter */

+    blkCnt--;

+  }

+

+  /* Store the minimum value and it's index into destination pointers */

+  *pResult = out;

+  *pIndex = outIndex;

+}

+#endif /* #if defined(ARM_MATH_NEON) */

+

+/**

+  @} end of Min group

+ */