CMSIS-DSP: New min/max functions.

Added arm_(max|min)_no_idx_(q7|q15|q31|f16|f32|f64).c
Added arm_abs(max|min)_no_idx_(q7|q15|q31|f16|f32|f64).c

For both functions : Helium and scalar versions.

CMSIS/DSP/Include/dsp/statistics_functions.h

@@ -425,6 +425,17 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
         q7_t * result,
         uint32_t * index);
 
+    /**
+   * @brief  Minimum value of absolute values of a Q7 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] result     is output pointer
+   */
+  void arm_absmin_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * result);
+
 
   /**
    * @brief  Minimum value of a Q15 vector.
@@ -452,6 +463,17 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
         q15_t * pResult,
         uint32_t * pIndex);
 
+  /**
+   * @brief  Minimum value of absolute values of a Q15 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output pointer
+   */
+  void arm_absmin_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult);
+
 
   /**
    * @brief  Minimum value of a Q31 vector.
@@ -479,6 +501,17 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
         q31_t * pResult,
         uint32_t * pIndex);
 
+ /**
+   * @brief  Minimum value of absolute values of a Q31 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output pointer
+   */
+  void arm_absmin_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult);
+
 
   /**
    * @brief  Minimum value of a floating-point vector.
@@ -506,6 +539,17 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
         float32_t * pResult,
         uint32_t * pIndex);
 
+  /**
+   * @brief  Minimum value of absolute values of a floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output pointer
+   */
+  void arm_absmin_no_idx_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult);
+
 
   /**
    * @brief  Minimum value of a floating-point vector.
@@ -533,6 +577,17 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
         float64_t * pResult,
         uint32_t * pIndex);
 
+  /**
+   * @brief  Minimum value of absolute values of a floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output pointer
+   */
+  void arm_absmin_no_idx_f64(
+  const float64_t * pSrc,
+        uint32_t blockSize,
+        float64_t * pResult);
+
 
 /**
  * @brief Maximum value of a Q7 vector.
@@ -560,6 +615,17 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
         q7_t * pResult,
         uint32_t * pIndex);
 
+/**
+ * @brief Maximum value of absolute values of a Q7 vector.
+ * @param[in]  pSrc       points to the input buffer
+ * @param[in]  blockSize  length of the input vector
+ * @param[out] pResult    maximum value returned here
+ */
+  void arm_absmax_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult);
+
 
 /**
  * @brief Maximum value of a Q15 vector.
@@ -587,6 +653,17 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
         q15_t * pResult,
         uint32_t * pIndex);
 
+  /**
+ * @brief Maximum value of absolute values of a Q15 vector.
+ * @param[in]  pSrc       points to the input buffer
+ * @param[in]  blockSize  length of the input vector
+ * @param[out] pResult    maximum value returned here
+ */
+  void arm_absmax_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult);
+
 /**
  * @brief Maximum value of a Q31 vector.
  * @param[in]  pSrc       points to the input buffer
@@ -613,6 +690,17 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
         q31_t * pResult,
         uint32_t * pIndex);
 
+ /**
+ * @brief Maximum value of absolute values of a Q31 vector.
+ * @param[in]  pSrc       points to the input buffer
+ * @param[in]  blockSize  length of the input vector
+ * @param[out] pResult    maximum value returned here
+ */
+  void arm_absmax_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult);
+
 /**
  * @brief Maximum value of a floating-point vector.
  * @param[in]  pSrc       points to the input buffer
@@ -639,6 +727,17 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
         float32_t * pResult,
         uint32_t * pIndex);
 
+ /**
+ * @brief Maximum value of absolute values of a floating-point vector.
+ * @param[in]  pSrc       points to the input buffer
+ * @param[in]  blockSize  length of the input vector
+ * @param[out] pResult    maximum value returned here
+ */
+  void arm_absmax_no_idx_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult);
+
 /**
  * @brief Maximum value of a floating-point vector.
  * @param[in]  pSrc       points to the input buffer
@@ -665,6 +764,17 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
         float64_t * pResult,
         uint32_t * pIndex);
 
+/**
+ * @brief Maximum value of absolute values of a floating-point vector.
+ * @param[in]  pSrc       points to the input buffer
+ * @param[in]  blockSize  length of the input vector
+ * @param[out] pResult    maximum value returned here
+ */
+  void arm_absmax_no_idx_f64(
+  const float64_t * pSrc,
+        uint32_t blockSize,
+        float64_t * pResult);
+
   /**
     @brief         Maximum value of a floating-point vector.
     @param[in]     pSrc       points to the input vector
@@ -677,6 +787,18 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
       uint32_t   blockSize,
       float32_t *pResult);
 
+  /**
+    @brief         Minimum value of a floating-point vector.
+    @param[in]     pSrc       points to the input vector
+    @param[in]     blockSize  number of samples in input vector
+    @param[out]    pResult    minimum value returned here
+    @return        none
+   */
+  void arm_min_no_idx_f32(
+      const float32_t *pSrc,
+      uint32_t   blockSize,
+      float32_t *pResult);
+
   /**
     @brief         Maximum value of a floating-point vector.
     @param[in]     pSrc       points to the input vector
@@ -689,6 +811,90 @@ float64_t arm_kullback_leibler_f64(const float64_t * pSrcA,
       uint32_t   blockSize,
       float64_t *pResult);
 
+  /**
+    @brief         Maximum value of a q31 vector.
+    @param[in]     pSrc       points to the input vector
+    @param[in]     blockSize  number of samples in input vector
+    @param[out]    pResult    maximum value returned here
+    @return        none
+   */
+  void arm_max_no_idx_q31(
+      const q31_t *pSrc,
+      uint32_t   blockSize,
+      q31_t *pResult);
+
+  /**
+    @brief         Maximum value of a q15 vector.
+    @param[in]     pSrc       points to the input vector
+    @param[in]     blockSize  number of samples in input vector
+    @param[out]    pResult    maximum value returned here
+    @return        none
+   */
+  void arm_max_no_idx_q15(
+      const q15_t *pSrc,
+      uint32_t   blockSize,
+      q15_t *pResult);
+
+  /**
+    @brief         Maximum value of a q7 vector.
+    @param[in]     pSrc       points to the input vector
+    @param[in]     blockSize  number of samples in input vector
+    @param[out]    pResult    maximum value returned here
+    @return        none
+   */
+  void arm_max_no_idx_q7(
+      const q7_t *pSrc,
+      uint32_t   blockSize,
+      q7_t *pResult);
+
+  /**
+    @brief         Minimum value of a floating-point vector.
+    @param[in]     pSrc       points to the input vector
+    @param[in]     blockSize  number of samples in input vector
+    @param[out]    pResult    minimum value returned here
+    @return        none
+   */
+  void arm_min_no_idx_f64(
+      const float64_t *pSrc,
+      uint32_t   blockSize,
+      float64_t *pResult);
+
+/**
+    @brief         Minimum value of a q31 vector.
+    @param[in]     pSrc       points to the input vector
+    @param[in]     blockSize  number of samples in input vector
+    @param[out]    pResult    minimum value returned here
+    @return        none
+   */
+  void arm_min_no_idx_q31(
+      const q31_t *pSrc,
+      uint32_t   blockSize,
+      q31_t *pResult);
+
+  /**
+    @brief         Minimum value of a q15 vector.
+    @param[in]     pSrc       points to the input vector
+    @param[in]     blockSize  number of samples in input vector
+    @param[out]    pResult    minimum value returned here
+    @return        none
+   */
+  void arm_min_no_idx_q15(
+      const q15_t *pSrc,
+      uint32_t   blockSize,
+      q15_t *pResult);
+
+  /**
+    @brief         Minimum value of a q7 vector.
+    @param[in]     pSrc       points to the input vector
+    @param[in]     blockSize  number of samples in input vector
+    @param[out]    pResult    minimum value returned here
+    @return        none
+   */
+  void arm_min_no_idx_q7(
+      const q7_t *pSrc,
+      uint32_t   blockSize,
+      q7_t *pResult);
+
 
 
 #ifdef   __cplusplus

CMSIS/DSP/Include/dsp/statistics_functions_f16.h

@@ -150,6 +150,29 @@ extern "C"
         float16_t * pResult,
         uint32_t * pIndex);
 
+    /**
+   * @brief  Minimum value of absolute values of a floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output pointer
+   */
+  void arm_absmin_no_idx_f16(
+  const float16_t * pSrc,
+        uint32_t blockSize,
+        float16_t * pResult);
+
+/**
+ * @brief Maximum value of a floating-point vector.
+ * @param[in]  pSrc       points to the input buffer
+ * @param[in]  blockSize  length of the input vector
+ * @param[out] pResult    maximum value returned here
+ */
+  void arm_absmax_no_idx_f16(
+  const float16_t * pSrc,
+        uint32_t blockSize,
+        float16_t * pResult);
+
+
 /**
  * @brief Entropy
  *
@@ -208,7 +231,17 @@ float16_t arm_kullback_leibler_f16(const float16_t * pSrcA
       uint32_t   blockSize,
       float16_t *pResult);
 
-
+/**
+    @brief         Minimum value of a floating-point vector.
+    @param[in]     pSrc       points to the input vector
+    @param[in]     blockSize  number of samples in input vector
+    @param[out]    pResult    minimum value returned here
+    @return        none
+   */
+  void arm_min_no_idx_f16(
+      const float16_t *pSrc,
+      uint32_t   blockSize,
+      float16_t *pResult);
 
 #endif /*defined(ARM_FLOAT16_SUPPORTED)*/
 #ifdef   __cplusplus

CMSIS/DSP/Source/StatisticsFunctions/CMakeLists.txt

@@ -19,9 +19,14 @@ target_sources(CMSISDSPStatistics PRIVATE arm_max_f32.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_max_f64.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_max_no_idx_f32.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_max_no_idx_f64.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_min_no_idx_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_min_no_idx_f64.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_max_q15.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_max_q31.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_max_q7.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_max_no_idx_q31.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_max_no_idx_q15.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_max_no_idx_q7.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_mean_f32.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_mean_f64.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_mean_q15.c)
@@ -32,6 +37,9 @@ target_sources(CMSISDSPStatistics PRIVATE arm_min_f64.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_min_q15.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_min_q31.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_min_q7.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_min_no_idx_q31.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_min_no_idx_q15.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_min_no_idx_q7.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_power_f32.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_power_f64.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_power_q15.c)
@@ -61,6 +69,18 @@ target_sources(CMSISDSPStatistics PRIVATE arm_absmin_q15.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_absmin_q31.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_absmin_q7.c)
 
+target_sources(CMSISDSPStatistics PRIVATE arm_absmax_no_idx_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_absmax_no_idx_f64.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_absmax_no_idx_q15.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_absmax_no_idx_q31.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_absmax_no_idx_q7.c)
+
+target_sources(CMSISDSPStatistics PRIVATE arm_absmin_no_idx_f32.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_absmin_no_idx_f64.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_absmin_no_idx_q15.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_absmin_no_idx_q31.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_absmin_no_idx_q7.c)
+
 configLib(CMSISDSPStatistics ${ROOT})
 configDsp(CMSISDSPStatistics ${ROOT})
 
@@ -82,8 +102,10 @@ target_sources(CMSISDSPStatistics PRIVATE arm_kullback_leibler_f16.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_logsumexp_dot_prod_f16.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_logsumexp_f16.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_max_no_idx_f16.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_min_no_idx_f16.c)
 
 target_sources(CMSISDSPStatistics PRIVATE arm_absmax_f16.c)
 target_sources(CMSISDSPStatistics PRIVATE arm_absmin_f16.c)
-
+target_sources(CMSISDSPStatistics PRIVATE arm_absmax_no_idx_f16.c)
+target_sources(CMSISDSPStatistics PRIVATE arm_absmin_no_idx_f16.c)
 endif()

CMSIS/DSP/Source/StatisticsFunctions/StatisticsFunctions.c

@@ -39,6 +39,9 @@
 #include "arm_max_q7.c"
 #include "arm_max_no_idx_f32.c"
 #include "arm_max_no_idx_f64.c"
+#include "arm_max_no_idx_q31.c"
+#include "arm_max_no_idx_q15.c"
+#include "arm_max_no_idx_q7.c"
 #include "arm_mean_f32.c"
 #include "arm_mean_f64.c"
 #include "arm_mean_q15.c"
@@ -49,6 +52,11 @@
 #include "arm_min_q15.c"
 #include "arm_min_q31.c"
 #include "arm_min_q7.c"
+#include "arm_min_no_idx_f32.c"
+#include "arm_min_no_idx_f64.c"
+#include "arm_min_no_idx_q31.c"
+#include "arm_min_no_idx_q15.c"
+#include "arm_min_no_idx_q7.c"
 #include "arm_power_f32.c"
 #include "arm_power_f64.c"
 #include "arm_power_q15.c"
@@ -75,3 +83,13 @@
 #include "arm_absmin_q15.c"
 #include "arm_absmin_q31.c"
 #include "arm_absmin_q7.c"
+#include "arm_absmax_no_idx_f32.c"
+#include "arm_absmax_no_idx_f64.c"
+#include "arm_absmax_no_idx_q15.c"
+#include "arm_absmax_no_idx_q31.c"
+#include "arm_absmax_no_idx_q7.c"
+#include "arm_absmin_no_idx_f32.c"
+#include "arm_absmin_no_idx_f64.c"
+#include "arm_absmin_no_idx_q15.c"
+#include "arm_absmin_no_idx_q31.c"
+#include "arm_absmin_no_idx_q7.c"

