1 /* ----------------------------------------------------------------------
2 * Project: CMSIS DSP Library
3 * Title: arm_absmin_f16.c
4 * Description: Minimum value of absolute values of a floating-point vector
5 *
6 * $Date: 23 April 2021
7 * $Revision: V1.9.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_f16.h"
30
31 #if defined(ARM_FLOAT16_SUPPORTED)
32
33
34 #if (defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF)) && !defined(ARM_MATH_AUTOVECTORIZE)
35 #include <limits.h>
36 #endif
37
38
39 /**
40 @ingroup groupStats
41 */
42
43 /**
44 @addtogroup AbsMin
45 @{
46 */
47
48 /**
49 @brief Minimum value of absolute values of a floating-point vector.
50 @param[in] pSrc points to the input vector
51 @param[in] blockSize number of samples in input vector
52 @param[out] pResult minimum value returned here
53 @param[out] pIndex index of minimum value returned here
54 */
55
56 #if defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE)
57
58 #include "arm_helium_utils.h"
arm_absmin_f16(const float16_t * pSrc,uint32_t blockSize,float16_t * pResult,uint32_t * pIndex)59 ARM_DSP_ATTRIBUTE void arm_absmin_f16(
60 const float16_t * pSrc,
61 uint32_t blockSize,
62 float16_t * pResult,
63 uint32_t * pIndex)
64 {
65 uint16_t blkCnt; /* loop counters */
66 f16x8_t vecSrc;
67 float16_t const *pSrcVec;
68 f16x8_t curExtremValVec = vdupq_n_f16(F16_ABSMAX);
69 float16_t minValue = F16_ABSMAX;
70 uint16_t idx = blockSize;
71 uint16x8_t indexVec;
72 uint16x8_t curExtremIdxVec;
73 mve_pred16_t p0;
74
75
76 indexVec = vidupq_u16((uint32_t)0, 1);
77 curExtremIdxVec = vdupq_n_u16(0);
78
79 pSrcVec = (float16_t const *) pSrc;
80 blkCnt = blockSize >> 3;
81 while (blkCnt > 0U)
82 {
83 vecSrc = vldrhq_f16(pSrcVec);
84 pSrcVec += 8;
85 vecSrc = vabsq(vecSrc);
86 /*
87 * Get current max per lane and current index per lane
88 * when a max is selected
89 */
90 p0 = vcmpleq(vecSrc, curExtremValVec);
91 curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
92 curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
93
94 indexVec = indexVec + 8;
95 /*
96 * Decrement the blockSize loop counter
97 */
98 blkCnt--;
99 }
100 /*
101 * tail
102 * (will be merged thru tail predication)
103 */
104 blkCnt = blockSize & 7;
105 if (blkCnt > 0U)
106 {
107 p0 = vctp16q(blkCnt);
108
109 vecSrc = vldrhq_f16(pSrcVec);
110 pSrcVec += 8;
111 vecSrc = vabsq(vecSrc);
112 /*
113 * Get current max per lane and current index per lane
114 * when a max is selected
115 */
116 p0 = vcmpleq_m(vecSrc, curExtremValVec, p0);
117 curExtremValVec = vpselq(vecSrc, curExtremValVec, p0);
118 curExtremIdxVec = vpselq(indexVec, curExtremIdxVec, p0);
119 }
120 /*
121 * Get min value across the vector
122 */
123 minValue = vminnmvq(minValue, curExtremValVec);
124 /*
125 * set index for lower values to max possible index
126 */
127 p0 = vcmpleq(curExtremValVec, minValue);
128 indexVec = vpselq(curExtremIdxVec, vdupq_n_u16(blockSize), p0);
129 /*
130 * Get min index which is thus for a max value
131 */
132 idx = vminvq(idx, indexVec);
133 /*
134 * Save result
135 */
136 *pIndex = idx;
137 *pResult = minValue;
138 }
139
140 #else
141 #if defined(ARM_MATH_LOOPUNROLL)
arm_absmin_f16(const float16_t * pSrc,uint32_t blockSize,float16_t * pResult,uint32_t * pIndex)142 ARM_DSP_ATTRIBUTE void arm_absmin_f16(
143 const float16_t * pSrc,
144 uint32_t blockSize,
145 float16_t * pResult,
146 uint32_t * pIndex)
147 {
148 float16_t cur_absmin, out; /* Temporary variables to store the output value. */\
149 uint32_t blkCnt, outIndex; /* Loop counter */ \
150 uint32_t index; /* index of maximum value */ \
151 \
152 /* Initialize index value to zero. */ \
153 outIndex = 0U; \
154 /* Load first input value that act as reference value for comparision */ \
155 out = *pSrc++; \
156 out = ((_Float16)out > 0.0f16) ? out : -(_Float16)out; \
157 /* Initialize index of extrema value. */ \
158 index = 0U; \
159 \
160 /* Loop unrolling: Compute 4 outputs at a time */ \
161 blkCnt = (blockSize - 1U) >> 2U; \
162 \
163 while (blkCnt > 0U) \
164 { \
165 /* Initialize cur_absmin to next consecutive values one by one */ \
166 cur_absmin = *pSrc++; \
167 cur_absmin = ((_Float16)cur_absmin > 0.0f16) ? cur_absmin : -(_Float16)cur_absmin; \
168 /* compare for the extrema value */ \
169 if ((_Float16)cur_absmin < (_Float16)out) \
170 { \
171 /* Update the extrema value and it's index */ \
172 out = cur_absmin; \
173 outIndex = index + 1U; \
174 } \
175 \
176 cur_absmin = *pSrc++; \
177 cur_absmin = ((_Float16)cur_absmin > 0.0f16) ? cur_absmin : -(_Float16)cur_absmin; \
178 if ((_Float16)cur_absmin < (_Float16)out) \
179 { \
180 out = cur_absmin; \
181 outIndex = index + 2U; \
182 } \
183 \
184 cur_absmin = *pSrc++; \
185 cur_absmin = ((_Float16)cur_absmin > 0.0f16) ? cur_absmin : -(_Float16)cur_absmin; \
186 if ((_Float16)cur_absmin < (_Float16)out) \
187 { \
188 out = cur_absmin; \
189 outIndex = index + 3U; \
190 } \
191 \
192 cur_absmin = *pSrc++; \
193 cur_absmin = ((_Float16)cur_absmin > 0.0f16) ? cur_absmin : -(_Float16)cur_absmin; \
194 if ((_Float16)cur_absmin < (_Float16)out) \
195 { \
196 out = cur_absmin; \
197 outIndex = index + 4U; \
198 } \
199 \
200 index += 4U; \
201 \
202 /* Decrement loop counter */ \
203 blkCnt--; \
204 } \
205 \
206 /* Loop unrolling: Compute remaining outputs */ \
207 blkCnt = (blockSize - 1U) % 4U; \
208 \
209 \
210 while (blkCnt > 0U) \
211 { \
212 cur_absmin = *pSrc++; \
213 cur_absmin = ((_Float16)cur_absmin > 0.0f16) ? cur_absmin : -(_Float16)cur_absmin; \
214 if ((_Float16)cur_absmin < (_Float16)out) \
215 { \
216 out = cur_absmin; \
217 outIndex = blockSize - blkCnt; \
218 } \
219 \
220 /* Decrement loop counter */ \
221 blkCnt--; \
222 } \
223 \
224 /* Store the extrema value and it's index into destination pointers */ \
225 *pResult = out; \
226 *pIndex = outIndex;
227 }
228 #else
arm_absmin_f16(const float16_t * pSrc,uint32_t blockSize,float16_t * pResult,uint32_t * pIndex)229 ARM_DSP_ATTRIBUTE void arm_absmin_f16(
230 const float16_t * pSrc,
231 uint32_t blockSize,
232 float16_t * pResult,
233 uint32_t * pIndex)
234 {
235 float16_t minVal, out; /* Temporary variables to store the output value. */
236 uint32_t blkCnt, outIndex; /* Loop counter */
237
238 /* Initialise index value to zero. */
239 outIndex = 0U;
240
241 /* Load first input value that act as reference value for comparision */
242 out = (_Float16)fabsf((float32_t)*pSrc++);
243
244 /* Initialize blkCnt with number of samples */
245 blkCnt = (blockSize - 1U);
246
247 while (blkCnt > 0U)
248 {
249 /* Initialize minVal to the next consecutive values one by one */
250 minVal = (_Float16)fabsf((float32_t)*pSrc++);
251
252 /* compare for the minimum value */
253 if ((_Float16)out > (_Float16)minVal)
254 {
255 /* Update the minimum value and it's index */
256 out = minVal;
257 outIndex = blockSize - blkCnt;
258 }
259
260 /* Decrement loop counter */
261 blkCnt--;
262 }
263
264 /* Store the minimum value and it's index into destination pointers */
265 *pResult = out;
266 *pIndex = outIndex;
267 }
268 #endif /* defined(ARM_MATH_LOOPUNROLL) */
269 #endif /* defined(ARM_MATH_MVE_FLOAT16) && !defined(ARM_MATH_AUTOVECTORIZE) */
270 /**
271 @} end of AbsMin group
272 */
273
274 #endif /* #if defined(ARM_FLOAT16_SUPPORTED) */
275
276
