float.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _PICO_FLOAT_H
#define _PICO_FLOAT_H

 
#include "pico.h"
 
// PICO_CONFIG: PICO_FLOAT_IN_RAM, Force placement of SDK provided single-precision floating point code into RAM, type=bool, default=0, group=pico_float
#ifndef PICO_FLOAT_IN_RAM
#define PICO_FLOAT_IN_RAM 0
#endif
 
#if !(LIB_PICO_FLOAT_COMPILER || defined(__riscv)) || PICO_DOCS
// private define to simplify this header only - it is undefined at the end
#define __PICO_FLOAT_ARM_OPTIMIZED 1
#endif

 
// we always define these for C code, but they are inline
// funcs except for __PICO_FLOAT_ARM_OPTIMIZED so wouldn't
// be callable for assembly
#if __PICO_FLOAT_ARM_OPTIMIZED || !defined(__ASSEMBLER__)
#define PICO_FLOAT_HAS_INT32_TO_FLOAT_CONVERSIONS 1
#define PICO_FLOAT_HAS_INT64_TO_FLOAT_CONVERSIONS 1
#define PICO_FLOAT_HAS_FLOAT_TO_INT32_Z_CONVERSIONS 1
#define PICO_FLOAT_HAS_FLOAT_TO_INT64_Z_CONVERSIONS 1
#endif
 
#if __PICO_FLOAT_ARM_OPTIMIZED
#define PICO_FLOAT_HAS_FIX32_TO_FLOAT_CONVERSIONS 1
#define PICO_FLOAT_HAS_FIX64_TO_FLOAT_CONVERSIONS 1
#define PICO_FLOAT_HAS_FLOAT_TO_FIX32_Z_CONVERSIONS 1
#define PICO_FLOAT_HAS_FLOAT_TO_FIX64_Z_CONVERSIONS 1

#define PICO_FLOAT_HAS_FLOAT_TO_INT32_M_CONVERSIONS 1
#define PICO_FLOAT_HAS_FLOAT_TO_INT64_M_CONVERSIONS 1

#define PICO_FLOAT_HAS_FLOAT_TO_FIX32_M_CONVERSIONS 1
#define PICO_FLOAT_HAS_FLOAT_TO_FIX64_M_CONVERSIONS 1
#endif
 
#if (PICO_RP2350 && LIB_PICO_FLOAT_PICO_DCP) || PICO_DOCS
#define PICO_FLOAT_HAS_FDIV_FAST 1
#define PICO_FLOAT_HAS_SQRTF_FAST 1
#endif
 
#if __PICO_FLOAT_ARM_OPTIMIZED || __builtin_powif || PICO_DOCS
#define PICO_FLOAT_HAS_POWINTF 1
#endif
 
#ifndef __ASSEMBLER__
#include <math.h>
#include <float.h>
 
