stdfix-full-iso.h

Go to the documentation of this file.

/*
 * Copyright (c) 2013 The University of Manchester
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef __STDFIX_FULL_ISO_H__
#define __STDFIX_FULL_ISO_H__
 
#include <stdint.h>
#include <stdbool.h>
#include "arm_acle.h"
 
#ifndef min
#define min(a, b)   (((a)<(b)) ? (a) : (b))
#endif
 
 
#define __stdfix_max(a, b) \
    (((a)<(b)) ? (b) : (a))
 
 
// note that this is a use of the semicolon swallowing as defined in:
// https://gcc.gnu.org/onlinedocs/cpp/Swallowing-the-Semicolon.html
#define __stdfix_use(a) \
    do {} while ((a)!=(a))
 
 
#define __stdfix_abs(a) \
    (((a)<0) ? -(a) : (a))
 
 
#define __stdfix_ms_u32(x) \
    ((x) >> 32)
 
 
#define __stdfix_ls_u32(x) \
    ((x) & UINT32_MAX)
 
 
void __stdfix_64x64_128(uint64_t *hi, uint64_t *lo, uint64_t x, uint64_t y);
 
 
typedef int8_t  int_hr_t;
 
typedef int16_t int_r_t;
 
typedef int32_t int_lr_t;
 
typedef int16_t int_hk_t;
 
typedef int32_t int_k_t;
 
typedef int64_t int_lk_t;
 
typedef uint8_t  uint_uhr_t;
 
typedef uint16_t uint_ur_t;
 
typedef uint32_t uint_ulr_t;
 
typedef uint16_t uint_uhk_t;
 
typedef uint32_t uint_uk_t;
 
typedef uint64_t uint_ulk_t;
 
#ifdef __arm__
#include <stdfix.h>
 
// TRULY AWFUL HACK to make the Eclipse CDT not complain like crazy
// https://fasaxc.blogspot.co.uk/2015/02/working-with-cs-new-fixed-point.html
// I am so, so sorry...
#ifdef ECLIPSE_CDT_INDEXER_HACK
#define _Fract int
#define _Accum int
#define _Sat
#endif // ECLIPSE_CDT_INDEXER_HACK
 
typedef short fract s07;
 
typedef fract s015;
 
typedef long fract s031;
 
typedef short accum s87;
 
typedef accum s1615;
 
typedef long accum s3231;
 
typedef unsigned short fract u08;
 
typedef unsigned fract u016;
 
typedef unsigned long fract u032;
 
typedef unsigned short accum u88;
 
typedef unsigned accum u1616;
 
typedef unsigned long accum u3232;
 
#else /* ! __arm__ */
 
typedef int8_t s07;
typedef int16_t s015;
typedef int32_t s031;
typedef int16_t s87;
typedef int32_t s1615;
typedef int64_t s3231;
 
typedef uint8_t u08;
typedef uint16_t u016;
typedef uint32_t u032;
typedef uint16_t u88;
typedef uint32_t u1616;
typedef uint64_t u3232;
 
#endif /* __arm__ */
 
 
 