CMSIS/DSP/Source/StatisticsFunctions/StatisticsFunctionsF16.c

@@ -38,5 +38,8 @@
 #include "arm_logsumexp_dot_prod_f16.c"
 #include "arm_logsumexp_f16.c"
 #include "arm_max_no_idx_f16.c"
+#include "arm_min_no_idx_f16.c"
 #include "arm_absmax_f16.c"
 #include "arm_absmin_f16.c"
+#include "arm_absmax_no_idx_f16.c"
+#include "arm_absmin_no_idx_f16.c"

CMSIS/DSP/Source/StatisticsFunctions/arm_absmax_no_idx_f16.c

@@ -0,0 +1,228 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmax_no_idx_f16.c
+ * Description:  Maximum value of a absolute values of a floating-point vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+#if (defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF)) && !defined(ARM_MATH_AUTOVECTORIZE)
+#include <limits.h>
+#endif
+
+/**
+  @ingroup groupStats
+ */
+
+
+/**
+  @addtogroup AbsMax
+  @{
+ */
+
+/**
+  @brief         Maximum value of absolute values of a floating-point vector.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    maximum value returned here
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+void arm_absmax_no_idx_f16(
+  const float16_t * pSrc,
+        uint32_t blockSize,
+        float16_t * pResult)
+{
+   uint16_t  blkCnt;           /* loop counters */
+    f16x8_t vecSrc;
+    float16_t const *pSrcVec;
+    f16x8_t curExtremValVec = vdupq_n_f16(F16_ABSMIN);
+    float16_t maxValue = F16_ABSMIN;
+    mve_pred16_t p0;
+
+
+    pSrcVec = (float16_t const *) pSrc;
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0)
+    {
+        vecSrc = vldrhq_f16(pSrcVec);  
+        pSrcVec += 8;
+        /*
+         * update per-lane max.
+         */
+        curExtremValVec = vmaxnmaq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        vecSrc = vldrhq_f16(pSrcVec);  
+        pSrcVec += 8;
+        p0 = vctp16q(blkCnt);
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+         curExtremValVec = vmaxnmaq_m(curExtremValVec, vecSrc, p0);
+    }
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxnmavq(maxValue, curExtremValVec);
+    *pResult = maxValue;
+}
+#else
+#if defined(ARM_MATH_LOOPUNROLL)
+void arm_absmax_no_idx_f16(
+  const float16_t * pSrc,
+        uint32_t blockSize,
+        float16_t * pResult)
+{
+        float16_t cur_absmax, out;                     /* Temporary variables to store the output value. */\
+        uint32_t blkCnt;                     /* Loop counter */                                   \
+                                                                                                            \
+                                                                                           \
+  /* Load first input value that act as reference value for comparision */                                  \
+  out = *pSrc++;                                                                                            \
+  out = ((_Float16)out > 0.0f16) ? out : -(_Float16)out;                                                                             \
+                                                                                             \
+                                                                                                            \
+  /* Loop unrolling: Compute 4 outputs at a time */                                                         \
+  blkCnt = (blockSize - 1U) >> 2U;                                                                          \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    /* Initialize cur_absmax to next consecutive values one by one */                                         \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = ((_Float16)cur_absmax > 0.0f16) ? cur_absmax : -(_Float16)cur_absmax;                                                                 \
+    /* compare for the extrema value */                                                                     \
+    if ((_Float16)cur_absmax > (_Float16)out)                                                                         \
+    {                                                                                                       \
+      /* Update the extrema value and it's index */                                                         \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = ((_Float16)cur_absmax > 0.0f16) ? cur_absmax : -(_Float16)cur_absmax;                                                                 \
+    if ((_Float16)cur_absmax > (_Float16)out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = ((_Float16)cur_absmax > 0.0f16) ? cur_absmax : -(_Float16)cur_absmax;                                                                 \
+    if ((_Float16)cur_absmax > (_Float16)out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = ((_Float16)cur_absmax > 0.0f16) ? cur_absmax : -(_Float16)cur_absmax;                                                                 \
+    if ((_Float16)cur_absmax > (_Float16)out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Loop unrolling: Compute remaining outputs */                                                           \
+  blkCnt = (blockSize - 1U) % 4U;                                                                           \
+                                                                                                            \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = ((_Float16)cur_absmax > 0.0f16) ? cur_absmax : -(_Float16)cur_absmax;                                                                 \
+    if ((_Float16)cur_absmax > (_Float16)out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Store the extrema value and it's index into destination pointers */                                    \
+  *pResult = out;                                                                                           \
+}
+#else
+void arm_absmax_no_idx_f16(
+  const float16_t * pSrc,
+        uint32_t blockSize,
+        float16_t * pResult)
+{
+        float16_t maxVal, out;                         /* Temporary variables to store the output value. */
+        uint32_t blkCnt;                     /* Loop counter */
+
+
+
+  /* Load first input value that act as reference value for comparision */
+  out = (_Float16)fabsf((float32_t)*pSrc++);
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize maxVal to the next consecutive values one by one */
+    maxVal = (_Float16)fabsf((float32_t)*pSrc++);
+
+    /* compare for the maximum value */
+    if ((_Float16)out < (_Float16)maxVal)
+    {
+      /* Update the maximum value and it's index */
+      out = maxVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the maximum value and it's index into destination pointers */
+  *pResult = out;
+}
+#endif /* defined(ARM_MATH_LOOPUNROLL) */
+#endif /* defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of AbsMax group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */ 
+

CMSIS/DSP/Source/StatisticsFunctions/arm_absmax_no_idx_f32.c

@@ -0,0 +1,225 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmax_no_idx_f32.c
+ * Description:  Maximum value of absolute values of a floating-point vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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
+ */
+
+
+/**
+  @addtogroup AbsMax
+  @{
+ */
+
+/**
+  @brief         Maximum value of absolute values of a floating-point vector.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    maximum value returned here
+  @return        none
+ */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_absmax_no_idx_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    f32x4_t vecSrc;
+    float32_t const *pSrcVec;
+    f32x4_t curExtremValVec = vdupq_n_f32(F32_ABSMIN);
+    float32_t maxValue = F32_ABSMIN;
+    mve_pred16_t p0;
+
+
+    pSrcVec = (float32_t const *) pSrc;
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0)
+    {
+        vecSrc = vldrwq_f32(pSrcVec);  
+        pSrcVec += 4;
+        /*
+         * update per-lane max.
+         */
+        curExtremValVec = vmaxnmaq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0)
+    {
+        vecSrc = vldrwq_f32(pSrcVec);  
+        pSrcVec += 4;
+        p0 = vctp32q(blkCnt);
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+         curExtremValVec = vmaxnmaq_m(curExtremValVec, vecSrc, p0);
+    }
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxnmavq(maxValue, curExtremValVec);
+    *pResult = maxValue;
+}
+
+
+#else
+#if defined(ARM_MATH_LOOPUNROLL)
+void arm_absmax_no_idx_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult)
+{
+        float32_t cur_absmax, out;                     /* Temporary variables to store the output value. */\
+        uint32_t blkCnt;                     /* Loop counter */                                   \
+                                                                                                            \
+  /* Load first input value that act as reference value for comparision */                                  \
+  out = *pSrc++;                                                                                            \
+  out = (out > 0.0f) ? out : -out;                                                                             \
+                                                                                                            \
+  /* Loop unrolling: Compute 4 outputs at a time */                                                         \
+  blkCnt = (blockSize - 1U) >> 2U;                                                                          \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    /* Initialize cur_absmax to next consecutive values one by one */                                         \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0.0f) ? cur_absmax : -cur_absmax;                                                                 \
+    /* compare for the extrema value */                                                                     \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      /* Update the extrema value and it's index */                                                         \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0.0f) ? cur_absmax : -cur_absmax;                                                                 \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0.0f) ? cur_absmax : -cur_absmax;                                                                 \
+    if (cur_absmax > out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0.0f) ? cur_absmax : -cur_absmax;                                                                 \
+    if (cur_absmax > out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Loop unrolling: Compute remaining outputs */                                                           \
+  blkCnt = (blockSize - 1U) % 4U;                                                                           \
+                                                                                                            \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0.0f) ? cur_absmax : -cur_absmax;                                                                 \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Store the extrema value and it's index into destination pointers */                                    \
+  *pResult = out;                                                                                           \
+}
+#else
+void arm_absmax_no_idx_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult)
+{
+        float32_t maxVal, out;                         /* Temporary variables to store the output value. */
+        uint32_t blkCnt;                     /* Loop counter */
+
+
+
+
+
+  /* Load first input value that act as reference value for comparision */
+  out = fabsf(*pSrc++);
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize maxVal to the next consecutive values one by one */
+    maxVal = fabsf(*pSrc++);
+
+    /* compare for the maximum value */
+    if (out < maxVal)
+    {
+      /* Update the maximum value and it's index */
+      out = maxVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the maximum value and it's index into destination pointers */
+  *pResult = out;
+}
+#endif /* defined(ARM_MATH_LOOPUNROLL) */
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of AbsMax group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_absmax_no_idx_f64.c

@@ -0,0 +1,87 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmax_no_idx_f64.c
+ * Description:  Maximum value of absolute values of a floating-point vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup AbsMax
+  @{
+ */
+
+/**
+  @brief         Maximum value of absolute values of a floating-point vector.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    maximum value returned here
+  @return        none
+ */
+void arm_absmax_no_idx_f64(
+  const float64_t * pSrc,
+        uint32_t blockSize,
+        float64_t * pResult)
+{
+        float64_t maxVal, out;                         /* Temporary variables to store the output value. */
+        uint32_t blkCnt;                     /* Loop counter */
+
+
+
+
+
+  /* Load first input value that act as reference value for comparision */
+  out = fabs(*pSrc++);
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize maxVal to the next consecutive values one by one */
+    maxVal = fabs(*pSrc++);
+
+    /* compare for the maximum value */
+    if (out < maxVal)
+    {
+      /* Update the maximum value and it's index */
+      out = maxVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the maximum value and it's index into destination pointers */
+  *pResult = out;
+}
+
+/**
+  @} end of AbsMax group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_absmax_no_idx_q15.c

@@ -0,0 +1,220 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmax_no_idx_q15.c
+ * Description:  Maximum value of absolute values of a Q15 vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup AbsMax
+  @{
+ */
+
+/**
+  @brief         Maximum value of absolute values of a Q15 vector.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    maximum value returned here
+  @return        none
+ */
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_absmax_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+    uint16_t        blkCnt;           /* loop counters */
+    q15x8_t       vecSrc;
+    q15_t   const *pSrcVec;
+    uint16x8_t    curExtremValVec = vdupq_n_s16(Q15_ABSMIN);
+    q15_t           maxValue = Q15_ABSMIN;
+    mve_pred16_t    p0;
+
+
+    pSrcVec = (q15_t const *) pSrc;
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0U)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 8;
+        /*
+         * update per-lane max.
+         */
+        curExtremValVec = vmaxaq(curExtremValVec, vecSrc);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0U)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 8;
+        p0 = vctp16q(blkCnt);
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+         curExtremValVec = vmaxaq_m(curExtremValVec, vecSrc, p0);
+    }
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxavq(maxValue, (q15x8_t)curExtremValVec);
+    *pResult = maxValue;
+}
+
+#else
+#if defined(ARM_MATH_DSP)
+void arm_absmax_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+        q15_t cur_absmax, out;                     /* Temporary variables to store the output value. */\
+        uint32_t blkCnt;                     /* Loop counter */                                   \
+                                                                                                            \
+                                                                                            \
+  /* Load first input value that act as reference value for comparision */                                  \
+  out = *pSrc++;                                                                                            \
+  out = (out > 0) ? out : (q15_t)__QSUB16(0, out);                                                                           \
+                                                                                              \
+                                                                                                            \
+  /* Loop unrolling: Compute 4 outputs at a time */                                                         \
+  blkCnt = (blockSize - 1U) >> 2U;                                                                          \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    /* Initialize cur_absmax to next consecutive values one by one */                                         \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q15_t)__QSUB16(0, cur_absmax);                                                                \
+    /* compare for the extrema value */                                                                     \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      /* Update the extrema value and it's index */                                                         \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q15_t)__QSUB16(0, cur_absmax);                                                                \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q15_t)__QSUB16(0, cur_absmax);                                                                \
+    if (cur_absmax > out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q15_t)__QSUB16(0, cur_absmax);                                                                 \
+    if (cur_absmax > out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Loop unrolling: Compute remaining outputs */                                                           \
+  blkCnt = (blockSize - 1U) % 4U;                                                                           \
+                                                                                                            \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q15_t)__QSUB16(0, cur_absmax);                                                                 \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Store the extrema value and it's index into destination pointers */                                    \
+  *pResult = out;                                                                                           \
+}
+#else
+void arm_absmax_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+       q15_t maxVal, out;                             /* Temporary variables to store the output value. */
+        uint32_t blkCnt;                     /* Loop counter */
+
+
+  /* Load first input value that act as reference value for comparision */
+  out = (*pSrc > 0) ? *pSrc : ((*pSrc == (q15_t) 0x8000) ? 0x7fff : -*pSrc);
+  pSrc++;
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize maxVal to the next consecutive values one by one */
+    maxVal = (*pSrc > 0) ? *pSrc : ((*pSrc == (q15_t) 0x8000) ? 0x7fff : -*pSrc);
+    pSrc++;
+
+    /* compare for the maximum value */
+    if (out < maxVal)
+    {
+      /* Update the maximum value and it's index */
+      out = maxVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the maximum value and it's index into destination pointers */
+  *pResult = out;
+}
+#endif /* defined(ARM_MATH_DSP) */
+#endif /* defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of AbsMax group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_absmax_no_idx_q31.c

