Line data Source code
1 1 : /* Copyright (C) 2010-2021 ARM Limited or its affiliates. All rights reserved.
2 : * SPDX-License-Identifier: Apache-2.0
3 : */
4 :
5 : /**
6 : * @file zephyr/dsp/basicmath.h
7 : *
8 : * @brief Public APIs for DSP basicmath
9 : */
10 :
11 : #ifndef ZEPHYR_INCLUDE_DSP_BASICMATH_H_
12 : #define ZEPHYR_INCLUDE_DSP_BASICMATH_H_
13 :
14 : #include <zephyr/dsp/dsp.h>
15 :
16 : #ifdef __cplusplus
17 : extern "C" {
18 : #endif
19 :
20 : /**
21 : * @ingroup math_dsp
22 : * @defgroup math_dsp_basic Basic Math Functions
23 : */
24 :
25 : /**
26 : * @ingroup math_dsp_basic
27 : * @addtogroup math_dsp_basic_mult Vector Multiplication
28 : *
29 : * Element-by-element multiplication of two vectors.
30 : * <pre>
31 : * dst[n] = src_a[n] * src_b[n], 0 <= n < block_size.
32 : * </pre>
33 : * There are separate functions for floating-point, Q7, Q15, and Q31 data types.
34 : * @{
35 : */
36 :
37 : /**
38 : * @brief Q7 vector multiplication.
39 : *
40 : * @par Scaling and Overflow Behavior
41 : * The function uses saturating arithmetic.
42 : * Results outside of the allowable Q7 range [0x80 0x7F] are saturated.
43 : *
44 : * @param[in] src_a points to the first input vector
45 : * @param[in] src_b points to the second input vector
46 : * @param[out] dst points to the output vector
47 : * @param[in] block_size number of samples in each vector
48 : */
49 1 : DSP_FUNC_SCOPE void zdsp_mult_q7(const DSP_DATA q7_t *src_a, const DSP_DATA q7_t *src_b,
50 : DSP_DATA q7_t *dst, uint32_t block_size);
51 :
52 : /**
53 : * @brief Q15 vector multiplication.
54 : *
55 : * @par Scaling and Overflow Behavior
56 : * The function uses saturating arithmetic.
57 : * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
58 : *
59 : * @param[in] src_a points to the first input vector
60 : * @param[in] src_b points to the second input vector
61 : * @param[out] dst points to the output vector
62 : * @param[in] block_size number of samples in each vector
63 : */
64 1 : DSP_FUNC_SCOPE void zdsp_mult_q15(const DSP_DATA q15_t *src_a, const DSP_DATA q15_t *src_b,
65 : DSP_DATA q15_t *dst, uint32_t block_size);
66 :
67 : /**
68 : * @brief Q31 vector multiplication.
69 : *
70 : * @par Scaling and Overflow Behavior
71 : * The function uses saturating arithmetic.
72 : * Results outside of the allowable Q31 range[0x80000000 0x7FFFFFFF] are saturated.
73 : *
74 : * @param[in] src_a points to the first input vector
75 : * @param[in] src_b points to the second input vector
76 : * @param[out] dst points to the output vector
77 : * @param[in] block_size number of samples in each vector
78 : */
79 1 : DSP_FUNC_SCOPE void zdsp_mult_q31(const DSP_DATA q31_t *src_a, const DSP_DATA q31_t *src_b,
80 : DSP_DATA q31_t *dst, uint32_t block_size);
81 :
82 : /**
83 : * @brief Floating-point vector multiplication.
84 : * @param[in] src_a points to the first input vector
85 : * @param[in] src_b points to the second input vector
86 : * @param[out] dst points to the output vector
87 : * @param[in] block_size number of samples in each vector
88 : */
89 1 : DSP_FUNC_SCOPE void zdsp_mult_f32(const DSP_DATA float32_t *src_a, const DSP_DATA float32_t *src_b,
90 : DSP_DATA float32_t *dst, uint32_t block_size);
91 :
92 : /**
93 : * @}
94 : */
95 :
96 : /**
97 : * @ingroup math_dsp_basic
98 : * @addtogroup math_dsp_basic_add Vector Addition
99 : *
100 : * Element-by-element addition of two vectors.
101 : * <pre>
102 : * dst[n] = src_a[n] + src_b[n], 0 <= n < block_size.
103 : * </pre>
104 : * There are separate functions for floating-point, Q7, Q15, and Q31 data types.
105 : * @{
106 : */
107 :
108 : /**
109 : * @brief Floating-point vector addition.
110 : * @param[in] src_a points to the first input vector
111 : * @param[in] src_b points to the second input vector
112 : * @param[out] dst points to the output vector
113 : * @param[in] block_size number of samples in each vector
114 : */
115 1 : DSP_FUNC_SCOPE void zdsp_add_f32(const DSP_DATA float32_t *src_a, const DSP_DATA float32_t *src_b,
116 : DSP_DATA float32_t *dst, uint32_t block_size);
117 :
118 : /**
119 : * @brief Q7 vector addition.
120 : *
121 : * @par Scaling and Overflow Behavior
122 : * The function uses saturating arithmetic.
123 : * Results outside of the allowable Q7 range [0x80 0x7F] are saturated.
124 : *
125 : * @param[in] src_a points to the first input vector
126 : * @param[in] src_b points to the second input vector
127 : * @param[out] dst points to the output vector
128 : * @param[in] block_size number of samples in each vector
129 : */
130 1 : DSP_FUNC_SCOPE void zdsp_add_q7(const DSP_DATA q7_t *src_a, const DSP_DATA q7_t *src_b,
131 : DSP_DATA q7_t *dst, uint32_t block_size);
132 :
133 : /**
134 : * @brief Q15 vector addition.
135 : *
136 : * @par Scaling and Overflow Behavior
137 : * The function uses saturating arithmetic.
138 : * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
139 : *
140 : * @param[in] src_a points to the first input vector
141 : * @param[in] src_b points to the second input vector
142 : * @param[out] dst points to the output vector
143 : * @param[in] block_size number of samples in each vector
144 : */
145 1 : DSP_FUNC_SCOPE void zdsp_add_q15(const DSP_DATA q15_t *src_a, const DSP_DATA q15_t *src_b,
146 : DSP_DATA q15_t *dst, uint32_t block_size);
147 :
148 : /**
149 : * @brief Q31 vector addition.
150 : *
151 : * @par Scaling and Overflow Behavior
152 : * The function uses saturating arithmetic.
153 : * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.
154 : *
155 : * @param[in] src_a points to the first input vector
156 : * @param[in] src_b points to the second input vector
157 : * @param[out] dst points to the output vector
158 : * @param[in] block_size number of samples in each vector
159 : */
160 1 : DSP_FUNC_SCOPE void zdsp_add_q31(const DSP_DATA q31_t *src_a, const DSP_DATA q31_t *src_b,
161 : DSP_DATA q31_t *dst, uint32_t block_size);
162 :
163 : /**
164 : * @}
165 : */
166 :
167 : /**
168 : * @ingroup math_dsp_basic
169 : * @addtogroup math_dsp_basic_sub Vector Subtraction
170 : *
171 : * Element-by-element subtraction of two vectors.
172 : * <pre>
173 : * dst[n] = src_a[n] - src_b[n], 0 <= n < block_size.
174 : * </pre>
175 : * There are separate functions for floating-point, Q7, Q15, and Q31 data types.
176 : * @{
177 : */
178 :
179 : /**
180 : * @brief Floating-point vector subtraction.
181 : * @param[in] src_a points to the first input vector
182 : * @param[in] src_b points to the second input vector
183 : * @param[out] dst points to the output vector
184 : * @param[in] block_size number of samples in each vector
185 : */
186 1 : DSP_FUNC_SCOPE void zdsp_sub_f32(const DSP_DATA float32_t *src_a, const DSP_DATA float32_t *src_b,
187 : DSP_DATA float32_t *dst, uint32_t block_size);
188 :
189 : /**
190 : * @brief Q7 vector subtraction.
191 : *
192 : * @par Scaling and Overflow Behavior
193 : * The function uses saturating arithmetic.
194 : * Results outside of the allowable Q7 range [0x80 0x7F] will be saturated.
195 : *
196 : * @param[in] src_a points to the first input vector
197 : * @param[in] src_b points to the second input vector
198 : * @param[out] dst points to the output vector
199 : * @param[in] block_size number of samples in each vector
200 : */
201 1 : DSP_FUNC_SCOPE void zdsp_sub_q7(const DSP_DATA q7_t *src_a, const DSP_DATA q7_t *src_b,
202 : DSP_DATA q7_t *dst, uint32_t block_size);
203 :
204 : /**
205 : * @brief Q15 vector subtraction.
206 : *
207 : * @par Scaling and Overflow Behavior
208 : * The function uses saturating arithmetic.
209 : * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
210 : *
211 : * @param[in] src_a points to the first input vector
212 : * @param[in] src_b points to the second input vector
213 : * @param[out] dst points to the output vector
214 : * @param[in] block_size number of samples in each vector
215 : */
216 1 : DSP_FUNC_SCOPE void zdsp_sub_q15(const DSP_DATA q15_t *src_a, const DSP_DATA q15_t *src_b,
217 : DSP_DATA q15_t *dst, uint32_t block_size);
218 :
219 : /**
220 : * @brief Q31 vector subtraction.
221 : *
222 : * @par Scaling and Overflow Behavior
223 : * The function uses saturating arithmetic.
224 : * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.
225 : *
226 : * @param[in] src_a points to the first input vector
227 : * @param[in] src_b points to the second input vector
228 : * @param[out] dst points to the output vector
229 : * @param[in] block_size number of samples in each vector
230 : */
231 1 : DSP_FUNC_SCOPE void zdsp_sub_q31(const DSP_DATA q31_t *src_a, const DSP_DATA q31_t *src_b,
232 : DSP_DATA q31_t *dst, uint32_t block_size);
233 :
234 : /**
235 : * @}
236 : */
237 :
238 : /**
239 : * @ingroup math_dsp_basic
240 : * @addtogroup math_dsp_basic_scale Vector Scale
241 : *
242 : * Multiply a vector by a scalar value. For floating-point data, the algorithm used is:
243 : * <pre>
244 : * dst[n] = src[n] * scale, 0 <= n < block_size.
245 : * </pre>
246 : *
247 : * In the fixed-point Q7, Q15, and Q31 functions, scale is represented by a fractional
248 : * multiplication <code>scale_fract</code> and an arithmetic shift <code>shift</code>. The shift
249 : * allows the gain of the scaling operation to exceed 1.0. The algorithm used with fixed-point data
250 : * is:
251 : * <pre>
252 : * dst[n] = (src[n] * scale_fract) << shift, 0 <= n < block_size.
253 : * </pre>
254 : *
255 : * The overall scale factor applied to the fixed-point data is
256 : * <pre>
257 : * scale = scale_fract * 2^shift.
258 : * </pre>
259 : * The functions support in-place computation allowing the source and destination pointers to
260 : * reference the same memory buffer.
261 : * @{
262 : */
263 :
264 : /**
265 : * @brief Multiplies a floating-point vector by a scalar.
266 : * @param[in] src points to the input vector
267 : * @param[in] scale scale factor to be applied
268 : * @param[out] dst points to the output vector
269 : * @param[in] block_size number of samples in the vector
270 : */
271 1 : DSP_FUNC_SCOPE void zdsp_scale_f32(const DSP_DATA float32_t *src, float32_t scale,
272 : DSP_DATA float32_t *dst, uint32_t block_size);
273 :
274 : /**
275 : * @brief Multiplies a Q7 vector by a scalar.
276 : *
277 : * @par Scaling and Overflow Behavior
278 : * The input data <code>*src</code> and <code>scale_fract</code> are in 1.7 format.
279 : * These are multiplied to yield a 2.14 intermediate result and this is shifted with saturation to
280 : * 1.7 format.
281 : *
282 : * @param[in] src points to the input vector
283 : * @param[in] scale_fract fractional portion of the scale value
284 : * @param[in] shift number of bits to shift the result by
285 : * @param[out] dst points to the output vector
286 : * @param[in] block_size number of samples in the vector
287 : */
288 1 : DSP_FUNC_SCOPE void zdsp_scale_q7(const DSP_DATA q7_t *src, q7_t scale_fract, int8_t shift,
289 : DSP_DATA q7_t *dst, uint32_t block_size);
290 :
291 : /**
292 : * @brief Multiplies a Q15 vector by a scalar.
293 : *
294 : * @par Scaling and Overflow Behavior
295 : * The input data <code>*src</code> and <code>scale_fract</code> are in 1.15 format.
296 : * These are multiplied to yield a 2.30 intermediate result and this is shifted with saturation to
297 : * 1.15 format.
298 : *
299 : * @param[in] src points to the input vector
300 : * @param[in] scale_fract fractional portion of the scale value
301 : * @param[in] shift number of bits to shift the result by
302 : * @param[out] dst points to the output vector
303 : * @param[in] block_size number of samples in the vector
304 : */
305 1 : DSP_FUNC_SCOPE void zdsp_scale_q15(const DSP_DATA q15_t *src, q15_t scale_fract, int8_t shift,
306 : DSP_DATA q15_t *dst, uint32_t block_size);
307 :
308 : /**
309 : * @brief Multiplies a Q31 vector by a scalar.
310 : *
311 : * @par Scaling and Overflow Behavior
312 : * The input data <code>*src</code> and <code>scale_fract</code> are in 1.31 format.
313 : * These are multiplied to yield a 2.62 intermediate result and this is shifted with saturation to
314 : * 1.31 format.
315 : *
316 : * @param[in] src points to the input vector
317 : * @param[in] scale_fract fractional portion of the scale value
318 : * @param[in] shift number of bits to shift the result by
319 : * @param[out] dst points to the output vector
320 : * @param[in] block_size number of samples in the vector
321 : */
322 1 : DSP_FUNC_SCOPE void zdsp_scale_q31(const DSP_DATA q31_t *src, q31_t scale_fract, int8_t shift,
323 : DSP_DATA q31_t *dst, uint32_t block_size);
324 :
325 : /**
326 : * @}
327 : */
328 :
329 : /**
330 : * @ingroup math_dsp_basic
331 : * @addtogroup math_dsp_basic_abs Vector Absolute Value
332 : *
333 : * Computes the absolute value of a vector on an element-by-element basis.
334 : * <pre>
335 : * dst[n] = abs(src[n]), 0 <= n < block_size.
336 : * </pre>
337 : * The functions support in-place computation allowing the source and destination pointers to
338 : * reference the same memory buffer. There are separate functions for floating-point, Q7, Q15, and
339 : * Q31 data types.
340 : * @{
341 : */
342 :
343 : /**
344 : * @brief Floating-point vector absolute value.
345 : * @param[in] src points to the input buffer
346 : * @param[out] dst points to the output buffer
347 : * @param[in] block_size number of samples in each vector
348 : */
349 1 : DSP_FUNC_SCOPE void zdsp_abs_f32(const DSP_DATA float32_t *src, DSP_DATA float32_t *dst,
350 : uint32_t block_size);
351 :
352 : /**
353 : * @brief Q7 vector absolute value.
354 : *
355 : * @par Scaling and Overflow Behavior
356 : * The function uses saturating arithmetic.
357 : * The Q7 value -1 (0x80) will be saturated to the maximum allowable positive value 0x7F.
358 : *
359 : * @param[in] src points to the input buffer
360 : * @param[out] dst points to the output buffer
361 : * @param[in] block_size number of samples in each vector
362 : */
363 1 : DSP_FUNC_SCOPE void zdsp_abs_q7(const DSP_DATA q7_t *src, DSP_DATA q7_t *dst, uint32_t block_size);
364 :
365 : /**
366 : * @brief Q15 vector absolute value.
367 : *
368 : * @par Scaling and Overflow Behavior
369 : * The function uses saturating arithmetic.
370 : * The Q15 value -1 (0x8000) will be saturated to the maximum allowable positive value 0x7FFF.
371 : *
372 : * @param[in] src points to the input buffer
373 : * @param[out] dst points to the output buffer
374 : * @param[in] block_size number of samples in each vector
375 : */
376 1 : DSP_FUNC_SCOPE void zdsp_abs_q15(const DSP_DATA q15_t *src, DSP_DATA q15_t *dst,
377 : uint32_t block_size);
378 :
379 : /**
380 : * @brief Q31 vector absolute value.
381 : *
382 : * @par Scaling and Overflow Behavior
383 : * The function uses saturating arithmetic.
384 : * The Q31 value -1 (0x80000000) will be saturated to the maximum allowable positive value
385 : * 0x7FFFFFFF.
386 : *
387 : * @param[in] src points to the input buffer
388 : * @param[out] dst points to the output buffer
389 : * @param[in] block_size number of samples in each vector
390 : */
391 1 : DSP_FUNC_SCOPE void zdsp_abs_q31(const DSP_DATA q31_t *src, DSP_DATA q31_t *dst,
392 : uint32_t block_size);
393 :
394 : /**
395 : * @}
396 : */
397 :
398 : /**
399 : * @ingroup math_dsp_basic
400 : * @addtogroup math_dsp_basic_dot Vector Dot Product
401 : *
402 : * Computes the dot product of two vectors. The vectors are multiplied element-by-element and then
403 : * summed.
404 : * <pre>
405 : * sum = src_a[0]*src_b[0] + src_a[1]*src_b[1] + ... + src_a[block_size-1]*src_b[block_size-1]
406 : * </pre>
407 : * There are separate functions for floating-point, Q7, Q15, and Q31 data types.
408 : * @{
409 : */
410 :
411 : /**
412 : * @brief Dot product of floating-point vectors.
413 : * @param[in] src_a points to the first input vector
414 : * @param[in] src_b points to the second input vector
415 : * @param[in] block_size number of samples in each vector
416 : * @param[out] result output result returned here
417 : */
418 1 : DSP_FUNC_SCOPE void zdsp_dot_prod_f32(const DSP_DATA float32_t *src_a,
419 : const DSP_DATA float32_t *src_b, uint32_t block_size,
420 : DSP_DATA float32_t *result);
421 :
422 : /**
423 : * @brief Dot product of Q7 vectors.
424 : *
425 : * @par Scaling and Overflow Behavior
426 : * The intermediate multiplications are in 1.7 x 1.7 = 2.14 format and these results are added to
427 : * an accumulator in 18.14 format. Nonsaturating additions are used and there is no danger of wrap
428 : * around as long as the vectors are less than 2^18 elements long. The return result is in 18.14
429 : * format.
430 : *
431 : * @param[in] src_a points to the first input vector
432 : * @param[in] src_b points to the second input vector
433 : * @param[in] block_size number of samples in each vector
434 : * @param[out] result output result returned here
435 : */
436 1 : DSP_FUNC_SCOPE void zdsp_dot_prod_q7(const DSP_DATA q7_t *src_a, const DSP_DATA q7_t *src_b,
437 : uint32_t block_size, DSP_DATA q31_t *result);
438 :
439 : /**
440 : * @brief Dot product of Q15 vectors.
441 : *
442 : * @par Scaling and Overflow Behavior
443 : * The intermediate multiplications are in 1.15 x 1.15 = 2.30 format and these results are added
444 : * to a 64-bit accumulator in 34.30 format. Nonsaturating additions are used and given that there
445 : * are 33 guard bits in the accumulator there is no risk of overflow. The return result is in
446 : * 34.30 format.
447 : *
448 : * @param[in] src_a points to the first input vector
449 : * @param[in] src_b points to the second input vector
450 : * @param[in] block_size number of samples in each vector
451 : * @param[out] result output result returned here
452 : */
453 1 : DSP_FUNC_SCOPE void zdsp_dot_prod_q15(const DSP_DATA q15_t *src_a, const DSP_DATA q15_t *src_b,
454 : uint32_t block_size, DSP_DATA q63_t *result);
455 :
456 : /**
457 : * @brief Dot product of Q31 vectors.
458 : *
459 : * @par Scaling and Overflow Behavior
460 : * The intermediate multiplications are in 1.31 x 1.31 = 2.62 format and these are truncated to
461 : * 2.48 format by discarding the lower 14 bits. The 2.48 result is then added without saturation
462 : * to a 64-bit accumulator in 16.48 format. There are 15 guard bits in the accumulator and there
463 : * is no risk of overflow as long as the length of the vectors is less than 2^16 elements. The
464 : * return result is in 16.48 format.
465 : *
466 : * @param[in] src_a points to the first input vector
467 : * @param[in] src_b points to the second input vector
468 : * @param[in] block_size number of samples in each vector
469 : * @param[out] result output result returned here
470 : */
471 1 : DSP_FUNC_SCOPE void zdsp_dot_prod_q31(const DSP_DATA q31_t *src_a, const DSP_DATA q31_t *src_b,
472 : uint32_t block_size, DSP_DATA q63_t *result);
473 :
474 : /**
475 : * @}
476 : */
477 :
478 : /**
479 : * @ingroup math_dsp_basic
480 : * @addtogroup math_dsp_basic_shift Vector Shift
481 : *
482 : * Shifts the elements of a fixed-point vector by a specified number of bits.
483 : * There are separate functions for Q7, Q15, and Q31 data types. The underlying algorithm used is:
484 : * <pre>
485 : * dst[n] = src[n] << shift, 0 <= n < block_size.
486 : * </pre>
487 : * If <code>shift</code> is positive then the elements of the vector are shifted to the left.
488 : * If <code>shift</code> is negative then the elements of the vector are shifted to the right.
489 : *
490 : * The functions support in-place computation allowing the source and destination pointers to
491 : * reference the same memory buffer.
492 : * @{
493 : */
494 :
495 : /**
496 : * @brief Shifts the elements of a Q7 vector a specified number of bits.
497 : *
498 : * @par Scaling and Overflow Behavior
499 : * The function uses saturating arithmetic.
500 : * Results outside of the allowable Q7 range [0x80 0x7F] are saturated.
501 : *
502 : * @param[in] src points to the input vector
503 : * @param[in] shift_bits number of bits to shift. A positive value shifts left; a negative value
504 : * shifts right.
505 : * @param[out] dst points to the output vector
506 : * @param[in] block_size number of samples in the vector
507 : */
508 1 : DSP_FUNC_SCOPE void zdsp_shift_q7(const DSP_DATA q7_t *src, int8_t shift_bits, DSP_DATA q7_t *dst,
509 : uint32_t block_size);
510 :
511 : /**
512 : * @brief Shifts the elements of a Q15 vector a specified number of bits.
513 : *
514 : * @pre Scaling and Overflow Behavior
515 : * The function uses saturating arithmetic.
516 : * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
517 : *
518 : * @param[in] src points to the input vector
519 : * @param[in] shift_bits number of bits to shift. A positive value shifts left; a negative value
520 : * shifts right.
521 : * @param[out] dst points to the output vector
522 : * @param[in] block_size number of samples in the vector
523 : */
524 1 : DSP_FUNC_SCOPE void zdsp_shift_q15(const DSP_DATA q15_t *src, int8_t shift_bits,
525 : DSP_DATA q15_t *dst, uint32_t block_size);
526 :
527 : /**
528 : * @brief Shifts the elements of a Q31 vector a specified number of bits.
529 : *
530 : * @par Scaling and Overflow Behavior
531 : * The function uses saturating arithmetic.
532 : * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.
533 : *
534 : * @param[in] src points to the input vector
535 : * @param[in] shift_bits number of bits to shift. A positive value shifts left; a negative value
536 : * shifts right.
537 : * @param[out] dst points to the output vector
538 : * @param[in] block_size number of samples in the vector
539 : */
540 1 : DSP_FUNC_SCOPE void zdsp_shift_q31(const DSP_DATA q31_t *src, int8_t shift_bits,
541 : DSP_DATA q31_t *dst, uint32_t block_size);
542 :
543 : /**
544 : * @}
545 : */
546 :
547 : /**
548 : * @ingroup math_dsp_basic
549 : * @addtogroup math_dsp_basic_offset Vector Offset
550 : *
551 : * Adds a constant offset to each element of a vector.
552 : * <pre>
553 : * dst[n] = src[n] + offset, 0 <= n < block_size.
554 : * </pre>
555 : * The functions support in-place computation allowing the source and destination pointers to
556 : * reference the same memory buffer. There are separate functions for floating-point, Q7, Q15, and
557 : * Q31 data types.
558 : *
559 : * @{
560 : */
561 :
562 : /**
563 : * @brief Adds a constant offset to a floating-point vector.
564 : * @param[in] src points to the input vector
565 : * @param[in] offset is the offset to be added
566 : * @param[out] dst points to the output vector
567 : * @param[in] block_size number of samples in the vector
568 : */
569 1 : DSP_FUNC_SCOPE void zdsp_offset_f32(const DSP_DATA float32_t *src, float32_t offset,
570 : DSP_DATA float32_t *dst, uint32_t block_size);
571 :
572 : /**
573 : * @brief Adds a constant offset to a Q7 vector.
574 : *
575 : * @par Scaling and Overflow Behavior
576 : * The function uses saturating arithmetic.
577 : * Results outside of the allowable Q7 range [0x80 0x7F] are saturated.
578 : *
579 : * @param[in] src points to the input vector
580 : * @param[in] offset is the offset to be added
581 : * @param[out] dst points to the output vector
582 : * @param[in] block_size number of samples in the vector
583 : */
584 1 : DSP_FUNC_SCOPE void zdsp_offset_q7(const DSP_DATA q7_t *src, q7_t offset, DSP_DATA q7_t *dst,
585 : uint32_t block_size);
586 :
587 : /**
588 : * @brief Adds a constant offset to a Q15 vector.
589 : *
590 : * @par Scaling and Overflow Behavior
591 : * The function uses saturating arithmetic.
592 : * Results outside of the allowable Q15 range [0x8000 0x7FFF] are saturated.
593 : *
594 : * @param[in] src points to the input vector
595 : * @param[in] offset is the offset to be added
596 : * @param[out] dst points to the output vector
597 : * @param[in] block_size number of samples in the vector
598 : */
599 1 : DSP_FUNC_SCOPE void zdsp_offset_q15(const DSP_DATA q15_t *src, q15_t offset, DSP_DATA q15_t *dst,
600 : uint32_t block_size);
601 :
602 : /**
603 : * @brief Adds a constant offset to a Q31 vector.
604 : *
605 : * @par Scaling and Overflow Behavior
606 : * The function uses saturating arithmetic.
607 : * Results outside of the allowable Q31 range [0x80000000 0x7FFFFFFF] are saturated.
608 : *
609 : * @param[in] src points to the input vector
610 : * @param[in] offset is the offset to be added
611 : * @param[out] dst points to the output vector
612 : * @param[in] block_size number of samples in the vector
613 : */
614 1 : DSP_FUNC_SCOPE void zdsp_offset_q31(const DSP_DATA q31_t *src, q31_t offset, DSP_DATA q31_t *dst,
615 : uint32_t block_size);
616 :
617 : /**
618 : * @}
619 : */
620 :
621 : /**
622 : * @ingroup math_dsp_basic
623 : * @addtogroup math_dsp_basic_negate Vector Negate
624 : *
625 : * Negates the elements of a vector.
626 : * <pre>
627 : * dst[n] = -src[n], 0 <= n < block_size.
628 : * </pre>
629 : * The functions support in-place computation allowing the source and destination pointers to
630 : * reference the same memory buffer. There are separate functions for floating-point, Q7, Q15, and
631 : * Q31 data types.
632 : *
633 : * @{
634 : */
635 :
636 : /**
637 : * @brief Negates the elements of a floating-point vector.
638 : * @param[in] src points to the input vector
639 : * @param[out] dst points to the output vector
640 : * @param[in] block_size number of samples in the vector
641 : */
642 1 : DSP_FUNC_SCOPE void zdsp_negate_f32(const DSP_DATA float32_t *src, DSP_DATA float32_t *dst,
643 : uint32_t block_size);
644 :
645 : /**
646 : * @brief Negates the elements of a Q7 vector.
647 : *
648 : * @par Scaling and Overflow Behavior
649 : * The function uses saturating arithmetic.
650 : * The Q7 value -1 (0x80) is saturated to the maximum allowable positive value 0x7F.
651 : *
652 : * @param[in] src points to the input vector
653 : * @param[out] dst points to the output vector
654 : * @param[in] block_size number of samples in the vector
655 : */
656 1 : DSP_FUNC_SCOPE void zdsp_negate_q7(const DSP_DATA q7_t *src, DSP_DATA q7_t *dst,
657 : uint32_t block_size);
658 :
659 : /**
660 : * @brief Negates the elements of a Q15 vector.
661 : *
662 : * @par Scaling and Overflow Behavior
663 : * The function uses saturating arithmetic.
664 : * The Q15 value -1 (0x8000) is saturated to the maximum allowable positive value 0x7FFF.
665 : *
666 : * @param[in] src points to the input vector
667 : * @param[out] dst points to the output vector
668 : * @param[in] block_size number of samples in the vector
669 : */
670 1 : DSP_FUNC_SCOPE void zdsp_negate_q15(const DSP_DATA q15_t *src, DSP_DATA q15_t *dst,
671 : uint32_t block_size);
672 :
673 : /**
674 : * @brief Negates the elements of a Q31 vector.
675 : *
676 : * @par Scaling and Overflow Behavior
677 : * The function uses saturating arithmetic.
678 : * The Q31 value -1 (0x80000000) is saturated to the maximum allowable positive value 0x7FFFFFFF.
679 : *
680 : * @param[in] src points to the input vector
681 : * @param[out] dst points to the output vector
682 : * @param[in] block_size number of samples in the vector
683 : */
684 1 : DSP_FUNC_SCOPE void zdsp_negate_q31(const DSP_DATA q31_t *src, DSP_DATA q31_t *dst,
685 : uint32_t block_size);
686 :
687 : /**
688 : * @}
689 : */
690 :
691 : /**
692 : * @ingroup math_dsp_basic
693 : * @addtogroup math_dsp_basic_and Vector bitwise AND
694 : *
695 : * Compute the logical bitwise AND.
696 : *
697 : * There are separate functions for uint32_t, uint16_t, and uint7_t data types.
698 : * @{
699 : */
700 :
701 : /**
702 : * @brief Compute the logical bitwise AND of two fixed-point vectors.
703 : * @param[in] src_a points to input vector A
704 : * @param[in] src_b points to input vector B
705 : * @param[out] dst points to output vector
706 : * @param[in] block_size number of samples in each vector
707 : */
708 1 : DSP_FUNC_SCOPE void zdsp_and_u8(const DSP_DATA uint8_t *src_a, const DSP_DATA uint8_t *src_b,
709 : DSP_DATA uint8_t *dst, uint32_t block_size);
710 :
711 : /**
712 : * @brief Compute the logical bitwise AND of two fixed-point vectors.
713 : * @param[in] src_a points to input vector A
714 : * @param[in] src_b points to input vector B
715 : * @param[out] dst points to output vector
716 : * @param[in] block_size number of samples in each vector
717 : */
718 1 : DSP_FUNC_SCOPE void zdsp_and_u16(const DSP_DATA uint16_t *src_a, const DSP_DATA uint16_t *src_b,
719 : DSP_DATA uint16_t *dst, uint32_t block_size);
720 :
721 : /**
722 : * @brief Compute the logical bitwise AND of two fixed-point vectors.
723 : * @param[in] src_a points to input vector A
724 : * @param[in] src_b points to input vector B
725 : * @param[out] dst points to output vector
726 : * @param[in] block_size number of samples in each vector
727 : */
728 1 : DSP_FUNC_SCOPE void zdsp_and_u32(const DSP_DATA uint32_t *src_a, const DSP_DATA uint32_t *src_b,
729 : DSP_DATA uint32_t *dst, uint32_t block_size);
730 :
731 : /**
732 : * @}
733 : */
734 :
735 : /**
736 : * @ingroup math_dsp_basic
737 : * @addtogroup math_dsp_basic_or Vector bitwise OR
738 : *
739 : * Compute the logical bitwise OR.
740 : *
741 : * There are separate functions for uint32_t, uint16_t, and uint7_t data types.
742 : * @{
743 : */
744 :
745 : /**
746 : * @brief Compute the logical bitwise OR of two fixed-point vectors.
747 : * @param[in] src_a points to input vector A
748 : * @param[in] src_b points to input vector B
749 : * @param[out] dst points to output vector
750 : * @param[in] block_size number of samples in each vector
751 : */
752 1 : DSP_FUNC_SCOPE void zdsp_or_u8(const DSP_DATA uint8_t *src_a, const DSP_DATA uint8_t *src_b,
753 : DSP_DATA uint8_t *dst, uint32_t block_size);
754 :
755 : /**
756 : * @brief Compute the logical bitwise OR of two fixed-point vectors.
757 : * @param[in] src_a points to input vector A
758 : * @param[in] src_b points to input vector B
759 : * @param[out] dst points to output vector
760 : * @param[in] block_size number of samples in each vector
761 : */
762 1 : DSP_FUNC_SCOPE void zdsp_or_u16(const DSP_DATA uint16_t *src_a, const DSP_DATA uint16_t *src_b,
763 : DSP_DATA uint16_t *dst, uint32_t block_size);
764 :
765 : /**
766 : * @brief Compute the logical bitwise OR of two fixed-point vectors.
767 : * @param[in] src_a points to input vector A
768 : * @param[in] src_b points to input vector B
769 : * @param[out] dst points to output vector
770 : * @param[in] block_size number of samples in each vector
771 : */
772 1 : DSP_FUNC_SCOPE void zdsp_or_u32(const DSP_DATA uint32_t *src_a, const DSP_DATA uint32_t *src_b,
773 : DSP_DATA uint32_t *dst, uint32_t block_size);
774 :
775 : /**
776 : * @}
777 : */
778 :
779 : /**
780 : * @ingroup math_dsp_basic
781 : * @addtogroup math_dsp_basic_not Vector bitwise NOT
782 : *
783 : * Compute the logical bitwise NOT.
784 : *
785 : * There are separate functions for uint32_t, uint16_t, and uint7_t data types.
786 : * @{
787 : */
788 :
789 : /**
790 : * @brief Compute the logical bitwise NOT of a fixed-point vector.
791 : * @param[in] src points to input vector
792 : * @param[out] dst points to output vector
793 : * @param[in] block_size number of samples in each vector
794 : */
795 1 : DSP_FUNC_SCOPE void zdsp_not_u8(const DSP_DATA uint8_t *src, DSP_DATA uint8_t *dst,
796 : uint32_t block_size);
797 :
798 : /**
799 : * @brief Compute the logical bitwise NOT of a fixed-point vector.
800 : * @param[in] src points to input vector
801 : * @param[out] dst points to output vector
802 : * @param[in] block_size number of samples in each vector
803 : */
804 1 : DSP_FUNC_SCOPE void zdsp_not_u16(const DSP_DATA uint16_t *src, DSP_DATA uint16_t *dst,
805 : uint32_t block_size);
806 :
807 : /**
808 : * @brief Compute the logical bitwise NOT of a fixed-point vector.
809 : * @param[in] src points to input vector
810 : * @param[out] dst points to output vector
811 : * @param[in] block_size number of samples in each vector
812 : */
813 1 : DSP_FUNC_SCOPE void zdsp_not_u32(const DSP_DATA uint32_t *src, DSP_DATA uint32_t *dst,
814 : uint32_t block_size);
815 :
816 : /**
817 : * @}
818 : */
819 :
820 : /**
821 : * @ingroup math_dsp_basic
822 : * @addtogroup math_dsp_basic_xor Vector bitwise XOR
823 : *
824 : * Compute the logical bitwise XOR.
825 : *
826 : * There are separate functions for uint32_t, uint16_t, and uint7_t data types.
827 : * @{
828 : */
829 :
830 : /**
831 : * @brief Compute the logical bitwise XOR of two fixed-point vectors.
832 : * @param[in] src_a points to input vector A
833 : * @param[in] src_b points to input vector B
834 : * @param[out] dst points to output vector
835 : * @param[in] block_size number of samples in each vector
836 : */
837 1 : DSP_FUNC_SCOPE void zdsp_xor_u8(const DSP_DATA uint8_t *src_a, const DSP_DATA uint8_t *src_b,
838 : DSP_DATA uint8_t *dst, uint32_t block_size);
839 :
840 : /**
841 : * @brief Compute the logical bitwise XOR of two fixed-point vectors.
842 : * @param[in] src_a points to input vector A
843 : * @param[in] src_b points to input vector B
844 : * @param[out] dst points to output vector
845 : * @param[in] block_size number of samples in each vector
846 : */
847 1 : DSP_FUNC_SCOPE void zdsp_xor_u16(const DSP_DATA uint16_t *src_a, const DSP_DATA uint16_t *src_b,
848 : DSP_DATA uint16_t *dst, uint32_t block_size);
849 :
850 : /**
851 : * @brief Compute the logical bitwise XOR of two fixed-point vectors.
852 : * @param[in] src_a points to input vector A
853 : * @param[in] src_b points to input vector B
854 : * @param[out] dst points to output vector
855 : * @param[in] block_size number of samples in each vector
856 : */
857 1 : DSP_FUNC_SCOPE void zdsp_xor_u32(const DSP_DATA uint32_t *src_a, const DSP_DATA uint32_t *src_b,
858 : DSP_DATA uint32_t *dst, uint32_t block_size);
859 :
860 : /**
861 : * @}
862 : */
863 :
864 : /**
865 : * @ingroup math_dsp_basic
866 : * @addtogroup math_dsp_basic_clip Vector Clipping
867 : *
868 : * Element-by-element clipping of a value.
869 : *
870 : * The value is constrained between 2 bounds.
871 : *
872 : * There are separate functions for floating-point, Q7, Q15, and Q31 data types.
873 : * @{
874 : */
875 :
876 : /**
877 : * @brief Elementwise floating-point clipping
878 : * @param[in] src points to input values
879 : * @param[out] dst points to output clipped values
880 : * @param[in] low lower bound
881 : * @param[in] high higher bound
882 : * @param[in] num_samples number of samples to clip
883 : */
884 1 : DSP_FUNC_SCOPE void zdsp_clip_f32(const DSP_DATA float32_t *src, DSP_DATA float32_t *dst,
885 : float32_t low, float32_t high, uint32_t num_samples);
886 :
887 : /**
888 : * @brief Elementwise fixed-point clipping
889 : * @param[in] src points to input values
890 : * @param[out] dst points to output clipped values
891 : * @param[in] low lower bound
892 : * @param[in] high higher bound
893 : * @param[in] num_samples number of samples to clip
894 : */
895 1 : DSP_FUNC_SCOPE void zdsp_clip_q31(const DSP_DATA q31_t *src, DSP_DATA q31_t *dst, q31_t low,
896 : q31_t high, uint32_t num_samples);
897 :
898 : /**
899 : * @brief Elementwise fixed-point clipping
900 : * @param[in] src points to input values
901 : * @param[out] dst points to output clipped values
902 : * @param[in] low lower bound
903 : * @param[in] high higher bound
904 : * @param[in] num_samples number of samples to clip
905 : */
906 1 : DSP_FUNC_SCOPE void zdsp_clip_q15(const DSP_DATA q15_t *src, DSP_DATA q15_t *dst, q15_t low,
907 : q15_t high, uint32_t num_samples);
908 :
909 : /**
910 : * @brief Elementwise fixed-point clipping
911 : * @param[in] src points to input values
912 : * @param[out] dst points to output clipped values
913 : * @param[in] low lower bound
914 : * @param[in] high higher bound
915 : * @param[in] num_samples number of samples to clip
916 : */
917 1 : DSP_FUNC_SCOPE void zdsp_clip_q7(const DSP_DATA q7_t *src, DSP_DATA q7_t *dst, q7_t low, q7_t high,
918 : uint32_t num_samples);
919 :
920 : /**
921 : * @}
922 : */
923 :
924 : #ifdef __cplusplus
925 : }
926 : #endif
927 :
928 : #ifdef CONFIG_FP16
929 : #include <zephyr/dsp/basicmath_f16.h>
930 : #endif /* CONFIG_FP16 */
931 :
932 : #endif /* ZEPHYR_INCLUDE_DSP_BASICMATH_H_ */
|