#ifdef __cplusplus
extern "C" {
#endif

#if PICO_FLOAT_HAS_INT32_TO_FLOAT_CONVERSIONS
#if LIB_PICO_FLOAT_PICO_VFP || !__PICO_FLOAT_ARM_OPTIMIZED
    // for VFP the C cast is an assembly instruction anyway, so we prefer that over a function call
    // for non Arm-optimized we may as well provide the function and let the compiler handle it
    static inline float int2float(int32_t i) { return (float)i; }
    static inline float uint2float(uint32_t u) { return (float)u; }
#else
    float int2float(int32_t i);
    float uint2float(uint32_t u);
#endif
#endif
 
#if PICO_FLOAT_HAS_INT64_TO_FLOAT_CONVERSIONS
#if !__PICO_FLOAT_ARM_OPTIMIZED
    // for non Arm-optimized we may as well provide the function and let the compiler handle it
    static inline float int642float(int64_t i) { return (float)i; }
    static inline float uint642float(uint64_t u) { return (float)u; }
#else
    float int642float(int64_t i);
    float uint642float(uint64_t u);
#endif
#endif
 
#if PICO_FLOAT_HAS_FLOAT_TO_INT32_Z_CONVERSIONS
#if !__PICO_FLOAT_ARM_OPTIMIZED
    // for non Arm-optimized we may as well provide the function and let the compiler handle it
    static inline int32_t float2int_z(float f) { return (int32_t)f; }
    static inline uint32_t float2uint_z(float f) { return (uint32_t)f; }
#else
    int32_t float2int_z(float f);
    uint32_t float2uint_z(float f);
#endif
#endif
 
#if PICO_FLOAT_HAS_FLOAT_TO_INT64_Z_CONVERSIONS
#if !__PICO_FLOAT_ARM_OPTIMIZED
    // for non Arm-optimized we may as well provide the function and let the compiler handle it
    static inline int64_t float2int64_z(float f) { return (int64_t)f; }
    static inline uint64_t float2uint64_z(float f) { return (uint64_t)f; }
#else
    int64_t float2int64_z(float f);
    uint64_t float2uint64_z(float f);
#endif
#endif
 
#if PICO_FLOAT_HAS_FIX32_TO_FLOAT_CONVERSIONS
float fix2float(int32_t m, int e);
float ufix2float(uint32_t m, int e);
#endif
 
#if PICO_FLOAT_HAS_FIX64_TO_FLOAT_CONVERSIONS
float fix642float(int64_t m, int e);
float ufix642float(uint64_t m, int e);
#endif
 
#if PICO_FLOAT_HAS_FLOAT_TO_FIX32_Z_CONVERSIONS
int32_t float2fix_z(float f, int e);
uint32_t float2ufix_z(float f, int e);
#endif
 
#if PICO_FLOAT_HAS_FLOAT_TO_FIX64_Z_CONVERSIONS
int64_t float2fix64_z(float f, int e);
uint64_t float2ufix64_z(float f, int e);
#endif
 
// These methods round towards -Infinity - which IS NOT the C way for negative numbers;
// as such the naming is not ideal, however is kept for backwards compatibility
#if PICO_FLOAT_HAS_FLOAT_TO_INT32_M_CONVERSIONS
int32_t float2int(float f);
uint32_t float2uint(float f);
#endif
 
#if PICO_FLOAT_HAS_FLOAT_TO_INT64_M_CONVERSIONS
int64_t float2int64(float f);
uint64_t float2uint64(float f);
#endif
 
#if PICO_FLOAT_HAS_FLOAT_TO_FIX32_M_CONVERSIONS
int32_t float2fix(float f, int e);
uint32_t float2ufix(float f, int e);
#endif
 
#if PICO_FLOAT_HAS_FLOAT_TO_FIX64_M_CONVERSIONS
int64_t float2fix64(float f, int e);
uint64_t float2ufix64(float f, int e);
#endif
 
#if LIB_PICO_FLOAT_PICO_VFP
// special handling of fixed-point conversions for VFP - we want to inline calls with fixed exponents
// between 1 and 32, because they can use an assembly instruction. we leave the function in place
// with its original name, however make a #define which will either do the inline instruction
// or call the original function
#if PICO_FLOAT_HAS_FIX32_TO_FLOAT_CONVERSIONS
// a bit of a hack to inline VFP fixed-point conversion when exponent is constant and in range 1-32
#define fix2float(m, e) (__builtin_constant_p(e) && (e) >= 1 && (e) <= 32 ? _fix2float_inline(m, e) : fix2 ## float(m, e))
#define ufix2float(m, e) (__builtin_constant_p(e) && (e) >= 1 && (e) <= 32 ? _ufix2float_inline(m, e) : ufix2 ## float(m, e))
 
#define _fix2float_inline(m, e) ({ \
    int32_t _m = m; \
    float f; \
    pico_default_asm( \
        "vmov %0, %1\n" \
        "vcvt.f32.s32 %0, %0, %2\n" \
        : "=t" (f) \
        : "r" (_m), "i" (e) \
    ); \
    f; \
})
#define _ufix2float_inline(m, e) ({ \
    uint32_t _m = m; \
    float f; \
    pico_default_asm( \
        "vmov %0, %1\n" \
        "vcvt.f32.u32 %0, %0, %2\n" \
        : "=t" (f) \
        : "r" (_m), "i" (e) \
    ); \
    f; \
})
 
#endif
#if PICO_FLOAT_HAS_FLOAT_TO_FIX32_Z_CONVERSIONS
#define float2fix_z(f, e) (__builtin_constant_p(e) && (e) >= 1 && (e) <= 32 ? _float2fix_z_inline(f, e) : float2 ## fix_z(f, e))
#define float2ufix_z(f, e) (__builtin_constant_p(e) && (e) >= 1 && (e) <= 32 ? _float2ufix_z_inline(f, e) : float2 ## ufix_z(f, e))
 