@@ -0,0 +1,220 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmax_no_idx_q31.c
+ * Description:  Maximum value of absolute values of a Q31 vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup AbsMax
+  @{
+ */
+
+/**
+  @brief         Maximum value of absolute values of a Q31 vector.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    maximum value returned here
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+void arm_absmax_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q31x4_t       vecSrc;
+    q31_t   const *pSrcVec;
+    uint32x4_t    curExtremValVec = vdupq_n_s32(Q31_ABSMIN);
+    q31_t           maxValue = Q31_ABSMIN;
+    mve_pred16_t    p0;
+
+
+    pSrcVec = (q31_t const *) pSrc;
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0)
+    {
+        vecSrc = vldrwq_s32(pSrcVec);  
+        pSrcVec += 4;
+        /*
+         * update per-lane max.
+         */
+        curExtremValVec = vmaxaq(curExtremValVec, vecSrc);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0)
+    {
+        vecSrc = vldrwq_s32(pSrcVec);  
+        pSrcVec += 4;
+        p0 = vctp32q(blkCnt);
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+         curExtremValVec = vmaxaq_m(curExtremValVec, vecSrc, p0);
+    }
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxavq(maxValue, (q31x4_t)curExtremValVec);
+    *pResult = maxValue;
+}
+#else
+#if defined(ARM_MATH_DSP)
+void arm_absmax_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+        q31_t cur_absmax, out;                     /* Temporary variables to store the output value. */\
+        uint32_t blkCnt;                     /* Loop counter */                                   \
+                                                                                                            \
+                                                                                           \
+  /* Load first input value that act as reference value for comparision */                                  \
+  out = *pSrc++;                                                                                            \
+  out = (out > 0) ? out : (q31_t)__QSUB(0, out);                                                                           \
+                                                                                              \
+                                                                                                            \
+  /* Loop unrolling: Compute 4 outputs at a time */                                                         \
+  blkCnt = (blockSize - 1U) >> 2U;                                                                          \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    /* Initialize cur_absmax to next consecutive values one by one */                                         \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q31_t)__QSUB(0, cur_absmax);                                                                \
+    /* compare for the extrema value */                                                                     \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      /* Update the extrema value and it's index */                                                         \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q31_t)__QSUB(0, cur_absmax);                                                                \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q31_t)__QSUB(0, cur_absmax);                                                                \
+    if (cur_absmax > out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q31_t)__QSUB(0, cur_absmax);                                                                 \
+    if (cur_absmax > out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Loop unrolling: Compute remaining outputs */                                                           \
+  blkCnt = (blockSize - 1U) % 4U;                                                                           \
+                                                                                                            \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q31_t)__QSUB(0, cur_absmax);                                                                 \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Store the extrema value and it's index into destination pointers */                                    \
+  *pResult = out;                                                                                           \
+}
+#else
+void arm_absmax_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+        q31_t maxVal, out;                             /* Temporary variables to store the output value. */
+        uint32_t blkCnt;                     /* Loop counter */
+
+
+
+  /* Load first input value that act as reference value for comparision */
+  out = (*pSrc > 0) ? *pSrc : ((*pSrc == INT32_MIN) ? INT32_MAX : -*pSrc);
+  pSrc++;
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize maxVal to the next consecutive values one by one */
+    maxVal = (*pSrc > 0) ? *pSrc : ((*pSrc == INT32_MIN) ? INT32_MAX : -*pSrc);
+    pSrc++;
+
+    /* compare for the maximum value */
+    if (out < maxVal)
+    {
+      /* Update the maximum value and it's index */
+      out = maxVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the maximum value and it's index into destination pointers */
+  *pResult = out;
+}
+#endif /* defined(ARM_MATH_DSP) */
+#endif /* defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of AbsMax group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_absmax_no_idx_q7.c

@@ -0,0 +1,224 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmax_no_idx_q7.c
+ * Description:  Maximum value of absolute values of a Q7 vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup AbsMax
+  @{
+ */
+
+/**
+  @brief         Maximum value of absolute values of a Q7 vector.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    maximum value returned here
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include <stdint.h>
+#include "arm_helium_utils.h"
+
+
+
+void arm_absmax_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q7x16_t        vecSrc;
+    q7_t   const *pSrcVec;
+    uint8x16_t     curExtremValVec = vdupq_n_s8(Q7_ABSMIN);
+    q7_t            maxValue = Q7_ABSMIN;
+    mve_pred16_t    p0;
+
+
+    pSrcVec = (q7_t const *) pSrc;
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 16;
+        /*
+         * update per-lane max.
+         */
+        curExtremValVec = vmaxaq(curExtremValVec, vecSrc);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 16;
+        p0 = vctp8q(blkCnt);
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+         curExtremValVec = vmaxaq_m(curExtremValVec, vecSrc, p0);
+    }
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxavq(maxValue, (q7x16_t)curExtremValVec);
+    *pResult = maxValue;
+}
+#else
+#if defined(ARM_MATH_DSP)
+void arm_absmax_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult)
+{
+        q7_t cur_absmax, out;                     /* Temporary variables to store the output value. */\
+        uint32_t blkCnt;                     /* Loop counter */                                   \
+                                                                                                            \
+                                                                                           \
+  /* Load first input value that act as reference value for comparision */                                  \
+  out = *pSrc++;                                                                                            \
+  out = (out > 0) ? out : (q7_t)__QSUB8(0, out);                                                                           \
+                                                                                              \
+                                                                                                            \
+  /* Loop unrolling: Compute 4 outputs at a time */                                                         \
+  blkCnt = (blockSize - 1U) >> 2U;                                                                          \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    /* Initialize cur_absmax to next consecutive values one by one */                                         \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q7_t)__QSUB8(0, cur_absmax);                                                                \
+    /* compare for the extrema value */                                                                     \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      /* Update the extrema value and it's index */                                                         \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q7_t)__QSUB8(0, cur_absmax);                                                                \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q7_t)__QSUB8(0, cur_absmax);                                                                \
+    if (cur_absmax > out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q7_t)__QSUB8(0, cur_absmax);                                                                 \
+    if (cur_absmax > out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Loop unrolling: Compute remaining outputs */                                                           \
+  blkCnt = (blockSize - 1U) % 4U;                                                                           \
+                                                                                                            \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    cur_absmax = *pSrc++;                                                                                     \
+    cur_absmax = (cur_absmax > 0) ? cur_absmax : (q7_t)__QSUB8(0, cur_absmax);                                                                 \
+    if (cur_absmax > out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmax;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Store the extrema value and it's index into destination pointers */                                    \
+  *pResult = out;                                                                                           \
+}
+#else
+void arm_absmax_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult)
+{
+       q7_t maxVal, out;                              /* Temporary variables to store the output value. */
+        uint32_t blkCnt;                     /* Loop counter */
+
+
+
+  /* Load first input value that act as reference value for comparision */
+  out = (*pSrc > 0) ? *pSrc : ((*pSrc == (q7_t) 0x80) ? (q7_t) 0x7f : -*pSrc);
+  pSrc++;
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize maxVal to the next consecutive values one by one */
+    maxVal = (*pSrc > 0) ? *pSrc : ((*pSrc == (q7_t) 0x80) ? (q7_t) 0x7f : -*pSrc);
+    pSrc++;
+
+    /* compare for the maximum value */
+    if (out < maxVal)
+    {
+      /* Update the maximum value and it's index */
+      out = maxVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the maximum value and it's index into destination pointers */
+  *pResult = out;
+}
+#endif /* defined(ARM_MATH_DSP) */
+#endif /* defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of AbsMax group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_absmin_no_idx_f16.c

@@ -0,0 +1,230 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmin_no_idx_f16.c
+ * Description:  Minimum value of absolute values of a floating-point vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+
+#if (defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF)) && !defined(ARM_MATH_AUTOVECTORIZE)
+#include <limits.h>
+#endif
+
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup AbsMin
+  @{
+ */
+
+/**
+  @brief         Minimum value of absolute values 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
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+void arm_absmin_no_idx_f16(
+  const float16_t * pSrc,
+        uint32_t blockSize,
+        float16_t * pResult)
+{
+   int32_t  blkCnt;           /* loop counters */
+    f16x8_t vecSrc;
+    float16_t const *pSrcVec;
+    f16x8_t curExtremValVec = vdupq_n_f16(F16_ABSMAX);
+    float16_t minValue = F16_ABSMAX;
+    mve_pred16_t p0;
+
+
+    pSrcVec = (float16_t const *) pSrc;
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 8;
+        /*
+         * update per-lane min.
+         */
+        curExtremValVec = vminnmaq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 8;
+        p0 = vctp16q(blkCnt);
+        /*
+         * Get current min per lane and current index per lane
+         * when a min is selected
+         */
+         curExtremValVec = vminnmaq_m(curExtremValVec, vecSrc, p0);
+    }
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminnmavq(minValue, curExtremValVec);
+    *pResult = minValue;
+}
+
+#else
+#if defined(ARM_MATH_LOOPUNROLL)
+void arm_absmin_no_idx_f16(
+  const float16_t * pSrc,
+        uint32_t blockSize,
+        float16_t * pResult)
+{
+        float16_t cur_absmin, out;                     /* Temporary variables to store the output value. */\
+        uint32_t blkCnt;                     /* Loop counter */                                   \
+                                                                                                            \
+                                                                                          \
+  /* Load first input value that act as reference value for comparision */                                  \
+  out = *pSrc++;                                                                                            \
+  out = ((_Float16)out > 0.0f16) ? out : -(_Float16)out;                                                                             \
+                                                                                              \
+                                                                                                            \
+  /* Loop unrolling: Compute 4 outputs at a time */                                                         \
+  blkCnt = (blockSize - 1U) >> 2U;                                                                          \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    /* Initialize cur_absmin to next consecutive values one by one */                                         \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = ((_Float16)cur_absmin > 0.0f16) ? cur_absmin : -(_Float16)cur_absmin;                                                                 \
+    /* compare for the extrema value */                                                                     \
+    if ((_Float16)cur_absmin < (_Float16)out)                                                                         \
+    {                                                                                                       \
+      /* Update the extrema value and it's index */                                                         \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = ((_Float16)cur_absmin > 0.0f16) ? cur_absmin : -(_Float16)cur_absmin;                                                                 \
+    if ((_Float16)cur_absmin < (_Float16)out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = ((_Float16)cur_absmin > 0.0f16) ? cur_absmin : -(_Float16)cur_absmin;                                                                 \
+    if ((_Float16)cur_absmin < (_Float16)out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = ((_Float16)cur_absmin > 0.0f16) ? cur_absmin : -(_Float16)cur_absmin;                                                                 \
+    if ((_Float16)cur_absmin < (_Float16)out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Loop unrolling: Compute remaining outputs */                                                           \
+  blkCnt = (blockSize - 1U) % 4U;                                                                           \
+                                                                                                            \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = ((_Float16)cur_absmin > 0.0f16) ? cur_absmin : -(_Float16)cur_absmin;                                                                 \
+    if ((_Float16)cur_absmin < (_Float16)out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Store the extrema value and it's index into destination pointers */                                    \
+  *pResult = out;                                                                                           \
+}
+#else
+void arm_absmin_no_idx_f16(
+  const float16_t * pSrc,
+        uint32_t blockSize,
+        float16_t * pResult)
+{
+        float16_t minVal, out;                         /* Temporary variables to store the output value. */
+        uint32_t blkCnt;                     /* Loop counter */
+
+
+
+  /* Load first input value that act as reference value for comparision */
+  out = fabsf(*pSrc++);
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize minVal to the next consecutive values one by one */
+    minVal = (_Float16)fabsf((float32_t)*pSrc++);
+
+    /* compare for the minimum value */
+    if ((_Float16)out > (_Float16)minVal)
+    {
+      /* Update the minimum value and it's index */
+      out = minVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the minimum value and it's index into destination pointers */
+  *pResult = out;
+}
+#endif /* defined(ARM_MATH_LOOPUNROLL) */
+#endif /* defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of AbsMin group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */ 
+

CMSIS/DSP/Source/StatisticsFunctions/arm_absmin_no_idx_f32.c

@@ -0,0 +1,226 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmin_no_idx_f32.c
+ * Description:  Minimum value of absolute values of a floating-point vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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
+ */
+
+
+/**
+  @addtogroup AbsMin
+  @{
+ */
+
+/**
+  @brief         Minimum value of absolute values 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
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+void arm_absmin_no_idx_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    f32x4_t vecSrc;
+    float32_t const *pSrcVec;
+    f32x4_t curExtremValVec = vdupq_n_f32(F32_ABSMAX);
+    float32_t minValue = F32_ABSMAX;
+    mve_pred16_t p0;
+
+
+    pSrcVec = (float32_t const *) pSrc;
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0)
+    {
+        vecSrc = vldrwq_f32(pSrcVec);  
+        pSrcVec += 4;
+        /*
+         * update per-lane min.
+         */
+        curExtremValVec = vminnmaq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0)
+    {
+        vecSrc = vldrwq_f32(pSrcVec);  
+        pSrcVec += 4;
+        p0 = vctp32q(blkCnt);
+        /*
+         * Get current min per lane and current index per lane
+         * when a min is selected
+         */
+         curExtremValVec = vminnmaq_m(curExtremValVec, vecSrc, p0);
+    }
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminnmavq(minValue, curExtremValVec);
+    *pResult = minValue;
+}
+
+#else
+#if defined(ARM_MATH_LOOPUNROLL)
+void arm_absmin_no_idx_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult)
+{
+        float32_t cur_absmin, out;                     /* Temporary variables to store the output value. */\
+        uint32_t blkCnt;                     /* Loop counter */                                   \
+                                                                                                            \
+                                                                                           \
+  /* Load first input value that act as reference value for comparision */                                  \
+  out = *pSrc++;                                                                                            \
+  out = (out > 0.0f) ? out : -out;                                                                             \
+                                                                                              \
+                                                                                                            \
+  /* Loop unrolling: Compute 4 outputs at a time */                                                         \
+  blkCnt = (blockSize - 1U) >> 2U;                                                                          \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    /* Initialize cur_absmin to next consecutive values one by one */                                         \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0.0f) ? cur_absmin : -cur_absmin;                                                                 \
+    /* compare for the extrema value */                                                                     \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      /* Update the extrema value and it's index */                                                         \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0.0f) ? cur_absmin : -cur_absmin;                                                                 \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0.0f) ? cur_absmin : -cur_absmin;                                                                 \
+    if (cur_absmin < out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0.0f) ? cur_absmin : -cur_absmin;                                                                 \
+    if (cur_absmin < out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Loop unrolling: Compute remaining outputs */                                                           \
+  blkCnt = (blockSize - 1U) % 4U;                                                                           \
+                                                                                                            \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0.0f) ? cur_absmin : -cur_absmin;                                                                 \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Store the extrema value and it's index into destination pointers */                                    \
+  *pResult = out;                                                                                           \
+}
+#else
+void arm_absmin_no_idx_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult)
+{
+       float32_t minVal, out;                         /* Temporary variables to store the output value. */
+       uint32_t blkCnt;                     /* Loop counter */
+
+
+
+  /* Load first input value that act as reference value for comparision */
+  out = fabsf(*pSrc++);
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize minVal to the next consecutive values one by one */
+    minVal = fabsf(*pSrc++);
+
+    /* compare for the minimum value */
+    if (out > minVal)
+    {
+      /* Update the minimum value and it's index */
+      out = minVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the minimum value and it's index into destination pointers */
+  *pResult = out;
+}
+
+#endif /* defined(ARM_MATH_LOOPUNROLL) */
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of AbsMin group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_absmin_no_idx_f64.c

@@ -0,0 +1,84 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmin_no_idx_f64.c
+ * Description:  Minimum value of absolute values of a floating-point vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup AbsMin
+  @{
+ */
+
+/**
+  @brief         Minimum value of absolute values 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
+  @return        none
+ */
+void arm_absmin_no_idx_f64(
+  const float64_t * pSrc,
+        uint32_t blockSize,
+        float64_t * pResult)
+{
+       float64_t minVal, out;                         /* Temporary variables to store the output value. */
+       uint32_t blkCnt;                     /* Loop counter */
+
+
+  /* Load first input value that act as reference value for comparision */
+  out = fabs(*pSrc++);
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize minVal to the next consecutive values one by one */
+    minVal = fabs(*pSrc++);
+
+    /* compare for the minimum value */
+    if (out > minVal)
+    {
+      /* Update the minimum value and it's index */
+      out = minVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the minimum value and it's index into destination pointers */
+  *pResult = out;
+}
+
+/**
+  @} end of AbsMin group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_absmin_no_idx_q15.c

@@ -0,0 +1,222 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmin_no_idx_q15.c
+ * Description:  Minimum value of absolute values of a Q15 vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+/**
+  @ingroup groupStats
+ */
+
+
+/**
+  @addtogroup AbsMin
+  @{
+ */
+
+/**
+  @brief         Minimum value of absolute values of a Q15 vector.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    minimum value returned here
+  @return        none
+ */
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_absmin_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+    uint16_t        blkCnt;           /* loop counters */
+    q15x8_t       vecSrc;
+    q15_t   const *pSrcVec;
+    uint16x8_t    curExtremValVec = vdupq_n_s16(Q15_ABSMAX);
+    q15_t           minValue = Q15_ABSMAX;
+    mve_pred16_t    p0;
+
+
+    pSrcVec = (q15_t const *) pSrc;
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 8;
+        /*
+         * update per-lane min.
+         */
+        curExtremValVec = vminaq(curExtremValVec, vecSrc);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 8;
+        p0 = vctp16q(blkCnt);
+        /*
+         * Get current min per lane and current index per lane
+         * when a min is selected
+         */
+         curExtremValVec = vminaq_m(curExtremValVec, vecSrc, p0);
+    }
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminavq(minValue, (q15x8_t)curExtremValVec);
+    *pResult = minValue;
+}
+
+#else
+#if defined(ARM_MATH_DSP)
+void arm_absmin_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+        q15_t cur_absmin, out;                     /* Temporary variables to store the output value. */\
+        uint32_t blkCnt;                     /* Loop counter */                                   \
+                                                                                                            \
+                                                                                           \
+  /* Load first input value that act as reference value for comparision */                                  \
+  out = *pSrc++;                                                                                            \
+  out = (out > 0) ? out : (q15_t)__QSUB16(0, out);                                                                           \
+                                                                                             \
+                                                                                                            \
+  /* Loop unrolling: Compute 4 outputs at a time */                                                         \
+  blkCnt = (blockSize - 1U) >> 2U;                                                                          \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    /* Initialize cur_absmin to next consecutive values one by one */                                         \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q15_t)__QSUB16(0, cur_absmin);                                                                \
+    /* compare for the extrema value */                                                                     \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      /* Update the extrema value and it's index */                                                         \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q15_t)__QSUB16(0, cur_absmin);                                                                \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q15_t)__QSUB16(0, cur_absmin);                                                                \
+    if (cur_absmin < out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q15_t)__QSUB16(0, cur_absmin);                                                                 \
+    if (cur_absmin < out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Loop unrolling: Compute remaining outputs */                                                           \
+  blkCnt = (blockSize - 1U) % 4U;                                                                           \
+                                                                                                            \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q15_t)__QSUB16(0, cur_absmin);                                                                 \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Store the extrema value and it's index into destination pointers */                                    \
+  *pResult = out;                                                                                           \
+}
+#else
+void arm_absmin_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+       q15_t minVal, out;                             /* Temporary variables to store the output value. */
+        uint32_t blkCnt;                     /* Loop counter */
+
+
+
+  /* Load first input value that act as reference value for comparision */
+  out = (*pSrc > 0) ? *pSrc : ((*pSrc == (q15_t) 0x8000) ? 0x7fff : -*pSrc);
+  pSrc++;
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize minVal to the next consecutive values one by one */
+    minVal = (*pSrc > 0) ? *pSrc : ((*pSrc == (q15_t) 0x8000) ? 0x7fff : -*pSrc);
+    pSrc++;
+
+    /* compare for the minimum value */
+    if (out > minVal)
+    {
+      /* Update the minimum value and it's index */
+      out = minVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the minimum value and it's index into destination pointers */
+  *pResult = out;
+}
+#endif /* defined(ARM_MATH_DSP) */
+#endif /* defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of AbsMin group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_absmin_no_idx_q31.c

