/*
 * 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_FIXEDPOINT_H__
#define __ARM_COMPUTE_FIXEDPOINT_H__

#include <cstdint>

namespace arm_compute
{
using qint8_t  = int8_t;  /**< 8 bit fixed point scalar value */
using qint16_t = int16_t; /**< 16 bit fixed point scalar value */
using qint32_t = int32_t; /**< 32 bit fixed point scalar value */
using qint64_t = int64_t; /**< 64 bit fixed point scalar value */

/** 8 bit fixed point scalar saturating shift left
 *
 * @param[in] a     First 8 bit fixed point input
 * @param[in] shift Shift amount (positive only values)
 *
 * @return The result of the 8 bit fixed point shift. The result is saturated in case of overflow
 */
qint8_t sqshl_qs8(qint8_t a, int shift);

/** 16 bit fixed point scalar saturating shift left
 *
 * @param[in] a     First 16 bit fixed point input
 * @param[in] shift Shift amount (positive only values)
 *
 * @return The result of the 16 bit fixed point shift. The result is saturated in case of overflow
 */
qint16_t sqshl_qs16(qint16_t a, int shift);

/** 8 bit fixed point scalar absolute value
 *
 * @param[in] a 8 bit fixed point input
 *
 * @return The result of the 8 bit fixed point absolute value
 */
qint8_t sabs_qs8(qint8_t a);

/** 16 bit fixed point scalar absolute value
 *
 * @param[in] a 16 bit fixed point input
 *
 * @return The result of the 16 bit fixed point absolute value
 */
qint16_t sabs_qs16(qint16_t a);

/** 8 bit fixed point scalar add
 *
 * @param[in] a First 8 bit fixed point input
 * @param[in] b Second 8 bit fixed point input
 *
 * @return The result of the 8 bit fixed point addition
 */
qint8_t sadd_qs8(qint8_t a, qint8_t b);

/** 16 bit fixed point scalar add
 *
 * @param[in] a First 16 bit fixed point input
 * @param[in] b Second 16 bit fixed point input
 *
 * @return The result of the 16 bit fixed point addition
 */
qint16_t sadd_qs16(qint16_t a, qint16_t b);

/** 8 bit fixed point scalar saturating add
 *
 * @param[in] a First 8 bit fixed point input
 * @param[in] b Second 8 bit fixed point input
 *
 * @return The result of the 8 bit fixed point addition. The result is saturated in case of overflow
 */
qint8_t sqadd_qs8(qint8_t a, qint8_t b);

/** 16 bit fixed point scalar saturating add
 *
 * @param[in] a First 16 bit fixed point input
 * @param[in] b Second 16 bit fixed point input
 *
 * @return The result of the 16 bit fixed point addition. The result is saturated in case of overflow
 */
qint16_t sqadd_qs16(qint16_t a, qint16_t b);

/** 32 bit fixed point scalar saturating add
 *
 * @param[in] a First 32 bit fixed point input
 * @param[in] b Second 32 bit fixed point input
 *
 * @return The result of the 32 bit fixed point addition. The result is saturated in case of overflow
 */
qint32_t sqadd_qs32(qint32_t a, qint32_t b);

/** 8 bit fixed point scalar subtraction
 *
 * @param[in] a First 8 bit fixed point input
 * @param[in] b Second 8 bit fixed point input
 *
 * @return The result of the 8 bit fixed point subtraction
 */
qint8_t ssub_qs8(qint8_t a, qint8_t b);

/** 16 bit fixed point scalar subtraction
 *
 * @param[in] a First 16 bit fixed point input
 * @param[in] b Second 16 bit fixed point input
 *
 * @return The result of the 16 bit fixed point subtraction
 */
qint16_t ssub_qs16(qint16_t a, qint16_t b);

/** 8 bit fixed point scalar saturating subtraction
 *
 * @param[in] a First 8 bit fixed point input
 * @param[in] b Second 8 bit fixed point input
 *
 * @return The result of the 8 bit fixed point subtraction. The result is saturated in case of overflow
 */
qint8_t sqsub_qs8(qint8_t a, qint8_t b);

/** 16 bit fixed point scalar saturating subtraction
 *
 * @param[in] a First 16 bit fixed point input
 * @param[in] b Second 16 bit fixed point input
 *
 * @return The result of the 16 bit fixed point subtraction. The result is saturated in case of overflow
 */
qint16_t sqsub_qs16(qint16_t a, qint16_t b);

/** 8 bit fixed point scalar multiply
 *
 * @param[in] a                    First 8 bit fixed point input
 * @param[in] b                    Second 8 bit fixed point input
 * @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 multiplication.
 */
qint8_t smul_qs8(qint8_t a, qint8_t b, int fixed_point_position);

/** 16 bit fixed point scalar multiply
 *
 * @param[in] a                    First 16 bit fixed point input
 * @param[in] b                    Second 16 bit fixed point input
 * @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 multiplication.
 */
qint16_t smul_qs16(qint16_t a, qint16_t b, int fixed_point_position);

