/*
 * 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 */
using qint32x2_t   = int32x2_t;   /**< 32 bit fixed point vector with 2 elements */
using qint32x4_t   = int32x4_t;   /**< 32 bit fixed point vector with 4 elements */
using qint32x4x2_t = int32x4x2_t; /**< 32 bit fixed point vector with 8 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 lower half of a 16 elements vector
 *
 * @param[in] a vector of 8 elements
 *
 * @return 16 bit fixed point vector (4 elements)
 */
qint16x4_t vget_low_qs16(qint16x8_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);

/** Get the higher half of a 16 elements vector
 *
 * @param[in] a vector of 8 elements
 *
 * @return 16 bit fixed point vector (4 elements)
 */
qint16x4_t vget_high_qs16(qint16x8_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 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 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 (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 16 bit fixed point vector with same value from memory (4 elements)
 *
 * @param[in] addr Memory address of the 16 bit fixed point scalar value to load
 *
 * @return 16 bit fixed point vector (4 elements)
 */
qint16x4_t vld1_dup_qs16(const qint16_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);

/** Load all lanes of 16 bit fixed point vector with same value from memory (8 elements)
 *
 * @param[in] addr Memory address of the 16 bit fixed point scalar value to load
 *
 * @return 16 bit fixed point vector (8 elements)
 */
qint16x8_t vld1q_dup_qs16(const qint16_t *addr);

/** Load two 16 bit fixed point vectors from memory (8x2 elements)
 *
 * @param[in] addr Memory address of the 16 bit fixed point vectors to load
 *
 * @return 16 bit fixed point vectors (8x2 elements)
 */
qint16x8x2_t vld2q_qs16(qint16_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 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 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 (8 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);

/** Store two 16 bit fixed point vector to memory (8x2 elements)
 *
 * @param[in] addr Memory address where the 16 bit fixed point vectors should be stored
 * @param[in] b    16 bit fixed point vectors to store
 *
 */
void vst2q_qs16(qint16_t *addr, qint16x8x2_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);

/** 32 bit fixed point vector saturating narrow (4 elements)
 *
 * @param[in] a 32 bit fixed point vector to convert
 *
 * @return 16 bit fixed point vector
 */
qint16x4_t vqmovn_q32(qint32x4_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);

/** 16 bit fixed point vector duplicate (4 elements)
 *
 * @param[in] a 16 bit fixed point to duplicate
 *
 * @return The result of the vector duplication
 */
qint16x4_t vdup_n_qs16(qint16_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                    floating point value to convert and 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);

/** Duplicate a float and convert it to 16 bit fixed point vector (8 elements)
 *
 * @param[in] a                    floating point value to convert and 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
 */
qint16x8_t vdupq_n_qs16_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 16 bit fixed point vector (4 elements)
 *
 * @param[in] a 16 bit fixed point input vector
 *
 * @return The result of the 16 bit fixed point vector absolute value
 */
qint16x4_t vabs_qs16(qint16x4_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);

/** Absolute value of 16 bit fixed point vector (8 elements)
 *
 * @param[in] a 16 bit fixed point input vector
 *
 * @return The result of the 16 bit fixed point vector absolute value
 */
qint16x8_t vabsq_qs16(qint16x8_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 16 bit fixed point vector (4 elements)
 *
 * @param[in] a 4 bit fixed point input vector
 *
 * @return The result of the 16 bit fixed point vector absolute value
 */
qint16x4_t vqabs_qs16(qint16x4_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);

/** Saturating absolute value of 16 bit fixed point vector (8 elements)
 *
 * @param[in] a 16 bit fixed point input vector
 *
 * @return The result of the 16 bit fixed point vector absolute value
 */
qint16x8_t vqabsq_qs16(qint16x8_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);

/** 16 bit fixed point vector max (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 max operation
 */
qint16x4_t vmax_qs16(qint16x4_t a, qint16x4_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);

/** 16 bit fixed point vector max (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 max operation
 */
qint16x8_t vmaxq_qs16(qint16x8_t a, qint16x8_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);

/** 16 bit fixed point vector pairwise max (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 pairwise max operation
 */
qint16x4_t vpmax_qs16(qint16x4_t a, qint16x4_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);

/** 16 bit fixed point vector min (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 max operation
 */
qint16x4_t vmin_qs16(qint16x4_t a, qint16x4_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);

/** 16 bit fixed point vector min (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 min operation
 */
qint16x8_t vminq_qs16(qint16x8_t a, qint16x8_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);

/** 16 bit fixed point vector pairwise min (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 pairwise min operation
 */
qint16x4_t vpmin_qs16(qint16x4_t a, qint16x4_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);

/** 16 bit fixed point vector 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
 */
qint16x4_t vadd_qs16(qint16x4_t a, qint16x4_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);

/** 16 bit fixed point vector 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
 */
qint16x8_t vaddq_qs16(qint16x8_t a, qint16x8_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);

/** 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);

/** 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 (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);

/** 16 bit fixed point vector subtraction (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 subtraction
 */
qint16x4_t vsub_qs16(qint16x4_t a, qint16x4_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);

/** 16 bit fixed point vector subtraction (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 subtraction
 */
qint16x8_t vsubq_qs16(qint16x8_t a, qint16x8_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);

/** 16 bit fixed point vector saturating subtraction (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 subtraction. The result is saturated in case of overflow
 */
qint16x4_t vqsub_qs16(qint16x4_t a, qint16x4_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);

/** 16 bit fixed point vector saturating subtraction (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 subtraction. The result is saturated in case of overflow
 */
qint16x8_t vqsubq_qs16(qint16x8_t a, qint16x8_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);

/** 16 bit fixed point vector multiply (4 elements)
 *
 * @param[in] a                    First 16 bit fixed point input vector
 * @param[in] b                    Second 16 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 16 bit fixed point vector multiplication.
 */
qint16x4_t vmul_qs16(qint16x4_t a, qint16x4_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);

/** 16 bit fixed point vector multiply (8 elements)
 *
 * @param[in] a                    First 16 bit fixed point input vector
 * @param[in] b                    Second 16 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 16 bit fixed point vector multiplication.
 */
qint16x8_t vmulq_qs16(qint16x8_t a, qint16x8_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);

/** 16 bit fixed point vector saturating multiply (4 elements)
 *
 * @param[in] a                    First 16 bit fixed point input vector
 * @param[in] b                    Second 16 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 16 bit fixed point vector multiplication. The result is saturated in case of overflow
 */
qint16x4_t vqmul_qs16(qint16x4_t a, qint16x4_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);

/** 16 bit fixed point vector saturating multiply (8 elements)
 *
 * @param[in] a                    First 16 bit fixed point input vector
 * @param[in] b                    Second 16 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 16 bit fixed point vector multiplication. The result is saturated in case of overflow
 */
qint16x8_t vqmulq_qs16(qint16x8_t a, qint16x8_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);

/** 16 bit fixed point vector long multiply (4 elements)
 *
 * @param[in] a                    First 16 bit fixed point input vector
 * @param[in] b                    Second 16 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 32 bit fixed point long vector multiplication.
 */
qint32x4_t vmull_qs16(qint16x4_t a, qint16x4_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);

/** 16 bit fixed point vector multiply-accumulate (4 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 16 bit fixed point input vector where the result of multiplication must be added to
 * @param[in] b                    Second 16 bit fixed point input vector
 * @param[in] c                    Third 16 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 16 bit fixed point vector multiply-accumulate
 */
qint16x4_t vmla_qs16(qint16x4_t a, qint16x4_t b, qint16x4_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);

/** 16 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 16 bit fixed point input vector where the result of multiplication must be added to
 * @param[in] b                    Second 16 bit fixed point input vector
 * @param[in] c                    Third 16 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 16 bit fixed point vector multiply-accumulate
 */
qint16x8_t vmlaq_qs16(qint16x8_t a, qint16x8_t b, qint16x8_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);

/** 16 bit fixed point vector saturating multiply-accumulate (4 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 16 bit fixed point input vector where the result of multiplication must be added to
 * @param[in] b                    Second 16 bit fixed point input vector
 * @param[in] c                    Third 16 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 16 bit fixed point vector multiply-accumulate. The result is saturated in case of overflow
 */
qint16x4_t vqmla_qs16(qint16x4_t a, qint16x4_t b, qint16x4_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);

/** 16 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 16 bit fixed point input vector where the result of multiplication must be added to
 * @param[in] b                    Second 16 bit fixed point input vector
 * @param[in] c                    Third 16 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 16 bit fixed point vector multiply-accumulate.The result is saturated in case of overflow
 */
qint16x8_t vqmlaq_qs16(qint16x8_t a, qint16x8_t b, qint16x8_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);

/** 16 bit fixed point vector multiply-accumulate long (4 elements).
 *  This operation performs the product between @p b and @p c and add the result to the 32 bit fixed point vector @p a (a + b * c). 4 elements
 *
 * @param[in] a                    First 32 bit fixed point input vector where the result of multiplication must be added to
 * @param[in] b                    Second 16 bit fixed point input vector
 * @param[in] c                    Third 16 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 16 bit fixed point vector multiply-accumulate long
 */
qint32x4_t vmlal_qs16(qint32x4_t a, qint16x4_t b, qint16x4_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);

/** 16 bit fixed point vector saturating multiply-accumulate long (4 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 32 bit fixed point vector @p a (a + b * c). 4 elements
 *
 * @param[in] a                    First 32 bit fixed point input vector where the result of multiplication must be added to
 * @param[in] b                    Second 16 bit fixed point input vector
 * @param[in] c                    Third 16 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 16 bit fixed point vector multiply-accumulate long
 */
qint32x4_t vqmlal_qs16(qint32x4_t a, qint16x4_t b, qint16x4_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. The result is saturated in case of overflow
 */
qint8x8_t vqcvt_qs8_f32(const float32x4x2_t a, int fixed_point_position);

/** Convert a float vector with 4 elements to 16 bit fixed point vector with 4 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 -> 16 bit fixed point. The result is saturated in case of overflow
 */
qint16x4_t vqcvt_qs16_f32(const float32x4_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. The result is saturated in case of overflow
 */
qint8x16_t vqcvtq_qs8_f32(const float32x4x4_t &a, int fixed_point_position);

/** Convert a float vector with 4x2 elements to 16 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 -> 16 bit fixed point. The result is saturated in case of overflow
 */
qint16x8_t vqcvtq_qs16_f32(const float32x4x2_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 16 bit fixed point vector with 4 elements to a float vector with 4 elements
 *
 * @param[in] a                    16 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 16 bit fixed point -> float32x2
 */
float32x4_t vcvt_f32_qs16(qint16x4_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);

/** Convert a 16 bit fixed point vector with 8 elements to a float vector with 4x2 elements
 *
 * @param[in] a                    16 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 16 bit fixed point -> float32x4x2
 */
float32x4x2_t vcvtq_qs16_f32(qint16x8_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. (4 elements)
 *
 * @param[in] a                    16 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 16 bit reciprocal (1/a).
 */
qint16x4_t vrecip_qs16(qint16x4_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);

/** Calculate reciprocal of a fixed point 8bit number using the Newton-Raphson method. (8 elements)
 *
 * @param[in] a                    16 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 16 bit reciprocal (1/a).
 */
qint16x8_t vrecipq_qs16(qint16x8_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 16 bit (4 elements)
 *
 * @param[in] a                    First 16 bit fixed point input vector
 * @param[in] b                    Second  16 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 quotient and remainder number in fixed point format.
 */
qint16x4_t vdiv_qs16(qint16x4_t a, qint16x4_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, qint8x16_t b, int fixed_point_position);

/** Division fixed point 16 bit (8 elements)
 *
 * @param[in] a                    First 16 bit fixed point input vector
 * @param[in] b                    Second 16 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 quotient and remainder number in 16 bit fixed point format.
 */
qint16x8_t vdivq_qs16(qint16x8_t a, qint16x8_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. (4 elements)
 *
 * @param[in] a                    16 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 16 bit taylor approximation.
 */
template <bool islog>
qint16x4_t vtaylor_poly_qs16(qint16x4_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);

/** Perform a 4th degree polynomial approximation. (8 elements)
 *
 * @param[in] a                    16 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 8bit taylor approximation.
 */
template <bool islog>
qint16x8_t vtaylor_polyq_qs16(qint16x8_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 16 bit (4 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 16 bit saturating exponential
 */
qint16x4_t vqexp_qs16(qint16x4_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 saturating exponential fixed point 16 bit (8 elements)
 *
 * @param[in] a                    16 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 16 bit saturating exponential
 */
qint16x8_t vqexpq_qs16(qint16x8_t a, int fixed_point_position);

/** Calculate logarithm fixed point 8 bit (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 16 bit (4 elements)
 *
 * @param[in] a                    16 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 16 bit logarithm.
 */
qint16x4_t vlog_qs16(qint16x4_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 logarithm fixed point 16 bit (8 elements)
 *
 * @param[in] a                    16 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 16 bit logarithm.
 */
qint16x8_t vlogq_qs16(qint16x8_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 inverse square root for fixed point 16 bit using Newton-Raphosn method (4 elements)
 *
 * @param[in] a                    16 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 16 bit inverse sqrt.
 */
qint16x4_t vinvsqrt_qs16(qint16x4_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 saturating inverse square root for fixed point 16 bit using Newton-Raphosn method (4 elements)
 *
 * @param[in] a                    16 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 16 bit inverse sqrt.
 */
qint16x4_t vqinvsqrt_qs16(qint16x4_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 inverse square root for fixed point 8bit using Newton-Raphosn method (8 elements)
 *
 * @param[in] a                    16 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 16 bit inverse sqrt.
 */
qint16x8_t vinvsqrtq_qs16(qint16x8_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 saturating inverse square root for fixed point 16 bit using Newton-Raphosn method (8 elements)
 *
 * @param[in] a                    16 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 16 bit inverse sqrt.
 */
qint16x8_t vqinvsqrtq_qs16(qint16x8_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 vqtanh_qs8(qint8x8_t a, int fixed_point_position);

/** Calculate hyperbolic tangent for fixed point 16 bit (4 elements)
 *
 * @param[in] a                    16 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 calculated Hyperbolic Tangent.
 */
qint16x4_t vqtanh_qs16(qint16x4_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 vqtanhq_qs8(qint8x16_t a, int fixed_point_position);

/** Calculate hyperbolic tangent for fixed point 16bit (8 elements)
 *
 * @param[in] a                    16 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 calculated Hyperbolic Tangent.
 */
qint16x8_t vqtanhq_qs16(qint16x8_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.
 */
qint8x16_t vqpowq_qs8(qint8x16_t a, qint8x16_t b, int fixed_point_position);

/** Calculate saturating n power for fixed point 16bit (8 elements).
 *
 * pow(a,b) = e^(b*log(a))
 *
 * @param[in] a                    16bit fixed point input vector
 * @param[in] b                    16bit 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 16bit power.
 */
qint16x8_t vqpowq_qs16(qint16x8_t a, qint16x8_t b, int fixed_point_position);

/** Compute lane-by-lane maximum between elements of a float vector with 4x2 elements
 *
 * @param[in] a Float input vector
 * @param[in] b Float input vector
 *
 * @return The lane-by-lane maximum -> float32x4x2
 */
float32x4x2_t vmax2q_f32(float32x4x2_t a, float32x4x2_t b);
} // namespace arm_compute
#include "arm_compute/core/NEON/NEFixedPoint.inl"
#endif /* __ARM_COMPUTE_NEFIXEDPOINT_H__ */