@@ -0,0 +1,221 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmin_no_idx_q31.c
+ * Description:  Minimum value of absolute values of a Q31 vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+/**
+  @ingroup groupStats
+ */
+
+
+/**
+  @addtogroup AbsMin
+  @{
+ */
+
+/**
+  @brief         Minimum value of absolute values of a Q31 vector.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    minimum value returned here
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_absmin_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q31x4_t       vecSrc;
+    q31_t   const *pSrcVec;
+    uint32x4_t    curExtremValVec = vdupq_n_s32(Q31_ABSMAX);
+    q31_t           minValue = Q31_ABSMAX;
+    mve_pred16_t    p0;
+
+
+    pSrcVec = (q31_t const *) pSrc;
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0)
+    {
+        vecSrc = vldrwq_s32(pSrcVec);  
+        pSrcVec += 4;
+        /*
+         * update per-lane min.
+         */
+        curExtremValVec = vminaq(curExtremValVec, vecSrc);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0)
+    {
+        vecSrc = vldrwq_s32(pSrcVec);  
+        pSrcVec += 4;
+        p0 = vctp32q(blkCnt);
+        /*
+         * Get current min per lane and current index per lane
+         * when a min is selected
+         */
+         curExtremValVec = vminaq_m(curExtremValVec, vecSrc, p0);
+    }
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminavq(minValue, (q31x4_t)curExtremValVec);
+    *pResult = minValue;
+}
+
+#else
+#if defined(ARM_MATH_DSP)
+void arm_absmin_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+        q31_t cur_absmin, out;                     /* Temporary variables to store the output value. */\
+        uint32_t blkCnt;                     /* Loop counter */                                   \
+                                                                                                            \
+                                                                                           \
+  /* Load first input value that act as reference value for comparision */                                  \
+  out = *pSrc++;                                                                                            \
+  out = (out > 0) ? out : (q31_t)__QSUB(0, out);                                                                           \
+                                                                                              \
+                                                                                                            \
+  /* Loop unrolling: Compute 4 outputs at a time */                                                         \
+  blkCnt = (blockSize - 1U) >> 2U;                                                                          \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    /* Initialize cur_absmin to next consecutive values one by one */                                         \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q31_t)__QSUB(0, cur_absmin);                                                                \
+    /* compare for the extrema value */                                                                     \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      /* Update the extrema value and it's index */                                                         \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q31_t)__QSUB(0, cur_absmin);                                                                \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q31_t)__QSUB(0, cur_absmin);                                                                \
+    if (cur_absmin < out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q31_t)__QSUB(0, cur_absmin);                                                                 \
+    if (cur_absmin < out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Loop unrolling: Compute remaining outputs */                                                           \
+  blkCnt = (blockSize - 1U) % 4U;                                                                           \
+                                                                                                            \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q31_t)__QSUB(0, cur_absmin);                                                                 \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Store the extrema value and it's index into destination pointers */                                    \
+  *pResult = out;                                                                                           \
+}
+#else
+void arm_absmin_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+        q31_t minVal, out;                             /* Temporary variables to store the output value. */
+        uint32_t blkCnt;                     /* Loop counter */
+
+  /* Load first input value that act as reference value for comparision */
+  out = (*pSrc > 0) ? *pSrc : ((*pSrc == INT32_MIN) ? INT32_MAX : -*pSrc);
+  pSrc++;
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize minVal to the next consecutive values one by one */
+    minVal = (*pSrc > 0) ? *pSrc : ((*pSrc == INT32_MIN) ? INT32_MAX : -*pSrc);
+    pSrc++;
+
+    /* compare for the minimum value */
+    if (out > minVal)
+    {
+      /* Update the minimum value and it's index */
+      out = minVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the minimum value and it's index into destination pointers */
+  *pResult = out;
+}
+#endif /* defined(ARM_MATH_DSP) */
+#endif /* defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of AbsMin group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_absmin_no_idx_q7.c

