1  /* ----------------------------------------------------------------------
  2   * Project:      CMSIS DSP Library
  3   * Title:        arm_min_no_idx_q15.c
  4   * Description:  Minimum value of a q15 vector without returning the index
  5   *
  6   * $Date:        16 November 2021
  7   * $Revision:    V1.10.0
  8   *
  9   * Target Processor: Cortex-M and Cortex-A cores
 10   * -------------------------------------------------------------------- */
 11  /*
 12   * Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
 13   *
 14   * SPDX-License-Identifier: Apache-2.0
 15   *
 16   * Licensed under the Apache License, Version 2.0 (the License); you may
 17   * not use this file except in compliance with the License.
 18   * You may obtain a copy of the License at
 19   *
 20   * www.apache.org/licenses/LICENSE-2.0
 21   *
 22   * Unless required by applicable law or agreed to in writing, software
 23   * distributed under the License is distributed on an AS IS BASIS, WITHOUT
 24   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 25   * See the License for the specific language governing permissions and
 26   * limitations under the License.
 27   */
 28  
 29  #include "dsp/statistics_functions.h"
 30  
 31  
 32  /**
 33    @ingroup groupStats
 34   */
 35  
 36  /**
 37    @addtogroup Min
 38    @{
 39   */
 40  
 41  /**
 42    @brief         Minimum value of a q15 vector without index.
 43    @param[in]     pSrc       points to the input vector
 44    @param[in]     blockSize  number of samples in input vector
 45    @param[out]    pResult    minimum value returned here
 46    @return        none
 47   */
 48  
 49  #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE)
 50  
 51  #include "arm_helium_utils.h"
 52  
 53  void arm_min_no_idx_q15(
 54    const q15_t * pSrc,
 55          uint32_t blockSize,
 56          q15_t * pResult)
 57  {
 58      int32_t  blkCnt;           /* loop counters */
 59      q15x8_t vecSrc;
 60      q15_t const *pSrcVec;
 61      q15x8_t curExtremValVec = vdupq_n_s16(Q15_MAX);
 62      q15_t minValue = Q15_MAX;
 63      mve_pred16_t p0;
 64  
 65  
 66      pSrcVec = (q15_t const *) pSrc;
 67      blkCnt = blockSize >> 3;
 68      while (blkCnt > 0)
 69      {
 70          vecSrc = vld1q(pSrcVec); 
 71          pSrcVec += 8;
 72          /*
 73           * update per-lane min.
 74           */
 75          curExtremValVec = vminq(vecSrc, curExtremValVec);
 76          /*
 77           * Decrement the blockSize loop counter
 78           */
 79          blkCnt--;
 80      }
 81      /*
 82       * tail
 83       * (will be merged thru tail predication)
 84       */
 85      blkCnt = blockSize & 7;
 86      if (blkCnt > 0)
 87      {
 88          vecSrc = vld1q(pSrcVec); 
 89          pSrcVec += 8;
 90          p0 = vctp16q(blkCnt);
 91          /*
 92           * Get current min per lane and current index per lane
 93           * when a min is selected
 94           */
 95           curExtremValVec = vminq_m(curExtremValVec, vecSrc, curExtremValVec, p0);
 96      }
 97      /*
 98       * Get min value across the vector
 99       */
100      minValue = vminvq(minValue, curExtremValVec);
101      *pResult = minValue;
102  }
103  
104  #else
105  void arm_min_no_idx_q15(
106    const q15_t * pSrc,
107          uint32_t blockSize,
108          q15_t * pResult)
109  {
110    q15_t minVal1, out;       /* Temporary variables to store the output value. */    
111    uint32_t blkCnt;              /* loop counter */                                  
112                                                                                      
113    /* Load first input value that act as reference value for comparision */          
114    out = *pSrc++;                                                                    
115                                                                                      
116    blkCnt = (blockSize - 1U);                                                        
117                                                                                      
118                                                                                      
119    while (blkCnt > 0U)                                                               
120    {                                                                                 
121      /* Initialize minVal to the next consecutive values one by one */               
122      minVal1 = *pSrc++;                                                              
123                                                                                      
124      /* compare for the minimum value */                                             
125      if (out > minVal1)                                                              
126      {                                                                               
127        /* Update the minimum value */                                                
128        out = minVal1;                                                                
129      }                                                                               
130                                                                                      
131      /* Decrement the loop counter */                                                
132      blkCnt--;                                                                       
133    }                                                                                 
134                                                                                      
135    /* Store the minimum value into destination pointer */                            
136    *pResult = out;
137  }
138  
139  #endif /* #if defined(ARM_MATH_MVEI) && !defined(ARM_MATH_AUTOVECTORIZE) */
140  /**
141    @} end of Min group
142   */