diff options
Diffstat (limited to 'arm_compute/core/NEON/NEFixedPoint.h')
| -rw-r--r-- | arm_compute/core/NEON/NEFixedPoint.h | 686 |
1 files changed, 686 insertions, 0 deletions
diff --git a/arm_compute/core/NEON/NEFixedPoint.h b/arm_compute/core/NEON/NEFixedPoint.h new file mode 100644 index 0000000000..fb712611cb --- /dev/null +++ b/arm_compute/core/NEON/NEFixedPoint.h @@ -0,0 +1,686 @@ +/* + * Copyright (c) 2017 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef __ARM_COMPUTE_NEFIXEDPOINT_H__ +#define __ARM_COMPUTE_NEFIXEDPOINT_H__ + +#include "arm_compute/core/FixedPoint.h" + +#include <arm_neon.h> + +namespace arm_compute +{ +using qint8x8_t = int8x8_t; /**< 8 bit fixed point vector with 8 elements */ +using qint8x8x2_t = int8x8x2_t; /**< 8 bit fixed point vector with 16 elements */ +using qint8x8x3_t = int8x8x3_t; /**< 8 bit fixed point vector with 24 elements */ +using qint8x8x4_t = int8x8x4_t; /**< 8 bit fixed point vector with 32 elements */ +using qint8x16_t = int8x16_t; /**< 8 bit fixed point vector with 16 elements */ +using qint8x16x2_t = int8x16x2_t; /**< 8 bit fixed point vector with 32 elements */ +using qint8x16x3_t = int8x16x3_t; /**< 8 bit fixed point vector with 48 elements */ +using qint8x16x4_t = int8x16x4_t; /**< 8 bit fixed point vector with 64 elements */ +using qint16x4_t = int16x4_t; /**< 16 bit fixed point vector with 4 elements */ +using qint16x4x2_t = int16x4x2_t; /**< 16 bit fixed point vector with 8 elements */ +using qint16x4x3_t = int16x4x3_t; /**< 16 bit fixed point vector with 12 elements */ +using qint16x4x4_t = int16x4x4_t; /**< 16 bit fixed point vector with 16 elements */ +using qint16x8_t = int16x8_t; /**< 16 bit fixed point vector with 8 elements */ +using qint16x8x2_t = int16x8x2_t; /**< 16 bit fixed point vector with 16 elements */ +using qint16x8x3_t = int16x8x3_t; /**< 16 bit fixed point vector with 24 elements */ +using qint16x8x4_t = int16x8x4_t; /**< 16 bit fixed point vector with 32 elements */ + +/** Get the lower half of a 16 elements vector + * + * @param[in] a vector of 16 elements + * + * @return 8 bit fixed point vector (8 elements) + */ +qint8x8_t vget_low_qs8(qint8x16_t a); + +/** Get the higher half of a 16 elements vector + * + * @param[in] a vector of 16 elements + * + * @return 8 bit fixed point vector (8 elements) + */ +qint8x8_t vget_high_qs8(qint8x16_t a); + +/** Load a single 8 bit fixed point vector from memory (8 elements) + * + * @param[in] addr Memory address of the 8 bit fixed point vector to load + * + * @return 8 bit fixed point vector (8 elements) + */ +qint8x8_t vld1_qs8(const qint8_t *addr); + +/** Load a single 8 bit fixed point vector from memory (16 elements) + * + * @param[in] addr Memory address of the 8 bit fixed point vector to load + * + * @return 8 bit fixed point vector (16 elements) + */ +qint8x16_t vld1q_qs8(const qint8_t *addr); + +/** Load a single 16 bit fixed point vector from memory (4 elements) + * + * @param[in] addr Memory address of the 16 bit fixed point vector to load + * + * @return 16 bit fixed point vector (4 elements) + */ +qint16x4_t vld1_qs16(const qint16_t *addr); + +/** Load a single 16 bit fixed point vector from memory (8 elements) + * + * @param[in] addr Memory address of the 16 bit fixed point vector to load + * + * @return 16 bit fixed point vector (8 elements) + */ +qint16x8_t vld1q_qs16(const qint16_t *addr); + +/** Load all lanes of 8 bit fixed point vector with same value from memory (8 elements) + * + * @param[in] addr Memory address of the 8 bit fixed point scalar value to load + * + * @return 8 bit fixed point vector (8 elements) + */ +qint8x8_t vld1_dup_qs8(const qint8_t *addr); + +/** Load all lanes of 8 bit fixed point vector with same value from memory (16 elements) + * + * @param[in] addr Memory address of the 8 bit fixed point scalar value to load + * + * @return 8 bit fixed point vector (16 elements) + */ +qint8x16_t vld1q_dup_qs8(const qint8_t *addr); + +/** Store a single 8 bit fixed point vector to memory (8 elements) + * + * @param[in] addr Memory address where the 8 bit fixed point vector should be stored + * @param[in] b 8 bit fixed point vector to store + * + */ +void vst1_qs8(qint8_t *addr, qint8x8_t b); + +/** Store a single 8 bit fixed point vector to memory (16 elements) + * + * @param[in] addr Memory address where the 8 bit fixed point vector should be stored + * @param[in] b 8 bit fixed point vector to store + * + */ +void vst1q_qs8(qint8_t *addr, qint8x16_t b); + +/** Store a single 16 bit fixed point vector to memory (4 elements) + * + * @param[in] addr Memory address where the 16 bit fixed point vector should be stored + * @param[in] b 16 bit fixed point vector to store + * + */ +void vst1_qs16(qint16_t *addr, qint16x4_t b); + +/** Store a single 8 bit fixed point vector to memory (16 elements) + * + * @param[in] addr Memory address where the 16 bit fixed point vector should be stored + * @param[in] b 16 bit fixed point vector to store + * + */ +void vst1q_qs16(qint16_t *addr, qint16x8_t b); + +/** 16 bit fixed point vector saturating narrow (8 elements) + * + * @param[in] a 16 bit fixed point vector to convert + * + * @return 8 bit fixed point vector + */ +qint8x8_t vqmovn_q16(qint16x8_t a); + +/** 8 bit fixed point vector duplicate (8 elements) + * + * @param[in] a 8 bit fixed point to duplicate + * + * @return The result of the vector duplication + */ +qint8x8_t vdup_n_qs8(qint8_t a); + +/** 8 bit fixed point vector duplicate (16 elements) + * + * @param[in] a 8 bit fixed point to duplicate + * + * @return The result of the vector duplication + */ +qint8x16_t vdupq_n_qs8(qint8_t a); + +/** Duplicate a float and convert it to 8 bit fixed point vector (16 elements) + * + * @param[in] a 8 bit fixed point to duplicate + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the vector duplication + */ +qint8x16_t vdupq_n_qs8_f32(float a, int fixed_point_position); + +/** 16 bit fixed point vector duplicate (8 elements) + * + * @param[in] a 16 bit fixed point to duplicate + * + * @return The result of the vector duplication + */ +qint16x8_t vdupq_n_qs16(qint16x8_t a); + +/** Absolute value of 8 bit fixed point vector (8 elements) + * + * @param[in] a 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector absolute value + */ +qint8x8_t vabs_qs8(qint8x8_t a); + +/** Absolute value of 8 bit fixed point vector (16 elements) + * + * @param[in] a 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector absolute value + */ +qint8x16_t vabsq_qs8(qint8x16_t a); + +/** Saturating absolute value of 8 bit fixed point vector (8 elements) + * + * @param[in] a 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector absolute value + */ +qint8x8_t vqabs_qs8(qint8x8_t a); + +/** Saturating absolute value of 8 bit fixed point vector (16 elements) + * + * @param[in] a 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector absolute value + */ +qint8x16_t vqabsq_qs8(qint8x16_t a); + +/** 8 bit fixed point vector max (8 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector max operation + */ +qint8x8_t vmax_qs8(qint8x8_t a, qint8x8_t b); + +/** 8 bit fixed point vector max (16 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector max operation + */ +qint8x16_t vmaxq_qs8(qint8x16_t a, qint8x16_t b); + +/** 8 bit fixed point vector pairwise max (8 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector pairwise max operation + */ +qint8x8_t vpmax_qs8(qint8x8_t a, qint8x8_t b); + +/** 8 bit fixed point vector min (8 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector max operation + */ +qint8x8_t vmin_qs8(qint8x8_t a, qint8x8_t b); + +/** 8 bit fixed point vector min (16 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector min operation + */ +qint8x16_t vminq_qs8(qint8x16_t a, qint8x16_t b); + +/** 8 bit fixed point vector pairwise min (8 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector pairwise min operation + */ +qint8x8_t vpmin_qs8(qint8x8_t a, qint8x8_t b); + +/** 8 bit fixed point vector add (8 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector addition + */ +qint8x8_t vadd_qs8(qint8x8_t a, qint8x8_t b); + +/** 8 bit fixed point vector add (16 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector addition + */ +qint8x16_t vaddq_qs8(qint8x16_t a, qint8x16_t b); + +/** 8 bit fixed point vector saturating add (8 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector addition. The result is saturated in case of overflow + */ +qint8x8_t vqadd_qs8(qint8x8_t a, qint8x8_t b); + +/** 8 bit fixed point vector saturating add (16 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector addition. The result is saturated in case of overflow + */ +qint8x16_t vqaddq_qs8(qint8x16_t a, qint8x16_t b); + +/** 16 bit fixed point vector saturating add (4 elements) + * + * @param[in] a First 16 bit fixed point input vector + * @param[in] b Second 16 bit fixed point input vector + * + * @return The result of the 16 bit fixed point vector addition. The result is saturated in case of overflow + */ +qint16x4_t vqadd_qs16(qint16x4_t a, qint16x4_t b); + +/** 16 bit fixed point vector saturating add (8 elements) + * + * @param[in] a First 16 bit fixed point input vector + * @param[in] b Second 16 bit fixed point input vector + * + * @return The result of the 16 bit fixed point vector addition. The result is saturated in case of overflow + */ +qint16x8_t vqaddq_qs16(qint16x8_t a, qint16x8_t b); + +/** 8 bit fixed point vector saturating pairwise add (8 elements) + * + * @param[in] a 8 bit fixed point input vector + * + * @return The result of the 16 bit fixed point vector addition. The result is saturated in case of overflow + */ +int16x4_t vpaddl_qs8(qint8x8_t a); + +/** 8 bit fixed point vector subtraction (8 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector subtraction + */ +qint8x8_t vsub_qs8(qint8x8_t a, qint8x8_t b); + +/** 8 bit fixed point vector subtraction (16 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector subtraction + */ +qint8x16_t vsubq_qs8(qint8x16_t a, qint8x16_t b); + +/** 8 bit fixed point vector saturating subtraction (8 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector subtraction. The result is saturated in case of overflow + */ +qint8x8_t vqsub_qs8(qint8x8_t a, qint8x8_t b); + +/** 8 bit fixed point vector saturating subtraction (16 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * + * @return The result of the 8 bit fixed point vector subtraction. The result is saturated in case of overflow + */ +qint8x16_t vqsubq_qs8(qint8x16_t a, qint8x16_t b); + +/** 8 bit fixed point vector multiply (8 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8 bit fixed point vector multiplication. + */ +qint8x8_t vmul_qs8(qint8x8_t a, qint8x8_t b, int fixed_point_position); + +/** 8 bit fixed point vector multiply (16 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8 bit fixed point vector multiplication. + */ +qint8x16_t vmulq_qs8(qint8x16_t a, qint8x16_t b, int fixed_point_position); + +/** 8 bit fixed point vector saturating multiply (8 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8 bit fixed point vector multiplication. The result is saturated in case of overflow + */ +qint8x8_t vqmul_qs8(qint8x8_t a, qint8x8_t b, int fixed_point_position); + +/** 8 bit fixed point vector saturating multiply (16 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8 bit fixed point vector multiplication. The result is saturated in case of overflow + */ +qint8x16_t vqmulq_qs8(qint8x16_t a, qint8x16_t b, int fixed_point_position); + +/** 8 bit fixed point vector long multiply (8 elements) + * + * @param[in] a First 8 bit fixed point input vector + * @param[in] b Second 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8 bit fixed point long vector multiplication. + */ +qint16x8_t vmull_qs8(qint8x8_t a, qint8x8_t b, int fixed_point_position); + +/** 8 bit fixed point vector multiply-accumulate (8 elements). This operation performs the product between @p b and @p c and add the result to @p a (a + b * c). + * + * @param[in] a First 8 bit fixed point input vector where the result of multiplication must be added to + * @param[in] b Second 8 bit fixed point input vector + * @param[in] c Third 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8 bit fixed point vector multiply-accumulate + */ +qint8x8_t vmla_qs8(qint8x8_t a, qint8x8_t b, qint8x8_t c, int fixed_point_position); + +/** 8 bit fixed point vector multiply-accumulate (16 elements). This operation performs the product between @p b and @p c and add the result to @p a (a + b * c). + * + * @param[in] a First 8 bit fixed point input vector where the result of multiplication must be added to + * @param[in] b Second 8 bit fixed point input vector + * @param[in] c Third 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8 bit fixed point vector multiply-accumulate + */ +qint8x16_t vmlaq_qs8(qint8x16_t a, qint8x16_t b, qint8x16_t c, int fixed_point_position); + +/** 8 bit fixed point vector saturating multiply-accumulate (8 elements). This operation performs the product between @p b and @p c and add the result to @p a (a + b * c). + * + * @param[in] a First 8 bit fixed point input vector where the result of multiplication must be added to + * @param[in] b Second 8 bit fixed point input vector + * @param[in] c Third 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8 bit fixed point vector multiply-accumulate. The result is saturated in case of overflow + */ +qint8x8_t vqmla_qs8(qint8x8_t a, qint8x8_t b, qint8x8_t c, int fixed_point_position); + +/** 8 bit fixed point vector saturating multiply-accumulate (16 elements). This operation performs the product between @p b and @p c and add the result to @p a (a + b * c). + * + * @param[in] a First 8 bit fixed point input vector where the result of multiplication must be added to + * @param[in] b Second 8 bit fixed point input vector + * @param[in] c Third 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8 bit fixed point vector multiply-accumulate.The result is saturated in case of overflow + */ +qint8x16_t vqmlaq_qs8(qint8x16_t a, qint8x16_t b, qint8x16_t c, int fixed_point_position); + +/** 8 bit fixed point vector multiply-accumulate long (8 elements). + * This operation performs the product between @p b and @p c and add the result to the 16 bit fixed point vector @p a (a + b * c). 8 elements + * + * @param[in] a First 16 bit fixed point input vector where the result of multiplication must be added to + * @param[in] b Second 8 bit fixed point input vector + * @param[in] c Third 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8 bit fixed point vector multiply-accumulate long + */ +qint16x8_t vmlal_qs8(qint16x8_t a, qint8x8_t b, qint8x8_t c, int fixed_point_position); + +/** 8 bit fixed point vector saturating multiply-accumulate long (8 elements). The saturation is performed on the 16 bit fixed point output vector. + * This operation performs the product between @p b and @p c and add the result to the 16 bit fixed point vector @p a (a + b * c). 8 elements + * + * @param[in] a First 16 bit fixed point input vector where the result of multiplication must be added to + * @param[in] b Second 8 bit fixed point input vector + * @param[in] c Third 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8 bit fixed point vector multiply-accumulate long + */ +qint16x8_t vqmlal_qs8(qint16x8_t a, qint8x8_t b, qint8x8_t c, int fixed_point_position); + +/** Convert a float vector with 4x2 elements to 8 bit fixed point vector with 8 elements + * + * @param[in] a Float input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the conversion float -> 8 bit fixed point + */ +qint8x8_t vcvt_qs8_f32(const float32x4x2_t &a, int fixed_point_position); + +/** Convert a float vector with 4x4 elements to 8 bit fixed point vector with 16 elements + * + * @param[in] a Float input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the conversion float -> 8 bit fixed point + */ +qint8x16_t vcvtq_qs8_f32(const float32x4x4_t &a, int fixed_point_position); + +/** Convert a 8 bit fixed point vector with 8 elements to a float vector with 4x2 elements + * + * @param[in] a 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the conversion 8 bit fixed point -> float32x2x4 + */ +float32x4x2_t vcvt_f32_qs8(qint8x8_t a, int fixed_point_position); + +/** Convert a 8 bit fixed point vector with 16 elements to a float vector with 4x4 elements + * + * @param[in] a 8 bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the conversion 8 bit fixed point -> float32x4x4 + */ +float32x4x4_t vcvtq_qs8_f32(qint8x16_t a, int fixed_point_position); + +/** Calculate reciprocal of a fixed point 8bit number using the Newton-Raphson method. (8 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit reciprocal (1/a). + */ +qint8x8_t vrecip_qs8(qint8x8_t a, int fixed_point_position); + +/** Calculate reciprocal of a fixed point 8bit number using the Newton-Raphson method. (16 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit reciprocal (1/a). + */ +qint8x16_t vrecipq_qs8(qint8x16_t a, int fixed_point_position); + +/** Division fixed point 8bit (8 elements) + * + * @param[in] a First 8bit fixed point input vector + * @param[in] b Second 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The quotient and remainder number in fixed point format. + */ +qint8x8_t vdiv_qs8(qint8x8_t a, int8x8_t b, int fixed_point_position); + +/** Division fixed point 8bit (16 elements) + * + * @param[in] a First 8bit fixed point input vector + * @param[in] b Second 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The quotient and remainder number in 8bit fixed point format. + */ +qint8x16_t vdivq_qs8(qint8x16_t a, int8x16_t b, int fixed_point_position); + +/** Perform a 4th degree polynomial approximation. (8 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit taylor approximation. + */ +template <bool islog> +qint8x8_t vtaylor_poly_qs8(qint8x8_t a, int fixed_point_position); + +/** Perform a 4th degree polynomial approximation. (16 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit taylor approximation. + */ +template <bool islog> +qint8x16_t vtaylor_polyq_qs8(qint8x16_t a, int fixed_point_position); + +/** Calculate saturating exponential fixed point 8bit (8 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit saturating exponential + */ +qint8x8_t vqexp_qs8(qint8x8_t a, int fixed_point_position); + +/** Calculate saturating exponential fixed point 8bit (16 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit saturating exponential + */ +qint8x16_t vqexpq_qs8(qint8x16_t a, int fixed_point_position); + +/** Calculate logarithm fixed point 16bit (8 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit logarithm. + */ +qint8x8_t vlog_qs8(qint8x8_t a, int fixed_point_position); + +/** Calculate logarithm fixed point 16bit (16 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit logarithm. + */ +qint8x16_t vlogq_qs8(qint8x16_t a, int fixed_point_position); + +/** Calculate inverse square root for fixed point 8bit using Newton-Raphosn method (8 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit inverse sqrt. + */ +qint8x8_t vinvsqrt_qs8(qint8x8_t a, int fixed_point_position); + +/** Calculate saturating inverse square root for fixed point 8bit using Newton-Raphosn method (8 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit inverse sqrt. + */ +qint8x8_t vqinvsqrt_qs8(qint8x8_t a, int fixed_point_position); + +/** Calculate inverse square root for fixed point 8bit using Newton-Raphosn method (16 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit inverse sqrt. + */ +qint8x16_t vinvsqrtq_qs8(qint8x16_t a, int fixed_point_position); + +/** Calculate saturating inverse square root for fixed point 8bit using Newton-Raphosn method (16 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit inverse sqrt. + */ +qint8x16_t vqinvsqrtq_qs8(qint8x16_t a, int fixed_point_position); + +/** Calculate hyperbolic tangent for fixed point 8bit (8 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The calculated Hyperbolic Tangent. + */ +qint8x8_t vtanh_qs8(qint8x8_t a, int fixed_point_position); + +/** Calculate hyperbolic tangent for fixed point 8bit (16 elements) + * + * @param[in] a 8bit fixed point input vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The calculated Hyperbolic Tangent. + */ +qint8x16_t vtanhq_qs8(qint8x16_t a, int fixed_point_position); + +/** Calculate saturating n power for fixed point 8bit (16 elements). + * + * pow(a,b) = e^(b*log(a)) + * + * @param[in] a 8bit fixed point input vector + * @param[in] b 8bit fixed point power vector + * @param[in] fixed_point_position Fixed point position that expresses the number of bits for the fractional part of the number + * + * @return The result of the 8bit power. + */ +qint8x8_t vqpowq_qs8(qint8x8_t a, qint8x16_t b, int fixed_point_position); +} +#include "arm_compute/core/NEON/NEFixedPoint.inl" +#endif /* __ARM_COMPUTE_NEFIXEDPOINT_H__ */ |