@@ -0,0 +1,223 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_absmin_no_idx_q7.c
+ * Description:  Minimum value of absolute values of a Q7 vector
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+/**
+  @ingroup groupStats
+ */
+
+
+/**
+  @addtogroup AbsMin
+  @{
+ */
+
+/**
+  @brief         Minimum value of absolute values of a Q7 vector.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    minimum value returned here
+  @return        none
+ */
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include <stdint.h>
+#include "arm_helium_utils.h"
+
+
+
+void arm_absmin_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q7x16_t        vecSrc;
+    q7_t   const *pSrcVec;
+    uint8x16_t     curExtremValVec = vdupq_n_s8(Q7_ABSMAX);
+    q7_t            minValue = Q7_ABSMAX;
+    mve_pred16_t    p0;
+
+
+    pSrcVec = (q7_t const *) pSrc;
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 16;
+        /*
+         * update per-lane min.
+         */
+        curExtremValVec = vminaq(curExtremValVec, vecSrc);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 16;
+        p0 = vctp8q(blkCnt);
+        /*
+         * Get current min per lane and current index per lane
+         * when a min is selected
+         */
+         curExtremValVec = vminaq_m(curExtremValVec, vecSrc, p0);
+    }
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminavq(minValue, (q7x16_t)curExtremValVec);
+    *pResult = minValue;
+}
+
+#else
+#if defined(ARM_MATH_DSP)
+void arm_absmin_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult)
+{
+        q7_t cur_absmin, out;                     /* Temporary variables to store the output value. */\
+        uint32_t blkCnt;                     /* Loop counter */                                   \
+                                                                                                            \
+                                                                                           \
+  /* Load first input value that act as reference value for comparision */                                  \
+  out = *pSrc++;                                                                                            \
+  out = (out > 0) ? out : (q7_t)__QSUB8(0, out);                                                                           \
+                                                                                                            \
+  /* Loop unrolling: Compute 4 outputs at a time */                                                         \
+  blkCnt = (blockSize - 1U) >> 2U;                                                                          \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    /* Initialize cur_absmin to next consecutive values one by one */                                         \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q7_t)__QSUB8(0, cur_absmin);                                                                \
+    /* compare for the extrema value */                                                                     \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      /* Update the extrema value and it's index */                                                         \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q7_t)__QSUB8(0, cur_absmin);                                                                \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q7_t)__QSUB8(0, cur_absmin);                                                                \
+    if (cur_absmin < out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q7_t)__QSUB8(0, cur_absmin);                                                                 \
+    if (cur_absmin < out)                                                                          \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Loop unrolling: Compute remaining outputs */                                                           \
+  blkCnt = (blockSize - 1U) % 4U;                                                                           \
+                                                                                                            \
+                                                                                                            \
+  while (blkCnt > 0U)                                                                                       \
+  {                                                                                                         \
+    cur_absmin = *pSrc++;                                                                                     \
+    cur_absmin = (cur_absmin > 0) ? cur_absmin : (q7_t)__QSUB8(0, cur_absmin);                                                                 \
+    if (cur_absmin < out)                                                                         \
+    {                                                                                                       \
+      out = cur_absmin;                                                                                       \
+    }                                                                                                       \
+                                                                                                            \
+    /* Decrement loop counter */                                                                            \
+    blkCnt--;                                                                                               \
+  }                                                                                                         \
+                                                                                                            \
+  /* Store the extrema value and it's index into destination pointers */                                    \
+  *pResult = out;                                                                                           \
+}
+#else
+void arm_absmin_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult)
+{
+        q7_t minVal, out;                              /* Temporary variables to store the output value. */
+        uint32_t blkCnt;                     /* Loop counter */
+
+
+  /* Load first input value that act as reference value for comparision */
+  out = (*pSrc > 0) ? *pSrc : ((*pSrc == (q7_t) 0x80) ? (q7_t) 0x7f : -*pSrc);
+  pSrc++;
+
+  /* Initialize blkCnt with number of samples */
+  blkCnt = (blockSize - 1U);
+
+  while (blkCnt > 0U)
+  {
+    /* Initialize minVal to the next consecutive values one by one */
+    minVal = (*pSrc > 0) ? *pSrc : ((*pSrc == (q7_t) 0x80) ? (q7_t) 0x7f : -*pSrc);
+    pSrc++;
+
+    /* compare for the minimum value */
+    if (out > minVal)
+    {
+      /* Update the minimum value and it's index */
+      out = minVal;
+    }
+
+    /* Decrement loop counter */
+    blkCnt--;
+  }
+
+  /* Store the minimum value and it's index into destination pointers */
+  *pResult = out;
+}
+#endif /* defined(ARM_MATH_DSP) */
+#endif /* defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of AbsMin group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_max_no_idx_q15.c

@@ -0,0 +1,142 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_max_no_idx_q15.c
+ * Description:  Maximum value of a q15 vector without returning the index
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup Max
+  @{
+ */
+
+/**
+  @brief         Maximum value of a q15 vector without index.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    maximum value returned here
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_max_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q15x8_t       vecSrc;
+    q15_t const *pSrcVec;
+    q15x8_t       curExtremValVec = vdupq_n_s16(Q15_MIN);
+    q15_t           maxValue = Q15_MIN;
+    mve_pred16_t    p0;
+
+
+    pSrcVec = (q15_t const *) pSrc;
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 8;
+        /*
+         * update per-lane max.
+         */
+        curExtremValVec = vmaxq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 8;
+        p0 = vctp16q(blkCnt);
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+         curExtremValVec = vmaxq_m(curExtremValVec, vecSrc, curExtremValVec, p0);
+    }
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxvq(maxValue, curExtremValVec);
+    *pResult = maxValue;
+}
+
+#else
+void arm_max_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+  q15_t maxVal1, out;       /* Temporary variables to store the output value. */     
+  uint32_t blkCnt;              /* loop counter */                                 
+                                                                                   
+  /* Load first input value that act as reference value for comparision */         
+  out = *pSrc++;                                                                   
+                                                                                   
+  blkCnt = (blockSize - 1U);                                                       
+                                                                                   
+                                                                                   
+  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 */                                               
+      out = maxVal1;                                                               
+    }                                                                              
+                                                                                   
+    /* Decrement the loop counter */                                               
+    blkCnt--;                                                                      
+  }                                                                                
+                                                                                   
+  /* Store the maximum value into destination pointer */                           
+  *pResult = out;
+}
+
+#endif /* #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of Max group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_max_no_idx_q31.c

@@ -0,0 +1,142 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_max_no_idx_q31.c
+ * Description:  Maximum value of a q31 vector without returning the index
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup Max
+  @{
+ */
+
+/**
+  @brief         Maximum value of a q31 vector without index.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    maximum value returned here
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_max_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q31x4_t       vecSrc;
+    q31_t const *pSrcVec;
+    q31x4_t       curExtremValVec = vdupq_n_s32(Q31_MIN);
+    q31_t           maxValue = Q31_MIN;
+    mve_pred16_t    p0;
+
+
+    pSrcVec = (q31_t const *) pSrc;
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0)
+    {
+        vecSrc = vldrwq_s32(pSrcVec);  
+        pSrcVec += 4;
+        /*
+         * update per-lane max.
+         */
+        curExtremValVec = vmaxq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0)
+    {
+        vecSrc = vldrwq_s32(pSrcVec);  
+        pSrcVec += 4;
+        p0 = vctp32q(blkCnt);
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+         curExtremValVec = vmaxq_m(curExtremValVec, vecSrc, curExtremValVec, p0);
+    }
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxvq(maxValue, curExtremValVec);
+    *pResult = maxValue;
+}
+
+#else
+void arm_max_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+  q31_t maxVal1, out;       /* Temporary variables to store the output value. */    
+  uint32_t blkCnt;              /* loop counter */                                  
+                                                                                    
+  /* Load first input value that act as reference value for comparision */          
+  out = *pSrc++;                                                                    
+                                                                                    
+  blkCnt = (blockSize - 1U);                                                        
+                                                                                    
+                                                                                    
+  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 */                                                
+      out = maxVal1;                                                                
+    }                                                                               
+                                                                                    
+    /* Decrement the loop counter */                                                
+    blkCnt--;                                                                       
+  }                                                                                 
+                                                                                    
+  /* Store the maximum value into destination pointer */                            
+  *pResult = out;
+}
+
+#endif /* #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of Max group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_max_no_idx_q7.c

@@ -0,0 +1,143 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_max_no_idx_q7.c
+ * Description:  Maximum value of a q7 vector without returning the index
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup Max
+  @{
+ */
+
+/**
+  @brief         Maximum value of a q7 vector without index.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    maximum value returned here
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_max_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q7x16_t       vecSrc;
+    q7_t const *pSrcVec;
+    q7x16_t       curExtremValVec = vdupq_n_s8(Q7_MIN);
+    q7_t           maxValue = Q7_MIN;
+    mve_pred16_t    p0;
+
+
+    pSrcVec = (q7_t const *) pSrc;
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 16;
+        /*
+         * update per-lane max.
+         */
+        curExtremValVec = vmaxq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 16;
+        p0 = vctp8q(blkCnt);
+        /*
+         * Get current max per lane and current index per lane
+         * when a max is selected
+         */
+         curExtremValVec = vmaxq_m(curExtremValVec, vecSrc, curExtremValVec, p0);
+    }
+    /*
+     * Get max value across the vector
+     */
+    maxValue = vmaxvq(maxValue, curExtremValVec);
+    *pResult = maxValue;
+}
+
+#else
+
+void arm_max_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult)
+{
+  q7_t maxVal1, out;       /* Temporary variables to store the output value. */     
+  uint32_t blkCnt;              /* loop counter */                                  
+                                                                                    
+  /* Load first input value that act as reference value for comparision */          
+  out = *pSrc++;                                                                    
+                                                                                    
+  blkCnt = (blockSize - 1U);                                                        
+                                                                                    
+                                                                                    
+  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 */                                                
+      out = maxVal1;                                                                
+    }                                                                               
+                                                                                    
+    /* Decrement the loop counter */                                                
+    blkCnt--;                                                                       
+  }                                                                                 
+                                                                                    
+  /* Store the maximum value into destination pointer */                            
+  *pResult = out;
+}
+
+#endif /* #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of Max group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_min_no_idx_f16.c

@@ -0,0 +1,144 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_min_no_idx_f16.c
+ * Description:  Minimum value of a floating-point vector without returning the index
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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_f16.h"
+
+#if defined(ARM_FLOAT16_SUPPORTED)
+
+#if (defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF)) && !defined(ARM_MATH_AUTOVECTORIZE)
+#include <limits.h>
+#endif
+
+/**
+  @ingroup groupStats
+ */
+
+
+/**
+  @addtogroup Min
+  @{
+ */
+
+/**
+  @brief         Minimum value of a floating-point vector.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    minimum value returned here
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+void arm_min_no_idx_f16(
+    const float16_t *pSrc,
+    uint32_t   blockSize,
+    float16_t *pResult)
+{
+   f16x8_t     vecSrc;
+   f16x8_t     curExtremValVec = vdupq_n_f16(F16_MAX);
+   float16_t   minValue = F16_MAX;
+   float16_t   newVal;
+   uint32_t    blkCnt;
+
+   /* Loop unrolling: Compute 4 outputs at a time */
+   blkCnt = blockSize >> 3U;
+
+   while (blkCnt > 0U)
+   {
+
+        vecSrc = vldrhq_f16(pSrc);
+        /*
+         * update per-lane min.
+         */
+        curExtremValVec = vminnmq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         * Advance vector source and destination pointers
+         */
+        pSrc += 8;
+        blkCnt --;
+    }
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminnmvq(minValue, curExtremValVec);
+
+    blkCnt = blockSize & 7;
+
+    while (blkCnt > 0U)
+    {
+        newVal = *pSrc++;
+
+        /* compare for the minimum value */
+        if ((_Float16)minValue > (_Float16)newVal)
+        {
+            /* Update the minimum value and it's index */
+            minValue = newVal;
+        }
+
+        blkCnt --;
+    }
+
+    *pResult = minValue;
+}
+
+#else
+
+void arm_min_no_idx_f16(
+    const float16_t *pSrc,
+    uint32_t   blockSize,
+    float16_t *pResult)
+{
+   float16_t   minValue = F16_MAX;
+   float16_t   newVal;
+
+   while (blockSize > 0U)
+   {
+       newVal = *pSrc++;
+   
+       /* compare for the minimum value */
+       if ((_Float16)minValue > (_Float16)newVal)
+       {
+           /* Update the minimum value and it's index */
+           minValue = newVal;
+       }
+   
+       blockSize --;
+   }
+    
+   *pResult = minValue;
+}
+
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+  @} end of Min group
+ */
+
+#endif /* #if defined(ARM_FLOAT16_SUPPORTED) */ 
+

CMSIS/DSP/Source/StatisticsFunctions/arm_min_no_idx_f32.c