#define _float2fix_z_inline(f, e) ({ \
    int32_t _m; \
    float _f = (f); \
    pico_default_asm( \
        "vcvt.s32.f32 %0, %0, %2\n" \
        "vmov %1, %0\n" \
        : "+t" (_f), "=r" (_m) \
        : "i" (e) \
    ); \
    _m; \
})
#define _float2ufix_z_inline(f, e) ({ \
    uint32_t _m; \
    float _f = (f); \
    pico_default_asm( \
        "vcvt.u32.f32 %0, %0, %2\n" \
        "vmov %1, %0\n" \
        : "+t" (_f), "=r" (_m) \
        : "i" (e) \
    ); \
    _m; \
})
 
#endif
#if PICO_FLOAT_HAS_FLOAT_TO_FIX32_M_CONVERSIONS
#define float2fix(f, e) (__builtin_constant_p(e) && (e) >= 1 && (e) <= 32 ? _float2fix_inline(f, e) : float2 ## fix(f, e))
#define float2ufix(f, e) (__builtin_constant_p(e) && (e) >= 1 && (e) <= 32 ? _float2ufix_inline(f, e) : float2 ## ufix(f, e))
 
#define _float2fix_inline(f, e) ({ \
    union { float _f; int32_t _i; } _u; \
    _u._f = (f); \
    uint rc, tmp; \
    pico_default_asm( \
        "vcvt.s32.f32 %0, %0, %4\n" \
        "vmov %2, %0\n" \
        "lsls %1, #1\n" \
        "bls 2f\n" /* positive or zero or -zero are ok with the result we have */ \
        "lsrs %3, %1, #24\n" \
        "subs %3, #0x7f - %c4\n" \
        "bcc 1f\n" /* 0 < abs(f) < 1 ^ e, so need to round down */ \
        /* mask off all but fractional bits */ \
        "lsls %1, %3\n" \
        "lsls %1, #8\n" \
        "beq 2f\n" /* integers can round towards zero */ \
        "1:\n" \
        /* need to subtract 1 from the result to round towards -infinity... */ \
        /* this will never cause an overflow, because to get here we must have had a non integer/infinite value which */ \
        /* therefore cannot have been equal to INT64_MIN when rounded towards zero */ \
        "subs %2, #1\n" \
        "2:\n" \
        : "+t" (_u._f), "+r" (_u._i), "=r" (rc), "=r" (tmp) \
        : "i" (e) \
    ); \
    rc; \
})
#define _float2ufix_inline(f, e) _float2ufix_z_inline((f), (e))
#endif
#endif
 
    // exp10f doesn't always appear in math.h but is present on all our platforms even for LIB_PICO_FLOAT_COMPILER
    // so we declare it here always

    float exp10f(float x);
 
    // sincosf doesn't always appear in math.h but is present on all our platforms even for LIB_PICO_FLOAT_COMPILER
    // so we declare it here always
#if __PICO_FLOAT_ARM_OPTIMIZED && PICO_C_COMPILER_IS_CLANG
    // clang unhelpfully splits sincosf into explict calls to sin & cos
    extern void WRAPPER_FUNC(sincosf)(float x, float *sinx, float *cosx);
    #define sincosf(x, sinx, cosx) WRAPPER_FUNC(sincosf)(x, sinx, cosx)
#else
    void sincosf(float x, float *sinx, float *cosx);
#endif
 
#if PICO_FLOAT_HAS_POWINTF
#if !__PICO_FLOAT_ARM_OPTIMIZED && __has_builtin(__builtin_powif)
    static __force_inline float powintf(float f, int32_t p) {
        return __builtin_powif(f, p);
    }
#else
    float powintf(float x, int32_t y);
#endif
#endif
 
#if PICO_FLOAT_HAS_FDIV_FAST
float fdiv_fast(float n, float d);
#endif
 
#if PICO_FLOAT_HAS_SQRTF_FAST
float sqrtf_fast(float f);
#endif
 
#undef __PICO_FLOAT_ARM_OPTIMIZED
 
#ifdef __cplusplus
}
#endif
 
#endif
 
#endif