static inline int_hr_t bitshr(
    const s07 f)
{
    union { int_hr_t r; s07 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
static inline int_r_t bitsr(
    const s015 f)
{
    union { int_r_t r; s015 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
static inline int_lr_t bitslr(
    const s031 f)
{
    union { int_lr_t r; s031 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
static inline int_hk_t bitshk(
    const s87 f)
{
    union { int_hk_t r; s87 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
static inline int_k_t bitsk(
    const s1615 f)
{
    union { int_k_t r; s1615 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
static inline int_lk_t bitslk(
    const s3231 f)
{
    union { int_lk_t r; s3231 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
static inline uint_uhr_t bitsuhr(
    const u08 f)
{
    union { uint_uhr_t r; u08 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
static inline uint_ur_t bitsur(
    const u016 f)
{
    union { uint_ur_t r; u016 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
static inline uint_ulr_t bitsulr(
    const u032 f)
{
    union { uint_ulr_t r; u032 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
static inline uint_uhk_t bitsuhk(
    const u88 f)
{
    union { uint_uhk_t r; u88 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
static inline uint_uk_t bitsuk(
    const u1616 f)
{
    union { uint_uk_t r; u1616 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
static inline uint_ulk_t bitsulk(
    const u3232 f)
{
    union { uint_ulk_t r; u3232 fx; } x;
 
    x.fx = f;
    return x.r;
}
 
 
 
static inline s07 hrbits(
    const int_hr_t n)
{
    union { int_hr_t r; s07 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
 
static inline s015 rbits(
    const int_r_t n)
{
    union { int_r_t r; s015 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
 
static inline s031 lrbits(
    const int_lr_t n)
{
    union { int_lr_t r; s031 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
 
static inline s87 hkbits(
    const int_hk_t n)
{
    union { int_hk_t r; s87 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
 
static inline s1615 kbits(
    const int_k_t n)
{
    union { int_k_t r; s1615 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
 
static inline s3231 lkbits(
    const int_lk_t n)
{
    union { int_lk_t r; s3231 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
 
static inline u08 uhrbits(
    const uint_uhr_t n)
{
    union { uint_uhr_t r; u08 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
 
static inline u016 urbits(
    const uint_ur_t n)
{
    union { uint_ur_t r; u016 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
 
static inline u032 ulrbits(
    const uint_ulr_t n)
{
    union { uint_ulr_t r; u032 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
 
static inline u88 uhkbits(
    const uint_uhk_t n)
{
    union { uint_uhk_t r; u88 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
 
static inline u1616 ukbits(
    const uint_uk_t  n)
{
    union { uint_uk_t  r; u1616 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
 
static inline u3232 ulkbits(
    const uint_ulk_t n)
{
    union { uint_ulk_t r; u3232 fx; } x;
 
    x.r = n;
    return x.fx;
}
 
// Wrapped casts
#define __I(x)    ((int) (x))
#define __I32(x)  ((int32_t) (x))
#define __I64(x)  ((int64_t) (x))
#define __LI(x)   ((long int) (x))
#define __U32(x)  ((uint32_t) (x))
#define __U64(x)  ((uint64_t) (x))
#define __UI(x)   ((unsigned int) (x))
#define __ULI(x)  ((unsigned long int) (x))
 
// Saturation operations
 
 
static inline int32_t __stdfix_sat_hr(
    const int32_t x)
{
    if (x > INT8_MAX) {
        return INT8_MAX;
    }
    if (x < INT8_MIN) {
        return INT8_MIN;
    }
 
    return x;
}
 
 
static inline int32_t __stdfix_sat_r(
    const int32_t x)
{
    if (x > INT16_MAX) {
        return INT16_MAX;
    }
    if (x < INT16_MIN) {
        return INT16_MIN;
    }
 
    return x;
}
 
 
static inline int32_t __stdfix_sat_lr(
    const int64_t x)
{
    if (x > INT32_MAX) {
        return INT32_MAX;
    }
    if (x < INT32_MIN) {
        return INT32_MIN;
    }
 
    return __I32(x);
}
 
 
static inline int32_t __stdfix_sat_hk(
    const int32_t x)
{
    if (x > INT16_MAX) {
        return INT16_MAX;
    }
    if (x < INT16_MIN) {
        return INT16_MIN;
    }
 
    return x;
}
 
 
static inline int32_t __stdfix_sat_k(
    const int64_t x)
{
    if (x > INT32_MAX) {
        return INT32_MAX;
    }
    if (x < INT32_MIN) {
        return INT32_MIN;
    }
 
    return __I32(x);
}
 
 
static inline uint32_t __stdfix_sat_uhr(
    const uint32_t x)
{
    if (x > UINT8_MAX) {
        return UINT8_MAX;
    }
 
    return x;
}
 
 
static inline uint32_t __stdfix_sat_ur(
    const uint32_t x)
{
    if (x > UINT16_MAX) {
        return UINT16_MAX;
    }
 
    return x;
}
 
 
static inline uint32_t __stdfix_sat_ulr(
    const uint64_t x)
{
    if (x > UINT32_MAX) {
        return UINT32_MAX;
    }
 
    return __U32(x);
}
 
 
static inline uint32_t __stdfix_sat_uhk(
    const uint32_t x)
{
    if (x > UINT16_MAX) {
        return UINT16_MAX;
    }
 
    return x;
}
 
 
static inline uint32_t __stdfix_sat_uk(
    const uint64_t x)
{
    if (x > UINT32_MAX) {
        return UINT32_MAX;
    }
 
    return __U32(x);
}
 
// software simulation of basic saturating arithmetic
 
 
static inline int32_t __stdfix_sadd_hr(
    int_hr_t x,
    int_hr_t y)
{
    return __stdfix_sat_hr(__I32(x) + __I32(y));
}
 
 
static inline int32_t __stdfix_ssub_hr(
    int_hr_t x,
    int_hr_t y)
{
    return __stdfix_sat_hr(__I32(x) - __I32(y));
}
 
 
static inline int32_t __stdfix_sneg_hr(
    int_hr_t x)
{
    return __stdfix_sat_hr(__I32(-x));
}
 
 
static inline int32_t __stdfix_sadd_r(
    int32_t x,
    int32_t y)
{
    return __stdfix_sat_r(__I32(x) + __I32(y));
}
 
 
static inline int32_t __stdfix_ssub_r(
    int32_t x,
    int32_t y)
{
    return __stdfix_sat_r(__I32(x) - __I32(y));
}
 
 
static inline int32_t __stdfix_sneg_r(
    int32_t x)
{
    return __stdfix_sat_r(__I32(-x));
}
 
 
static inline int32_t __stdfix_sadd_lr(
    int32_t x,
    int32_t y)
{
    return __stdfix_sat_lr(__I64(x) + __I64(y));
}
 
 
static inline int32_t __stdfix_ssub_lr(
    int32_t x,
    int32_t y)
{
    return __stdfix_sat_lr(__I64(x) - __I64(y));
}
 
 
static inline int32_t __stdfix_sneg_lr(
    int32_t x)
{
    return __stdfix_sat_lr(__I64(-x));
}
 
 
static inline int32_t __stdfix_sadd_hk(
    int32_t x,
    int32_t y)
{
    return __stdfix_sat_hk(__I32(x) + __I32(y));
}
 
 
static inline int32_t __stdfix_ssub_hk(
    int32_t x,
    int32_t y)
{
    return __stdfix_sat_hk(__I32(x) - __I32(y));
}
 
 
static inline int32_t __stdfix_sneg_hk(
    int32_t x)
{
    return __stdfix_sat_hk(__I32(-x));
}
 
 
static inline int32_t __stdfix_sadd_k(
    int32_t x,
    int32_t y)
{
#ifdef   __ARM_FEATURE_DSP
    return __qadd(x, y);
#else  /*__ARM_FEATURE_DSP*/
    return __stdfix_sat_k(__I64(x) + __I64(y));
#endif /*__ARM_FEATURE_DSP*/
}
 
 
static inline int32_t __stdfix_ssub_k(
    int32_t x,
    int32_t y)
{
#ifdef   __ARM_FEATURE_DSP
    return __qsub(x, y);
#else  /*__ARM_FEATURE_DSP*/
    return __stdfix_sat_k(__I64(x) - __I64(y));
#endif /*__ARM_FEATURE_DSP*/
}
 
 
static inline int32_t __stdfix_sneg_k(
    int32_t x)
{
#ifdef   __ARM_FEATURE_DSP
    return __qsub(0, x);
#else  /*__ARM_FEATURE_DSP*/
    return __stdfix_sat_k(__I64(-x));
#endif /*__ARM_FEATURE_DSP*/
}
 
 
int64_t __stdfix_sadd_lk(int64_t x, int64_t y);
 
 
int64_t __stdfix_ssub_lk(int64_t x, int64_t y);
 
 
int64_t __stdfix_sneg_lk(int64_t x);
 
 
static inline int32_t __stdfix_smul_hr(
    int32_t x,
    int32_t y)
{
    if (x == INT8_MIN && y == INT8_MIN) { // special case for -1.0*-1.0
    return INT8_MAX;
    }
 
    return __I32(__stdfix_sat_hr((__I32(x) * __I32(y)) >> 7));
}
 
 
static inline int32_t __stdfix_smul_r(
    int32_t x,
    int32_t y)
{
    if (x == INT16_MIN && y == INT16_MIN) { // special case for -1.0*-1.0
    return INT16_MAX;
    }
 
    return __I32(__stdfix_sat_r((__I32(x) * __I32(y)) >> 15));
}
 
 
static inline int32_t __stdfix_smul_lr(
    int32_t x,
    int32_t y)
{
    if (x == INT32_MIN && y == INT32_MIN) { // special case for -1.0*-1.0
    return INT32_MAX;
    }
 
    return __stdfix_sat_lr((__I64(x) * __I64(y)) >> 31);
}
 
 
static inline int32_t __stdfix_smul_hk(
    int32_t x,
    int32_t y)
{
    if (x == INT16_MIN && y == INT16_MIN) { // special case for -1.0*-1.0
    return INT16_MAX;
    }
 
    return __stdfix_sat_hk((__I32(x) * __I32(y)) >> 7);
}
 
 
static inline int32_t __stdfix_smul_k(
    int32_t x,
    int32_t y)
{
    if (x == INT32_MIN && y == INT32_MIN) { // special case for -1.0*-1.0
    return INT32_MAX;
    }
 
    return __stdfix_sat_k((__I64(x) * __I64(y)) >> 15);
}
 
 
int64_t __stdfix_smul_lk(int64_t x, int64_t y);
 
 
static inline uint32_t __stdfix_sadd_uhr(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_uhr(__U32(x) + __U32(y));
}
 
 
static inline uint32_t __stdfix_ssub_uhr(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_uhr(__U32(x) - __U32(y));
}
 
 
static inline uint32_t __stdfix_sadd_ur(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_ur(__U32(x) + __U32(y));
}
 
 
static inline uint32_t __stdfix_ssub_ur(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_ur(__U32(x) - __U32(y));
}
 
 
static inline uint32_t __stdfix_sadd_ulr(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_ulr(__U64(x) + __U64(y));
}
 
 
static inline uint32_t __stdfix_ssub_ulr(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_ulr(__U64(x) - __U64(y));
}
 
 
static inline uint32_t __stdfix_sadd_uhk(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_uhk(__U32(x) + __U32(y));
}
 
 
static inline uint32_t __stdfix_ssub_uhk(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_uhk(__U32(x) - __U32(y));
}
 
 
static inline uint32_t __stdfix_sadd_uk(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_uk(__U64(x) + __U64(y));
}
 
 
static inline uint32_t __stdfix_ssub_uk(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_uk(__U64(x) - __U64(y));
}
 
 
uint64_t __stdfix_sadd_ulk(uint64_t x, uint64_t y);
 
 
uint64_t __stdfix_ssub_ulk(uint64_t x, uint64_t y);
 
 
static inline uint32_t __stdfix_smul_uhr(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_uhr((__U32(x) * __U32(y)) >> 8);
}
 
 
static inline uint32_t __stdfix_smul_ur(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_ur((__U32(x) * __U32(y)) >> 16);
}
 
 
static inline uint32_t __stdfix_smul_ulr(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_ulr((__U64(x) * __U64(y)) >> 32);
}
 
 
static inline uint32_t __stdfix_smul_uhk(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_uhk((__U32(x) * __U32(y)) >> 8);
}
 
 
static inline uint32_t __stdfix_smul_uk(
    uint32_t x,
    uint32_t y)
{
    return __stdfix_sat_uk((__U64(x) * __U64(y)) >> 16);
}
 
 
uint64_t __stdfix_smul_ulk(uint64_t x, uint64_t y);
 
 
 
static inline int mulir(
    int n,
    s015 x)
{
    return __I((__I64(n) * __I64(bitsr(x))) >> 15);
}
 
 
static inline long int mulilr(
    long int n,
    s031 x)
{
    return __LI((__I64(n) * __I64(bitslr(x))) >> 31);
}
 
 
static inline int mulik(
    int n,
    s1615 x)
{
    return __I((__I64(n) * __I64(bitsk(x))) >> 15);
}
 
 
static inline long int mulilk(
    long int n,
    s3231 x)
{
    int64_t r = bitslk(x);
    int64_t k = __I64(n) * (r >> 31);
    int64_t c = (__I64(n) * (r & INT64_C(0x7FFFFFF))) >> 31;
 
    return __LI(k + c);
}
 
 
static inline int divir(
    int n,
    s015 x)
{
    return __I((__I64(n) << 15) / bitsr(x));
}
 
 
static inline long int divilr(
    long int n,
    s031 x)
{
    return __LI((__I64(n) << 31) / bitslr(x));
}
 
 
static inline int divik(
    int n,
    s1615 x)
{
    return __LI((__I64(n) << 15) / bitsk(x));
}
 
 
static inline long int divilk(
    long int n,
    s3231 x)
{
    return __LI((__I64(n) << 31) / bitslk(x));
}
 
 
static inline s015 rdivi(
    int i,
    int j)
{
    return rbits((int_r_t) ((__I64(i) << 15) / __I64(j)));
}
 
 
static inline s031 lrdivi(
    long int i,
    long int j)
{
    return lrbits((int_lr_t) ((__I64(i) << 31) / __I64(j)));
}
 
 
static inline s1615 kdivi(
    int i,
    int j)
{
    return kbits((int_k_t) ((__I64(i) << 15) / __I64(j)));
}
 
 
static inline s3231 lkdivi(
    long int i,
    long int j)
{
    return lkbits((int_lk_t) ((__I64(i) << 31) / __I64(j)));
}
 
 
static inline int idivr(
    s015 x,
    s015 y)
{
    return __I(rbits(x) / rbits(y));
}
 
 
static inline long int idivlr(
    s031 x,
    s031 y)
{
    return __LI(lrbits(x) / lrbits(y));
}
 
 
static inline int idivk(
    s1615 x,
    s1615 y)
{
    return __I(kbits(x) / kbits(y));
}
 
 
static inline long int idivlk(
    s3231 x,
    s3231 y)
{
    return __LI(lkbits(x) / lkbits(y));
}
 
 
static inline unsigned int muliur(
    unsigned int n,
    u016 x)
{
    return __UI((__U64(n) * __U64(bitsur(x))) >> 16);
}
 
 
static inline unsigned long int muliulr(
    unsigned long int n,
    u032 x)
{
    return __ULI((__U64(n) * __U64(bitsulr(x))) >> 32);
}
 
 
static inline unsigned int muliuk(
    unsigned int n,
    u1616 x)
{
    return __UI(__U64(n) * __U64(bitsuk(x)) >> 16);
}
 
 
static inline unsigned long int muliulk(
    unsigned long int n,
    u3232 x)
{
    uint64_t r = bitsulk(x);
    uint64_t k = __U64(n) * (r >> 32);
    uint64_t c = (__U64(n) * (r & INT64_C(0xFFFFFFF))) >> 32;
 
    return __ULI(k + c);
}
 
 
static inline unsigned int diviur(
    unsigned int n,
    u016 x)
{
    return __UI((__U64(n) << 16) / bitsur(x));
}
 
 
static inline unsigned long int diviulr(
    unsigned long int n,
    u032 x)
{
    return __ULI((__U64(n) << 32) / bitsulr(x));
}
 
 
static inline unsigned int diviuk(
    unsigned int n,
    u1616 x)
{
    return __ULI((__U64(n) << 16) / bitsuk(x));
}
 
 
static inline unsigned long int diviulk(
    unsigned long int n,
    u3232 x)
{
    return __ULI((__U64(n) << 32) / bitsulk(x));
}
 
 
static inline u016 urdivi(
    unsigned int i,
    unsigned int j)
{
    return ulrbits((uint_ulr_t) ((__U64(i) << 16) / __U64(j)));
}
 
 
static inline u032 ulrdivi(
    unsigned long int i,
    unsigned long int j)
{
    return ulrbits((uint_ulr_t) ((__U64(i) << 32) / __U64(j)));
}
 
 
static inline u1616 ukdivi(
    unsigned int i,
    unsigned int j)
{
    return ukbits((uint_uk_t) ((__U64(i) << 16) / __U64(j)));
}
 
 
static inline u3232 ulkdivi(
    unsigned long int i,
    unsigned long int j)
{
    return ulkbits((uint_ulk_t) ((__U64(i) << 32) / __U64(j)));
}
 
 
static inline unsigned int idivur(
    u016 x,
    u016 y)
{
    return __UI(urbits(x) / urbits(y));
}
 
 
static inline unsigned long int idivulr(
    u032 x,
    u032 y)
{
    return __ULI(ulrbits(x) / ulrbits(y));
}
 
 
static inline unsigned int idivuk(
    u1616 x,
    u1616 y)
{
    return __UI(ukbits(x) / ukbits(y));
}
 
 
static inline unsigned long int idivulk(
    u3232 x,
    u3232 y)
{
    return __ULI(ulkbits(x) / ulkbits(y));
}
 
 
 
static inline s07 abshr(
    s07 f)
{
    int_hr_t r = bitshr(f);
 
    if (r < 0) {
    r = (r == INT8_MIN) ? INT8_MAX : -r;
    }
 
    return hrbits(r);
}
 
 
static inline s015 absr(
    s015 f)
{
    int_r_t r = bitsr(f);
 
    if (r < 0) {
    r = (r == INT16_MIN) ? INT16_MAX : -r;
    }
 
    return rbits(r);
}
 
 
static inline s031 abslr(
    s031 f)
{
    int_lr_t r = bitslr(f);
 
    if (r < 0) {
    r = (r == INT32_MIN) ? INT32_MAX : -r;
    }
 
    return lrbits(r);
}
 
 
static inline s87 abshk(
    s87 f)
{
    int_hk_t r = bitshk(f);
 
    if (r < 0) {
    r = (r == INT16_MIN) ? INT16_MAX : -r;
    }
 
    return hkbits(r);
}
 
 
static inline s1615 absk(
    s1615 f)
{
    int_k_t r = bitsk(f);
 
    if (r < 0) {
    r = (r == INT32_MIN) ? INT32_MAX : -r;
    }
 
    return kbits(r);
}
 
 
static inline s3231 abslk(
    s3231 f)
{
    int_lk_t r = bitslk(f);
 
    if (r < 0) {
    r = (r == INT64_MIN) ? INT64_MAX : -r;
    }
 
    return lkbits(r);
}
 
 
 
static inline uint8_t __stdfix_round_u8(
    uint8_t x,
    int n)
{
    register uint8_t r, c;
 
    c = (x >> (n-1)) & 0x1;
    r = x >> n;
    r = (r + c) << n;
 
    return r;
}
 
 
static inline uint16_t __stdfix_round_u16(
    uint16_t x,
    int n)
{
    register uint16_t r, c;
 
    c = (x >> (n-1)) & 0x1;
    r = x >> n;
    r = (r + c) << n;
 
    return r;
}
 
 
static inline uint32_t __stdfix_round_u32(
    uint32_t x,
    int n)
{
    register uint32_t r, c;
 
    c = (x >> (n-1)) & 0x1;
    r = x >> n;
    r = (r + c) << n;
 
    return r;
}
 
 
static inline uint64_t __stdfix_round_u64(
    uint64_t x,
    int n)
{
    register uint64_t r, c;
 
    c = (x >> (n-1)) & 0x1;
    r = x >> n;
    r = (r + c) << n;
 
    return r;
}
 
 
static inline int8_t __stdfix_round_s8(
    int8_t x,
    int n)
{
    register int8_t r, c;
 
    c = (x >> (n-1)) & 0x1;
    r = x >> n;
    r = (r + c) << n;
 
    return r;
}
 
 
static inline int16_t __stdfix_round_s16(
    int16_t x,
    int n)
{
    register int16_t r, c;
 
    c = (x >> (n-1)) & 0x1;
    r = x >> n;
    r = (r + c) << n;
 
    return r;
}
 
 
static inline int32_t __stdfix_round_s32(
    int32_t x,
    int n)
{
    register int32_t r, c;
 
    c = (x >> (n-1)) & 0x1;
    r = x >> n;
    r = (r + c) << n;
 
    return r;
}
 
 
static inline int64_t __stdfix_round_s64(
    int64_t x,
    int n)
{
    register int64_t r, c;
 
    c = (x >> (n-1)) & 0x1;
    r = x >> n;
    r = (r + c) << n;
 
    return r;
}
 
 
static inline s07 roundhr(
    s07 f,
    int n)
{
    return hrbits(__stdfix_round_s8(bitshr(f), n));
}
 
 
static inline s015 roundr(
    s015 f,
    int n)
{
    return rbits(__stdfix_round_s16(bitsr(f), n));
}
 
 
static inline s031 roundlr(
    s031 f,
    int n)
{
    return lrbits(__stdfix_round_s32(bitslr(f), n));
}
 
 
static inline s87 roundhk(
    s87 f,
    int n)
{
    return hkbits(__stdfix_round_s16(bitshk(f), n));
}
 
 
static inline s1615 roundk(
    s1615 f,
    int n)
{
    return kbits(__stdfix_round_s32(bitsk(f), n));
}
 
 
static inline s3231 roundlk(
    s3231 f,
    int n)
{
    return lkbits(__stdfix_round_s64(bitslk(f), n));
}
 
 
static inline u08 rounduhr(
    u08 f,
    int n)
{
    return uhrbits(__stdfix_round_u8(bitsuhr(f), n));
}
 
 
static inline u016 roundur(
    u016 f,
    int n)
{
    return urbits(__stdfix_round_u16(bitsur(f), n));
}
 
 
static inline u032 roundulr(
    u032 f,
    int n)
{
    return ulrbits(__stdfix_round_u32(bitsulr(f), n));
}
 
 
static inline u88 rounduhk(
    u88 f,
    int n)
{
    return uhkbits(__stdfix_round_u16(bitsuhk(f), n));
}
 
 
static inline u1616 rounduk(
    u1616 f,
    int n)
{
    return ukbits(__stdfix_round_u32(bitsuk(f), n));
}
 
 
static inline u3232 roundulk(
    u3232 f,
    int n)
{
    return ulkbits(__stdfix_round_u64(bitsulk(f), n));
}
 
 
 
static inline int countlshr(
    s07 f)
{
    int32_t n = __I32(bitshr(f));
 
    if (n == 0) {
    return 7;
    }
 
    return __builtin_clrsb(n) - 24;
}
 
 
static inline int countlsr(
    s015 f)
{
    int32_t n = __I32(bitsr(f));
 
    if (n == 0) {
    return 15;
    }
 
    return __builtin_clrsb(n) - 16;
}
 
 
static inline int countlslr(
    s031 f)
{
    int_lr_t n = bitslr(f);
 
    if (n == 0) {
    return 31;
    }
 
    return __builtin_clrsb(n);
}
 
 
static inline int countlshk(
    s87 f)
{
    int32_t n = __I32(bitshk(f));
 
    if (n == 0) {
    return 15;
    }
 
    return __builtin_clrsb(n) - 16;
}
 
 
static inline int countlsk(
    s1615 f)
{
    int_k_t n = bitsk(f);
 
    if (n == 0) {
    return 31;
    }
 
    return __builtin_clrsb(n);
}
 
 
static inline int countlslk(
    s3231 f)
{
    int64_t n = __I64(bitslk(f));
 
    if (n == 0) {
    return 63;
    }
 
    return __builtin_clrsbll(n);
}
 
 
static inline int countlsuhr(
    u08 f)
{
    uint32_t n = __U32(bitsuhr(f));
 
    if (n == 0) {
    return 8;
    }
 
    return __builtin_clz(n) - 24;
}
 
 
static inline int countlsur(
    u016 f)
{
    uint32_t n = __U32(bitsur(f));
 
    if (n == 0) {
    return 16;
    }
 
    return __builtin_clz(n) - 16;
}
 
 
static inline int countlsulr(
    u032 f)
{
    uint_ulr_t n = bitsulr(f);
 
    if (n == 0) {
    return 32;
    }
 
    return __builtin_clz(n);
}
 
 
static inline int countlsuhk(
    u88 f)
{
    uint32_t n = __U32(bitsuhk(f));
 
    if (n == 0) {
    return 16;
    }
 
    return __builtin_clz(n) - 16;
}
 
 
static inline int countlsuk(
    u1616 f)
{
    uint_uk_t n = (uint_uk_t) bitsuk(f);
 
    if (n == 0) {
    return 32;
    }
 
    return __builtin_clz(n);
}
 
 
static inline int countlsulk(
    u3232 f)
{
    uint_ulk_t n = (uint_ulk_t) bitsulk(f);
 
    if (n == 0) {
    return 64;
    }
 
    return __builtin_clzll(n);
}
 
 
 
#define absfx(f) \
    _Generic((f), \
    s07:   abshr(f), \
    s015:  absr(f), \
    s031:  abslr(f), \
    s87:   abshk(f), \
    s1615: absk(f), \
    s3231: abslk(f), \
    default: abort() \
    )
 
 
#define roundfx(f, n) \
    _Generic((f), \
    s07:   roundhr(f, n), \
    s015:  roundr(f, n), \
    s031:  roundlr(f, n), \
    s87:   roundhk(f, n), \
    s1615: roundk(f, n), \
    s3231: roundlk(f, n), \
    u08:   rounduhr(f, n), \
    u016:  roundur(f, n), \
    u032:  roundulr(f, n), \
    u88:   rounduhk(f, n), \
    u1616: rounduk(f, n), \
    u3232: roundulk(f, n), \
    default: abort() \
    )
 
 
#define countlsfx(f) \
    _Generic((f), \
    s07:   countlshr(f), \
    s015:  countlsr(f), \
    s031:  countlslr(f), \
    s87:   countlshk(f), \
    s1615: countlsk(f), \
    s3231: countlslk(f), \
    u08:   countlsuhr(f), \
    u016:  countlsur(f), \
    u032:  countlsulr(f), \
    u88:   countlsuhk(f), \
    u1616: countlsuk(f), \
    u3232: countlsulk(f), \
    default: abort() \
    )
 
 
#ifndef __arm__
s07   strtofxhr (const char *restrict nptr, char **restrict endptr);
s015  strtofxr  (const char *restrict nptr, char **restrict endptr);
s031  strtofxlr (const char *restrict nptr, char **restrict endptr);
s87   strtofxhk (const char *restrict nptr, char **restrict endptr);
s1615 strtofxk  (const char *restrict nptr, char **restrict endptr);
s3231 strtofxlk (const char *restrict nptr, char **restrict endptr);
 
u08   strtofxuhr(const char *restrict nptr, char **restrict endptr);
u016  strtofxur (const char *restrict nptr, char **restrict endptr);
u032  strtofxulr(const char *restrict nptr, char **restrict endptr);
u88   strtofxuhk(const char *restrict nptr, char **restrict endptr);
u1616 strtofxuk (const char *restrict nptr, char **restrict endptr);
u3232 strtofxulk(const char *restrict nptr, char **restrict endptr);
#endif /*__arm__*/
 
 
#endif /* __STDFIX_FULL_ISO_H__ */