/** 8 bit fixed point scalar saturating multiply
 *
 * @param[in] a                    First 8 bit fixed point input
 * @param[in] b                    Second 8 bit fixed point input
 * @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 multiplication. The result is saturated in case of overflow
 */
qint8_t sqmul_qs8(qint8_t a, qint8_t b, int fixed_point_position);

/** 16 bit fixed point scalar saturating multiply
 *
 * @param[in] a                    First 16 bit fixed point input
 * @param[in] b                    Second 16 bit fixed point input
 * @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 multiplication. The result is saturated in case of overflow
 */
qint16_t sqmul_qs16(qint16_t a, qint16_t b, int fixed_point_position);

/** 8 bit fixed point scalar multiply long
 *
 * @param[in] a                    First 8 bit fixed point input
 * @param[in] b                    Second 8 bit fixed point input
 * @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 multiplication long. The result is saturated in case of overflow
 */
qint16_t sqmull_qs8(qint8_t a, qint8_t b, int fixed_point_position);

/** 16 bit fixed point scalar multiply long
 *
 * @param[in] a                    First 16 bit fixed point input
 * @param[in] b                    Second 16 bit fixed point input
 * @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 multiplication long. The result is saturated in case of overflow
 */
qint32_t sqmull_qs16(qint16_t a, qint16_t b, int fixed_point_position);

/** 16 bit fixed point scalar saturating multiply
*
* @param[in] a                    First 16 bit fixed point input
* @param[in] b                    Second 16 bit fixed point input
* @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 multiplication. The result is saturated in case of overflow
*/
qint16_t sqmul_qs16(qint16_t a, qint16_t b, int fixed_point_position);

/** 8 bit fixed point scalar inverse square root
*
* @param[in] a                    8 bit fixed point input
* @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 inverse square root.
*/
qint8_t sinvsqrt_qs8(qint8_t a, int fixed_point_position);

/** 16 bit fixed point scalar inverse square root
*
* @param[in] a                    16 bit fixed point input
* @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 inverse square root.
*/
qint16_t sinvsqrt_qs16(qint16_t a, int fixed_point_position);

/** 8 bit fixed point scalar division
*
* @param[in] a                    First 8 bit fixed point input
* @param[in] b                    Second 8 bit fixed point input
* @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 division.
*/
qint8_t sdiv_qs8(qint8_t a, qint8_t b, int fixed_point_position);

/** 16 bit fixed point scalar division
*
* @param[in] a                    First 16 bit fixed point input
* @param[in] b                    Second 16 bit fixed point input
* @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 division.
*/
qint16_t sdiv_qs16(qint16_t a, qint16_t b, int fixed_point_position);

/** 8 bit fixed point scalar exponential
*
* @param[in] a                    8 bit fixed point input
* @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 exponential.
*/
qint8_t sqexp_qs8(qint8_t a, int fixed_point_position);

/** 16 bit fixed point scalar exponential
*
* @param[in] a                    16 bit fixed point input
* @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 exponential.
*/
qint16_t sqexp_qs16(qint16_t a, int fixed_point_position);

/** 16 bit fixed point scalar exponential
*
* @param[in] a                    16 bit fixed point input
* @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 exponential.
*/
qint16_t sexp_qs16(qint16_t a, int fixed_point_position);

/** 8 bit fixed point scalar logarithm
*
* @param[in] a                    8 bit fixed point input
* @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 logarithm.
*/
qint8_t slog_qs8(qint8_t a, int fixed_point_position);

/** 16 bit fixed point scalar logarithm
*
* @param[in] a                    16 bit fixed point input
* @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 logarithm.
*/
qint16_t slog_qs16(qint16_t a, int fixed_point_position);

/** Convert an 8 bit fixed point to float
 *
 * @param[in] a                    Input to convert
 * @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 -> float
 */
float scvt_f32_qs8(qint8_t a, int fixed_point_position);

/** Convert a float to 8 bit fixed point
 *
 * @param[in] a                    Input to convert
 * @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
 */
qint8_t sqcvt_qs8_f32(float a, int fixed_point_position);

/** Convert a 16 bit fixed point to float
 *
 * @param[in] a                    Input to convert
 * @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 -> float
 */
float scvt_f32_qs16(qint16_t a, int fixed_point_position);

/** Convert a float to 16 bit fixed point
 *
 * @param[in] a                    Input to convert
 * @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
 */
qint16_t sqcvt_qs16_f32(float a, int fixed_point_position);

/** Scalar saturating move and narrow.
 *
 * @param[in] a Input to convert to 8 bit fixed point
 *
 * @return The narrowing conversion to 8 bit
 */
qint8_t sqmovn_qs16(qint16_t a);

/** Scalar saturating move and narrow.
 *
 * @param[in] a Input to convert to 16 bit fixed point
 *
 * @return The narrowing conversion to 16 bit
 */
qint16_t sqmovn_qs32(qint32_t a);
}
#include "arm_compute/core/FixedPoint.inl"
#endif /* __ARM_COMPUTE_FIXEDPOINT_H__ */