@@ -0,0 +1,138 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_min_no_idx_f32.c
+ * Description:  Minimum value of a floating-point vector without returning the index
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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
+ */
+
+
+/**
+  @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
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+void arm_min_no_idx_f32(
+    const float32_t *pSrc,
+    uint32_t   blockSize,
+    float32_t *pResult)
+{
+   f32x4_t     vecSrc;
+   f32x4_t     curExtremValVec = vdupq_n_f32(F32_MAX);
+   float32_t   minValue = F32_MAX;
+   float32_t   newVal;
+   uint32_t    blkCnt;
+
+   /* Loop unrolling: Compute 4 outputs at a time */
+   blkCnt = blockSize >> 2U;
+
+   while (blkCnt > 0U)
+   {
+
+        vecSrc = vldrwq_f32(pSrc);
+        /*
+         * update per-lane min.
+         */
+        curExtremValVec = vminnmq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         * Advance vector source and destination pointers
+         */
+        pSrc += 4;
+        blkCnt --;
+    }
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminnmvq(minValue, curExtremValVec);
+
+    blkCnt = blockSize & 3;
+
+    while (blkCnt > 0U)
+    {
+        newVal = *pSrc++;
+
+        /* compare for the minimum value */
+        if (minValue > newVal)
+        {
+            /* Update the minimum value and it's index */
+            minValue = newVal;
+        }
+
+        blkCnt --;
+    }
+
+    *pResult = minValue;
+}
+
+#else
+
+void arm_min_no_idx_f32(
+    const float32_t *pSrc,
+    uint32_t   blockSize,
+    float32_t *pResult)
+{
+   float32_t   minValue = F32_MAX;
+   float32_t   newVal;
+
+   while (blockSize > 0U)
+   {
+       newVal = *pSrc++;
+   
+       /* compare for the minimum value */
+       if (minValue > newVal)
+       {
+           /* Update the minimum value and it's index */
+           minValue = newVal;
+       }
+   
+       blockSize --;
+   }
+    
+   *pResult = minValue;
+}
+
+#endif /* defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE) */
+
+/**
+  @} end of Min group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_min_no_idx_f64.c

@@ -0,0 +1,75 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_min_no_idx_f64.c
+ * Description:  Maximum value of a floating-point vector without returning the index
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+/**
+  @ingroup groupStats
+ */
+
+
+/**
+  @addtogroup Min
+  @{
+ */
+
+/**
+  @brief         Maximum value of a floating-point vector.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    minimum value returned here
+  @return        none
+ */
+void arm_min_no_idx_f64(
+    const float64_t *pSrc,
+    uint32_t   blockSize,
+    float64_t *pResult)
+{
+   float64_t   minValue = F64_MAX;
+   float64_t   newVal;
+
+   while (blockSize > 0U)
+   {
+       newVal = *pSrc++;
+   
+       /* compare for the minimum value */
+       if (minValue > newVal)
+       {
+           /* Update the minimum value and it's index */
+           minValue = newVal;
+       }
+   
+       blockSize --;
+   }
+    
+   *pResult = minValue;
+}
+
+/**
+  @} end of Min group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_min_no_idx_q15.c

@@ -0,0 +1,142 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_min_no_idx_q15.c
+ * Description:  Minimum value of a q15 vector without returning the index
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup Min
+  @{
+ */
+
+/**
+  @brief         Minimum value of a q15 vector without index.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    minimum value returned here
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_min_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q15x8_t vecSrc;
+    q15_t const *pSrcVec;
+    q15x8_t curExtremValVec = vdupq_n_s16(Q15_MAX);
+    q15_t minValue = Q15_MAX;
+    mve_pred16_t p0;
+
+
+    pSrcVec = (q15_t const *) pSrc;
+    blkCnt = blockSize >> 3;
+    while (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 8;
+        /*
+         * update per-lane min.
+         */
+        curExtremValVec = vminq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 7;
+    if (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 8;
+        p0 = vctp16q(blkCnt);
+        /*
+         * Get current min per lane and current index per lane
+         * when a min is selected
+         */
+         curExtremValVec = vminq_m(curExtremValVec, vecSrc, curExtremValVec, p0);
+    }
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminvq(minValue, curExtremValVec);
+    *pResult = minValue;
+}
+
+#else
+void arm_min_no_idx_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult)
+{
+  q15_t minVal1, out;       /* Temporary variables to store the output value. */    
+  uint32_t blkCnt;              /* loop counter */                                  
+                                                                                    
+  /* Load first input value that act as reference value for comparision */          
+  out = *pSrc++;                                                                    
+                                                                                    
+  blkCnt = (blockSize - 1U);                                                        
+                                                                                    
+                                                                                    
+  while (blkCnt > 0U)                                                               
+  {                                                                                 
+    /* Initialize minVal to the next consecutive values one by one */               
+    minVal1 = *pSrc++;                                                              
+                                                                                    
+    /* compare for the minimum value */                                             
+    if (out > minVal1)                                                              
+    {                                                                               
+      /* Update the minimum value */                                                
+      out = minVal1;                                                                
+    }                                                                               
+                                                                                    
+    /* Decrement the loop counter */                                                
+    blkCnt--;                                                                       
+  }                                                                                 
+                                                                                    
+  /* Store the minimum value into destination pointer */                            
+  *pResult = out;
+}
+
+#endif /* #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of Min group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_min_no_idx_q31.c

@@ -0,0 +1,141 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_min_no_idx_q31.c
+ * Description:  Minimum value of a q31 vector without returning the index
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup Min
+  @{
+ */
+
+/**
+  @brief         Minimum value of a q31 vector without index.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    minimum value returned here
+  @return        none
+ */
+
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+void arm_min_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q31x4_t vecSrc;
+    q31_t const *pSrcVec;
+    q31x4_t curExtremValVec = vdupq_n_s32(Q31_MAX);
+    q31_t minValue = Q31_MAX;
+    mve_pred16_t p0;
+
+
+    pSrcVec = (q31_t const *) pSrc;
+    blkCnt = blockSize >> 2;
+    while (blkCnt > 0)
+    {
+        vecSrc = vldrwq_s32(pSrcVec);  
+        pSrcVec += 4;
+        /*
+         * update per-lane min.
+         */
+        curExtremValVec = vminq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 3;
+    if (blkCnt > 0)
+    {
+        vecSrc = vldrwq_s32(pSrcVec);  
+        pSrcVec += 4;
+        p0 = vctp32q(blkCnt);
+        /*
+         * Get current min per lane and current index per lane
+         * when a min is selected
+         */
+         curExtremValVec = vminq_m(curExtremValVec, vecSrc, curExtremValVec, p0);
+    }
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminvq(minValue, curExtremValVec);
+    *pResult = minValue;
+}
+
+#else
+void arm_min_no_idx_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult)
+{
+  q31_t minVal1, out;       /* Temporary variables to store the output value. */    
+  uint32_t blkCnt;              /* loop counter */                                  
+                                                                                    
+  /* Load first input value that act as reference value for comparision */          
+  out = *pSrc++;                                                                    
+                                                                                    
+  blkCnt = (blockSize - 1U);                                                        
+                                                                                    
+                                                                                    
+  while (blkCnt > 0U)                                                               
+  {                                                                                 
+    /* Initialize minVal to the next consecutive values one by one */               
+    minVal1 = *pSrc++;                                                              
+                                                                                    
+    /* compare for the minimum value */                                             
+    if (out > minVal1)                                                              
+    {                                                                               
+      /* Update the minimum value */                                                
+      out = minVal1;                                                                
+    }                                                                               
+                                                                                    
+    /* Decrement the loop counter */                                                
+    blkCnt--;                                                                       
+  }                                                                                 
+                                                                                    
+  /* Store the minimum value into destination pointer */                            
+  *pResult = out;
+}
+
+#endif /* #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of Min group
+ */

CMSIS/DSP/Source/StatisticsFunctions/arm_min_no_idx_q7.c

@@ -0,0 +1,141 @@
+/* ----------------------------------------------------------------------
+ * Project:      CMSIS DSP Library
+ * Title:        arm_min_no_idx_q7.c
+ * Description:  Minimum value of a q7 vector without returning the index
+ *
+ * $Date:        16 November 2021
+ * $Revision:    V1.10.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"
+
+
+/**
+  @ingroup groupStats
+ */
+
+/**
+  @addtogroup Min
+  @{
+ */
+
+/**
+  @brief         Minimum value of a q7 vector without index.
+  @param[in]     pSrc       points to the input vector
+  @param[in]     blockSize  number of samples in input vector
+  @param[out]    pResult    minimum value returned here
+  @return        none
+ */
+#if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
+
+#include "arm_helium_utils.h"
+
+void arm_min_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult)
+{
+    int32_t  blkCnt;           /* loop counters */
+    q7x16_t vecSrc;
+    q7_t const *pSrcVec;
+    q7x16_t curExtremValVec = vdupq_n_s8(Q7_MAX);
+    q7_t minValue = Q7_MAX;
+    mve_pred16_t p0;
+
+
+    pSrcVec = (q7_t const *) pSrc;
+    blkCnt = blockSize >> 4;
+    while (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 16;
+        /*
+         * update per-lane min.
+         */
+        curExtremValVec = vminq(vecSrc, curExtremValVec);
+        /*
+         * Decrement the blockSize loop counter
+         */
+        blkCnt--;
+    }
+    /*
+     * tail
+     * (will be merged thru tail predication)
+     */
+    blkCnt = blockSize & 0xF;
+    if (blkCnt > 0)
+    {
+        vecSrc = vld1q(pSrcVec); 
+        pSrcVec += 16;
+        p0 = vctp8q(blkCnt);
+        /*
+         * Get current min per lane and current index per lane
+         * when a min is selected
+         */
+         curExtremValVec = vminq_m(curExtremValVec, vecSrc, curExtremValVec, p0);
+    }
+    /*
+     * Get min value across the vector
+     */
+    minValue = vminvq(minValue, curExtremValVec);
+    *pResult = minValue;
+}
+
+#else
+void arm_min_no_idx_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult)
+{
+  q7_t minVal1, out;       /* Temporary variables to store the output value. */    
+  uint32_t blkCnt;              /* loop counter */                                  
+                                                                                    
+  /* Load first input value that act as reference value for comparision */          
+  out = *pSrc++;                                                                    
+                                                                                    
+  blkCnt = (blockSize - 1U);                                                        
+                                                                                    
+                                                                                    
+  while (blkCnt > 0U)                                                               
+  {                                                                                 
+    /* Initialize minVal to the next consecutive values one by one */               
+    minVal1 = *pSrc++;                                                              
+                                                                                    
+    /* compare for the minimum value */                                             
+    if (out > minVal1)                                                              
+    {                                                                               
+      /* Update the minimum value */                                                
+      out = minVal1;                                                                
+    }                                                                               
+                                                                                    
+    /* Decrement the loop counter */                                                
+    blkCnt--;                                                                       
+  }                                                                                 
+                                                                                    
+  /* Store the minimum value into destination pointer */                            
+  *pResult = out;
+}
+
+#endif /* #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
+/**
+  @} end of Min group
+ */

CMSIS/DSP/Testing/Source/Tests/StatsTestsF16.cpp

@@ -90,6 +90,66 @@ a double precision computation.
 
     }
 
+    void StatsTestsF16::test_absmax_no_idx_f16()
+    {
+        const float16_t *inp  = inputA.ptr();
+
+        float16_t result;
+
+        float16_t *refp  = ref.ptr();
+
+        float16_t *outp  = output.ptr();
+
+        arm_absmax_no_idx_f16(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsF16::test_min_no_idx_f16()
+    {
+        const float16_t *inp  = inputA.ptr();
+
+        float16_t result;
+
+        float16_t *refp  = ref.ptr();
+
+        float16_t *outp  = output.ptr();
+
+        arm_min_no_idx_f16(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsF16::test_absmin_no_idx_f16()
+    {
+        const float16_t *inp  = inputA.ptr();
+
+        float16_t result;
+
+        float16_t *refp  = ref.ptr();
+
+        float16_t *outp  = output.ptr();
+
+        arm_absmin_no_idx_f16(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
 
     void StatsTestsF16::test_min_f16()
     {
@@ -864,6 +924,114 @@ a double precision computation.
                refOffset = 2;
             }
             break;
+
+            case StatsTestsF16::TEST_MIN_NO_IDX_F16_40:
+            {
+               inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,7);
+              
+               ref.reload(StatsTestsF16::MINVALS_F16_ID,mgr);
+               
+               output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF16::TEST_MIN_NO_IDX_F16_41:
+            {
+               inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,16);
+              
+               ref.reload(StatsTestsF16::MINVALS_F16_ID,mgr);
+               
+               output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF16::TEST_MIN_NO_IDX_F16_42:
+            {
+               inputA.reload(StatsTestsF16::INPUT1_F16_ID,mgr,23);
+              
+               ref.reload(StatsTestsF16::MINVALS_F16_ID,mgr);
+               
+               output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF16::TEST_ABSMAX_NO_IDX_F16_43:
+            {
+               inputA.reload(StatsTestsF16::INPUTNEW1_F16_ID,mgr,7);
+              
+               ref.reload(StatsTestsF16::ABSMAXVALS_F16_ID,mgr);
+               
+               output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF16::TEST_ABSMAX_NO_IDX_F16_44:
+            {
+               inputA.reload(StatsTestsF16::INPUTNEW1_F16_ID,mgr,16);
+              
+               ref.reload(StatsTestsF16::ABSMAXVALS_F16_ID,mgr);
+               
+               output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF16::TEST_ABSMAX_NO_IDX_F16_45:
+            {
+               inputA.reload(StatsTestsF16::INPUTNEW1_F16_ID,mgr,23);
+              
+               ref.reload(StatsTestsF16::ABSMAXVALS_F16_ID,mgr);
+               
+               output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF16::TEST_ABSMIN_NO_IDX_F16_46:
+            {
+               inputA.reload(StatsTestsF16::INPUTNEW1_F16_ID,mgr,7);
+              
+               ref.reload(StatsTestsF16::ABSMINVALS_F16_ID,mgr);
+               
+               output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF16::TEST_ABSMIN_NO_IDX_F16_47:
+            {
+               inputA.reload(StatsTestsF16::INPUTNEW1_F16_ID,mgr,16);
+              
+               ref.reload(StatsTestsF16::ABSMINVALS_F16_ID,mgr);
+               
+               output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF16::TEST_ABSMIN_NO_IDX_F16_48:
+            {
+               inputA.reload(StatsTestsF16::INPUTNEW1_F16_ID,mgr,23);
+              
+               ref.reload(StatsTestsF16::ABSMINVALS_F16_ID,mgr);
+               
+               output.create(1,StatsTestsF16::OUT_F16_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
         }
         
     }

CMSIS/DSP/Testing/Source/Tests/StatsTestsF32.cpp

@@ -85,6 +85,66 @@ a double precision computation.
 
     }
 
+    void StatsTestsF32::test_absmax_no_idx_f32()
+    {
+        const float32_t *inp  = inputA.ptr();
+
+        float32_t result;
+
+        float32_t *refp  = ref.ptr();
+
+        float32_t *outp  = output.ptr();
+
+        arm_absmax_no_idx_f32(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsF32::test_min_no_idx_f32()
+    {
+        const float32_t *inp  = inputA.ptr();
+
+        float32_t result;
+
+        float32_t *refp  = ref.ptr();
+
+        float32_t *outp  = output.ptr();
+
+        arm_min_no_idx_f32(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsF32::test_absmin_no_idx_f32()
+    {
+        const float32_t *inp  = inputA.ptr();
+
+        float32_t result;
+
+        float32_t *refp  = ref.ptr();
+
+        float32_t *outp  = output.ptr();
+
+        arm_absmin_no_idx_f32(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
     void StatsTestsF32::test_min_f32()
     {
         const float32_t *inp  = inputA.ptr();
@@ -859,6 +919,114 @@ a double precision computation.
             }
             break;
 
+            case StatsTestsF32::TEST_MIN_NO_IDX_F32_40:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,3);
+              
+               ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF32::TEST_MIN_NO_IDX_F32_41:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,8);
+              
+               ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF32::TEST_MIN_NO_IDX_F32_42:
+            {
+               inputA.reload(StatsTestsF32::INPUT1_F32_ID,mgr,11);
+              
+               ref.reload(StatsTestsF32::MINVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF32::TEST_ABSMAX_NO_IDX_F32_43:
+            {
+               inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,3);
+              
+               ref.reload(StatsTestsF32::ABSMAXVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF32::TEST_ABSMAX_NO_IDX_F32_44:
+            {
+               inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,8);
+              
+               ref.reload(StatsTestsF32::ABSMAXVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF32::TEST_ABSMAX_NO_IDX_F32_45:
+            {
+               inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,11);
+              
+               ref.reload(StatsTestsF32::ABSMAXVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF32::TEST_ABSMIN_NO_IDX_F32_46:
+            {
+               inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,3);
+              
+               ref.reload(StatsTestsF32::ABSMINVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF32::TEST_ABSMIN_NO_IDX_F32_47:
+            {
+               inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,8);
+              
+               ref.reload(StatsTestsF32::ABSMINVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF32::TEST_ABSMIN_NO_IDX_F32_48:
+            {
+               inputA.reload(StatsTestsF32::INPUTNEW1_F32_ID,mgr,11);
+              
+               ref.reload(StatsTestsF32::ABSMINVALS_F32_ID,mgr);
+               
+               output.create(1,StatsTestsF32::OUT_F32_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
 
         }
         

CMSIS/DSP/Testing/Source/Tests/StatsTestsF64.cpp

@@ -85,6 +85,66 @@ a double precision computation.
 
     }
 
+    void StatsTestsF64::test_absmax_no_idx_f64()
+    {
+        const float64_t *inp  = inputA.ptr();
+
+        float64_t result;
+
+        float64_t *refp  = ref.ptr();
+
+        float64_t *outp  = output.ptr();
+
+        arm_absmax_no_idx_f64(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsF64::test_min_no_idx_f64()
+    {
+        const float64_t *inp  = inputA.ptr();
+
+        float64_t result;
+
+        float64_t *refp  = ref.ptr();
+
+        float64_t *outp  = output.ptr();
+
+        arm_min_no_idx_f64(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsF64::test_absmin_no_idx_f64()
+    {
+        const float64_t *inp  = inputA.ptr();
+
+        float64_t result;
+
+        float64_t *refp  = ref.ptr();
+
+        float64_t *outp  = output.ptr();
+
+        arm_absmin_no_idx_f64(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
     void StatsTestsF64::test_min_f64()
     {
         const float64_t *inp  = inputA.ptr();
@@ -861,6 +921,115 @@ a double precision computation.
             }
             break;
 
+            case StatsTestsF64::TEST_MIN_NO_IDX_F64_40:
+            {
+               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,2);
+              
+               ref.reload(StatsTestsF64::MINVALS_F64_ID,mgr);
+               
+               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF64::TEST_MIN_NO_IDX_F64_41:
+            {
+               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,4);
+              
+               ref.reload(StatsTestsF64::MINVALS_F64_ID,mgr);
+               
+               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF64::TEST_MIN_NO_IDX_F64_42:
+            {
+               inputA.reload(StatsTestsF64::INPUT1_F64_ID,mgr,5);
+              
+               ref.reload(StatsTestsF64::MINVALS_F64_ID,mgr);
+               
+               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+
+            case StatsTestsF64::TEST_ABSMAX_NO_IDX_F64_43:
+            {
+               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,2);
+              
+               ref.reload(StatsTestsF64::ABSMAXVALS_F64_ID,mgr);
+               
+               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF64::TEST_ABSMAX_NO_IDX_F64_44:
+            {
+               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,4);
+              
+               ref.reload(StatsTestsF64::ABSMAXVALS_F64_ID,mgr);
+               
+               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF64::TEST_ABSMAX_NO_IDX_F64_45:
+            {
+               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,5);
+              
+               ref.reload(StatsTestsF64::ABSMAXVALS_F64_ID,mgr);
+               
+               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsF64::TEST_ABSMIN_NO_IDX_F64_46:
+            {
+               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,2);
+              
+               ref.reload(StatsTestsF64::ABSMINVALS_F64_ID,mgr);
+               
+               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsF64::TEST_ABSMIN_NO_IDX_F64_47:
+            {
+               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,4);
+              
+               ref.reload(StatsTestsF64::ABSMINVALS_F64_ID,mgr);
+               
+               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsF64::TEST_ABSMIN_NO_IDX_F64_48:
+            {
+               inputA.reload(StatsTestsF64::INPUTNEW1_F64_ID,mgr,5);
+              
+               ref.reload(StatsTestsF64::ABSMINVALS_F64_ID,mgr);
+               
+               output.create(1,StatsTestsF64::OUT_F64_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
 
         }
         

CMSIS/DSP/Testing/Source/Tests/StatsTestsQ15.cpp

@@ -41,6 +41,46 @@ a double precision computation.
 
     }
 
+    void StatsTestsQ15::test_max_no_idx_q15()
+    {
+        const q15_t *inp  = inputA.ptr();
+
+        q15_t result;
+
+        q15_t *refp  = ref.ptr();
+
+        q15_t *outp  = output.ptr();
+
+        arm_max_no_idx_q15(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsQ15::test_absmax_no_idx_q15()
+    {
+        const q15_t *inp  = inputA.ptr();
+
+        q15_t result;
+
+        q15_t *refp  = ref.ptr();
+
+        q15_t *outp  = output.ptr();
+
+        arm_absmax_no_idx_q15(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
     void StatsTestsQ15::test_absmax_q15()
     {
         const q15_t *inp  = inputA.ptr();
@@ -93,6 +133,46 @@ a double precision computation.
 
     }
 
+    void StatsTestsQ15::test_min_no_idx_q15()
+    {
+        const q15_t *inp  = inputA.ptr();
+
+        q15_t result;
+
+        q15_t *refp  = ref.ptr();
+
+        q15_t *outp  = output.ptr();
+
+        arm_min_no_idx_q15(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsQ15::test_absmin_no_idx_q15()
+    {
+        const q15_t *inp  = inputA.ptr();
+
+        q15_t result;
+
+        q15_t *refp  = ref.ptr();
+
+        q15_t *outp  = output.ptr();
+
+        arm_absmin_no_idx_q15(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
     void StatsTestsQ15::test_absmin_q15()
     {
         const q15_t *inp  = inputA.ptr();
@@ -584,6 +664,150 @@ a double precision computation.
             }
             break;
 
+            case StatsTestsQ15::TEST_MAX_NO_IDX_Q15_28:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,7);
+              
+               ref.reload(StatsTestsQ15::MAXVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MAX_NO_IDX_Q15_29:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,16);
+              
+               ref.reload(StatsTestsQ15::MAXVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MAX_NO_IDX_Q15_30:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,23);
+              
+               ref.reload(StatsTestsQ15::MAXVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MIN_NO_IDX_Q15_31:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,7);
+              
+               ref.reload(StatsTestsQ15::MINVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MIN_NO_IDX_Q15_32:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,16);
+              
+               ref.reload(StatsTestsQ15::MINVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_MIN_NO_IDX_Q15_33:
+            {
+               inputA.reload(StatsTestsQ15::INPUT1_Q15_ID,mgr,23);
+              
+               ref.reload(StatsTestsQ15::MINVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_ABSMAX_NO_IDX_Q15_34:
+            {
+               inputA.reload(StatsTestsQ15::INPUTNEW1_Q15_ID,mgr,7);
+              
+               ref.reload(StatsTestsQ15::ABSMAXVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_ABSMAX_NO_IDX_Q15_35:
+            {
+               inputA.reload(StatsTestsQ15::INPUTNEW1_Q15_ID,mgr,16);
+              
+               ref.reload(StatsTestsQ15::ABSMAXVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_ABSMAX_NO_IDX_Q15_36:
+            {
+               inputA.reload(StatsTestsQ15::INPUTNEW1_Q15_ID,mgr,23);
+              
+               ref.reload(StatsTestsQ15::ABSMAXVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_ABSMIN_NO_IDX_Q15_37:
+            {
+               inputA.reload(StatsTestsQ15::INPUTNEW1_Q15_ID,mgr,7);
+              
+               ref.reload(StatsTestsQ15::ABSMINVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_ABSMIN_NO_IDX_Q15_38:
+            {
+               inputA.reload(StatsTestsQ15::INPUTNEW1_Q15_ID,mgr,16);
+              
+               ref.reload(StatsTestsQ15::ABSMINVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ15::TEST_ABSMIN_NO_IDX_Q15_39:
+            {
+               inputA.reload(StatsTestsQ15::INPUTNEW1_Q15_ID,mgr,23);
+              
+               ref.reload(StatsTestsQ15::ABSMINVALS_Q15_ID,mgr);
+               
+               output.create(1,StatsTestsQ15::OUT_Q15_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
           
         }
         

CMSIS/DSP/Testing/Source/Tests/StatsTestsQ31.cpp

@@ -93,6 +93,46 @@ a double precision computation.
 
     }
 
+    void StatsTestsQ31::test_min_no_idx_q31()
+    {
+        const q31_t *inp  = inputA.ptr();
+
+        q31_t result;
+
+        q31_t *refp  = ref.ptr();
+
+        q31_t *outp  = output.ptr();
+
+        arm_min_no_idx_q31(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsQ31::test_absmin_no_idx_q31()
+    {
+        const q31_t *inp  = inputA.ptr();
+
+        q31_t result;
+
+        q31_t *refp  = ref.ptr();
+
+        q31_t *outp  = output.ptr();
+
+        arm_absmin_no_idx_q31(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
     void StatsTestsQ31::test_absmin_q31()
     {
         const q31_t *inp  = inputA.ptr();
@@ -229,6 +269,46 @@ a double precision computation.
 
     }
 
+    void StatsTestsQ31::test_max_no_idx_q31()
+    {
+        const q31_t *inp  = inputA.ptr();
+
+        q31_t result;
+
+        q31_t *refp  = ref.ptr();
+
+        q31_t *outp  = output.ptr();
+
+        arm_max_no_idx_q31(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsQ31::test_absmax_no_idx_q31()
+    {
+        const q31_t *inp  = inputA.ptr();
+
+        q31_t result;
+
+        q31_t *refp  = ref.ptr();
+
+        q31_t *outp  = output.ptr();
+
+        arm_absmax_no_idx_q31(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
   
   
     void StatsTestsQ31::setUp(Testing::testID_t id,std::vector<Testing::param_t>& paramsArgs,Client::PatternMgr *mgr)
@@ -584,6 +664,150 @@ a double precision computation.
             }
             break;
 
+            case StatsTestsQ31::TEST_MAX_NO_IDX_Q31_28:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,3);
+              
+               ref.reload(StatsTestsQ31::MAXVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MAX_NO_IDX_Q31_29:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,8);
+              
+               ref.reload(StatsTestsQ31::MAXVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MAX_NO_IDX_Q31_30:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,11);
+              
+               ref.reload(StatsTestsQ31::MAXVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MIN_NO_IDX_Q31_31:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,3);
+              
+               ref.reload(StatsTestsQ31::MINVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MIN_NO_IDX_Q31_32:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,8);
+              
+               ref.reload(StatsTestsQ31::MINVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_MIN_NO_IDX_Q31_33:
+            {
+               inputA.reload(StatsTestsQ31::INPUT1_Q31_ID,mgr,11);
+              
+               ref.reload(StatsTestsQ31::MINVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_ABSMAX_NO_IDX_Q31_34:
+            {
+               inputA.reload(StatsTestsQ31::INPUTNEW1_Q31_ID,mgr,3);
+              
+               ref.reload(StatsTestsQ31::ABSMAXVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_ABSMAX_NO_IDX_Q31_35:
+            {
+               inputA.reload(StatsTestsQ31::INPUTNEW1_Q31_ID,mgr,8);
+              
+               ref.reload(StatsTestsQ31::ABSMAXVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_ABSMAX_NO_IDX_Q31_36:
+            {
+               inputA.reload(StatsTestsQ31::INPUTNEW1_Q31_ID,mgr,11);
+              
+               ref.reload(StatsTestsQ31::ABSMAXVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_ABSMIN_NO_IDX_Q31_37:
+            {
+               inputA.reload(StatsTestsQ31::INPUTNEW1_Q31_ID,mgr,3);
+              
+               ref.reload(StatsTestsQ31::ABSMINVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_ABSMIN_NO_IDX_Q31_38:
+            {
+               inputA.reload(StatsTestsQ31::INPUTNEW1_Q31_ID,mgr,8);
+              
+               ref.reload(StatsTestsQ31::ABSMINVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ31::TEST_ABSMIN_NO_IDX_Q31_39:
+            {
+               inputA.reload(StatsTestsQ31::INPUTNEW1_Q31_ID,mgr,11);
+              
+               ref.reload(StatsTestsQ31::ABSMINVALS_Q31_ID,mgr);
+               
+               output.create(1,StatsTestsQ31::OUT_Q31_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
           
         }
         

CMSIS/DSP/Testing/Source/Tests/StatsTestsQ7.cpp

@@ -42,6 +42,46 @@ a double precision computation.
 
     }
 
+    void StatsTestsQ7::test_max_no_idx_q7()
+    {
+        const q7_t *inp  = inputA.ptr();
+
+        q7_t result;
+
+        q7_t *refp  = ref.ptr();
+
+        q7_t *outp  = output.ptr();
+
+        arm_max_no_idx_q7(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsQ7::test_absmax_no_idx_q7()
+    {
+        const q7_t *inp  = inputA.ptr();
+
+        q7_t result;
+
+        q7_t *refp  = ref.ptr();
+
+        q7_t *outp  = output.ptr();
+
+        arm_absmax_no_idx_q7(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
     void StatsTestsQ7::test_absmax_q7()
     {
         const q7_t *inp  = inputA.ptr();
@@ -104,6 +144,46 @@ Python code must be tuned to change this.
 
     }
 
+    void StatsTestsQ7::test_min_no_idx_q7()
+    {
+        const q7_t *inp  = inputA.ptr();
+
+        q7_t result;
+
+        q7_t *refp  = ref.ptr();
+
+        q7_t *outp  = output.ptr();
+
+        arm_min_no_idx_q7(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
+    void StatsTestsQ7::test_absmin_no_idx_q7()
+    {
+        const q7_t *inp  = inputA.ptr();
+
+        q7_t result;
+
+        q7_t *refp  = ref.ptr();
+
+        q7_t *outp  = output.ptr();
+
+        arm_absmin_no_idx_q7(inp,
+              inputA.nbSamples(),
+              &result);
+
+        outp[0] = result;
+
+        ASSERT_EQ(result,refp[this->refOffset]);
+
+    }
+
     void StatsTestsQ7::test_absmin_q7()
     {
         const q7_t *inp  = inputA.ptr();
@@ -673,6 +753,150 @@ But the tests are kept for when they will be available.
                refOffset = 3;
             }
             break;
+
+            case StatsTestsQ7::TEST_MAX_NO_IDX_Q7_23:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,15);
+              
+               ref.reload(StatsTestsQ7::MAXVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MAX_NO_IDX_Q7_24:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,32);
+              
+               ref.reload(StatsTestsQ7::MAXVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MAX_NO_IDX_Q7_25:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,47);
+              
+               ref.reload(StatsTestsQ7::MAXVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MIN_NO_IDX_Q7_26:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,15);
+              
+               ref.reload(StatsTestsQ7::MINVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MIN_NO_IDX_Q7_27:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,32);
+              
+               ref.reload(StatsTestsQ7::MINVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_MIN_NO_IDX_Q7_28:
+            {
+               inputA.reload(StatsTestsQ7::INPUT1_Q7_ID,mgr,47);
+              
+               ref.reload(StatsTestsQ7::MINVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_ABSMAX_NO_IDX_Q7_29:
+            {
+               inputA.reload(StatsTestsQ7::INPUTNEW1_Q7_ID,mgr,15);
+              
+               ref.reload(StatsTestsQ7::ABSMAXVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_ABSMAX_NO_IDX_Q7_30:
+            {
+               inputA.reload(StatsTestsQ7::INPUTNEW1_Q7_ID,mgr,32);
+              
+               ref.reload(StatsTestsQ7::ABSMAXVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_ABSMAX_NO_IDX_Q7_31:
+            {
+               inputA.reload(StatsTestsQ7::INPUTNEW1_Q7_ID,mgr,47);
+              
+               ref.reload(StatsTestsQ7::ABSMAXVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_ABSMIN_NO_IDX_Q7_32:
+            {
+               inputA.reload(StatsTestsQ7::INPUTNEW1_Q7_ID,mgr,15);
+              
+               ref.reload(StatsTestsQ7::ABSMINVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 0;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_ABSMIN_NO_IDX_Q7_33:
+            {
+               inputA.reload(StatsTestsQ7::INPUTNEW1_Q7_ID,mgr,32);
+              
+               ref.reload(StatsTestsQ7::ABSMINVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 1;
+            }
+            break;
+
+            case StatsTestsQ7::TEST_ABSMIN_NO_IDX_Q7_34:
+            {
+               inputA.reload(StatsTestsQ7::INPUTNEW1_Q7_ID,mgr,47);
+              
+               ref.reload(StatsTestsQ7::ABSMINVALS_Q7_ID,mgr);
+               
+               output.create(1,StatsTestsQ7::OUT_Q7_ID,mgr);
+
+               refOffset = 2;
+            }
+            break;
           
         }
         

CMSIS/DSP/Testing/desc.txt

@@ -110,6 +110,18 @@ group Root {
                 Test nb=2n   arm_absmin_f64:test_absmin_f64
                 Test nb=2n+1 arm_absmin_f64:test_absmin_f64
 
+                Test nb=2    arm_min_no_idx_f64:test_min_no_idx_f64
+                Test nb=2n   arm_min_no_idx_f64:test_min_no_idx_f64
+                Test nb=2n+1 arm_min_no_idx_f64:test_min_no_idx_f64
+
+                Test nb=2    arm_absmax_no_idx_f64:test_absmax_no_idx_f64
+                Test nb=2n   arm_absmax_no_idx_f64:test_absmax_no_idx_f64
+                Test nb=2n+1 arm_absmax_no_idx_f64:test_absmax_no_idx_f64
+
+                Test nb=2    arm_absmin_no_idx_f64:test_absmin_no_idx_f64
+                Test nb=2n   arm_absmin_no_idx_f64:test_absmin_no_idx_f64
+                Test nb=2n+1 arm_absmin_no_idx_f64:test_absmin_no_idx_f64
+
 
               }
 
@@ -215,6 +227,18 @@ group Root {
                 Test nb=4n   arm_absmin_f32:test_absmin_f32
                 Test nb=4n+1 arm_absmin_f32:test_absmin_f32
 
+                Test nb=3    arm_min_no_idx_f32:test_min_no_idx_f32
+                Test nb=4n   arm_min_no_idx_f32:test_min_no_idx_f32
+                Test nb=4n+1 arm_min_no_idx_f32:test_min_no_idx_f32
+
+                Test nb=2    arm_absmax_no_idx_f32:test_absmax_no_idx_f32
+                Test nb=2n   arm_absmax_no_idx_f32:test_absmax_no_idx_f32
+                Test nb=2n+1 arm_absmax_no_idx_f32:test_absmax_no_idx_f32
+
+                Test nb=2    arm_absmin_no_idx_f32:test_absmin_no_idx_f32
+                Test nb=2n   arm_absmin_no_idx_f32:test_absmin_no_idx_f32
+                Test nb=2n+1 arm_absmin_no_idx_f32:test_absmin_no_idx_f32
+
 
               }
 
@@ -288,6 +312,22 @@ group Root {
                 Test nb=4n   arm_absmin_q31:test_absmin_q31
                 Test nb=4n+1 arm_absmin_q31:test_absmin_q31
 
+                Test nb=3    arm_max_no_idx_q31:test_max_no_idx_q31
+                Test nb=4n   arm_max_no_idx_q31:test_max_no_idx_q31
+                Test nb=4n+1 arm_max_no_idx_q31:test_max_no_idx_q31
+
+                Test nb=3    arm_min_no_idx_q31:test_min_no_idx_q31
+                Test nb=4n   arm_min_no_idx_q31:test_min_no_idx_q31
+                Test nb=4n+1 arm_min_no_idx_q31:test_min_no_idx_q31
+
+                Test nb=2    arm_absmax_no_idx_q31:test_absmax_no_idx_q31
+                Test nb=2n   arm_absmax_no_idx_q31:test_absmax_no_idx_q31
+                Test nb=2n+1 arm_absmax_no_idx_q31:test_absmax_no_idx_q31
+
+                Test nb=2    arm_absmin_no_idx_q31:test_absmin_no_idx_q31
+                Test nb=2n   arm_absmin_no_idx_q31:test_absmin_no_idx_q31
+                Test nb=2n+1 arm_absmin_no_idx_q31:test_absmin_no_idx_q31
+
               }
 
            }
@@ -360,6 +400,22 @@ group Root {
                 Test nb=4n   arm_absmin_q15:test_absmin_q15
                 Test nb=4n+1 arm_absmin_q15:test_absmin_q15
 
+                Test nb=3    arm_max_no_idx_q15:test_max_no_idx_q15
+                Test nb=4n   arm_max_no_idx_q15:test_max_no_idx_q15
+                Test nb=4n+1 arm_max_no_idx_q15:test_max_no_idx_q15
+
+                Test nb=3    arm_min_no_idx_q15:test_min_no_idx_q15
+                Test nb=4n   arm_min_no_idx_q15:test_min_no_idx_q15
+                Test nb=4n+1 arm_min_no_idx_q15:test_min_no_idx_q15
+
+                Test nb=2    arm_absmax_no_idx_q15:test_absmax_no_idx_q15
+                Test nb=2n   arm_absmax_no_idx_q15:test_absmax_no_idx_q15
+                Test nb=2n+1 arm_absmax_no_idx_q15:test_absmax_no_idx_q15
+
+                Test nb=2    arm_absmin_no_idx_q15:test_absmin_no_idx_q15
+                Test nb=2n   arm_absmin_no_idx_q15:test_absmin_no_idx_q15
+                Test nb=2n+1 arm_absmin_no_idx_q15:test_absmin_no_idx_q15
+
               }
 
            }
@@ -431,6 +487,22 @@ group Root {
                 Test big index  arm_absmax_q7:test_absmax_q7
                 Test big index  arm_absmin_q7:test_absmin_q7
 
+                Test nb=3    arm_max_no_idx_q7:test_max_no_idx_q7
+                Test nb=4n   arm_max_no_idx_q7:test_max_no_idx_q7
+                Test nb=4n+1 arm_max_no_idx_q7:test_max_no_idx_q7
+
+                Test nb=3    arm_min_no_idx_q7:test_min_no_idx_q7
+                Test nb=4n   arm_min_no_idx_q7:test_min_no_idx_q7
+                Test nb=4n+1 arm_min_no_idx_q7:test_min_no_idx_q7
+
+                Test nb=2    arm_absmax_no_idx_q7:test_absmax_no_idx_q7
+                Test nb=2n   arm_absmax_no_idx_q7:test_absmax_no_idx_q7
+                Test nb=2n+1 arm_absmax_no_idx_q7:test_absmax_no_idx_q7
+
+                Test nb=2    arm_absmin_no_idx_q7:test_absmin_no_idx_q7
+                Test nb=2n   arm_absmin_no_idx_q7:test_absmin_no_idx_q7
+                Test nb=2n+1 arm_absmin_no_idx_q7:test_absmin_no_idx_q7
+
               }
 
            }

CMSIS/DSP/Testing/desc_f16.txt

@@ -107,6 +107,18 @@ group Root {
                 Test nb=3    arm_absmin_f16:test_absmin_f16
                 Test nb=4n   arm_absmin_f16:test_absmin_f16
                 Test nb=4n+1 arm_absmin_f16:test_absmin_f16
+
+                Test nb=7    arm_min_no_idx_f16:test_min_no_idx_f16
+                Test nb=8n   arm_min_no_idx_f16:test_min_no_idx_f16
+                Test nb=8n+1 arm_min_no_idx_f16:test_min_no_idx_f16
+
+                Test nb=2    arm_absmax_no_idx_f16:test_absmax_no_idx_f16
+                Test nb=2n   arm_absmax_no_idx_f16:test_absmax_no_idx_f16
+                Test nb=2n+1 arm_absmax_no_idx_f16:test_absmax_no_idx_f16
+
+                Test nb=2    arm_absmin_no_idx_f16:test_absmin_no_idx_f16
+                Test nb=2n   arm_absmin_no_idx_f16:test_absmin_no_idx_f16
+                Test nb=2n+1 arm_absmin_no_idx_f16:test_absmin_no_idx_f16
               }
            }
         }

CMSIS/DSP/configCore.cmake

@@ -10,7 +10,7 @@ option(HARDFP "Hard floating point" ON)
 option(LITTLEENDIAN "Little endian" ON)
 option(FASTMATHCOMPUTATIONS "Fast Math enabled" OFF)
 option(FLOAT16 "Scalar float16 supported by the core" OFF)
-option(HYBRID "Hybrid instrinsics" ON)
+option(HYBRID "Hybrid instrinsics" OFF)
 
 # More detailed identification for benchmark results
 SET(COREID ARMCM7)

CMSIS/DoxyGen/DSP/src/history.txt

@@ -27,6 +27,11 @@
 
       Added arm_mat_mult_opt_q31 for a faster version of arm_mat_mult_q31
       when using Helium (but requiring more storage for intermediate results).
+
+      arm_(min|max)_no_idx_(q7|q15|q31|f16|f32|f64)
+      
+      arm_abs(min|max)_no_idx_(q7|q15|q31|f16|f32|f64)
+
     </td>
   </tr>
   <tr>