pico_float

Optimized single-precision floating point functions.

Optimized single-precision floating point functions.

An application can take control of the floating point routines used in the application over and above what is provided by the compiler, by depending on the pico_float library. A user might want to do this

1. To use optimized software implementations provided by the RP2-series device's bootrom or the SDK
2. To use optimized combined software/hardware implementations utilizing custom RP2-series hardware for acceleration
3. To control the amount of C compiler/library code bloat
4. To make sure no floating point is called at all

The pico_float library comes in three main flavors:

1. pico_float_none - all floating point operations cause a panic - no single-precision floating point code is included
2. pico_float_compiler - no custom functions are provided; all single-precision floating point is handled by the C compiler/library
3. pico_float_pico - the smallest and fastest available for the platform, along with additional functionality (e.g. fixed point conversions) which are detailed below

The user can control which version they want (e.g. pico_float_xxx by either setting the CMake global variable PICO_DEFAULT_FLOAT_IMPL=xxx, or by using the CMake function pico_set_float_implementation(<TARGET> xxx). Note that in the absence of either, pico_float_pico is used by default.

On RP2040, pico_float_pico uses optimized hand coded implementations from the bootrom and the SDK for both basic single-precision floating point operations and floating point math library functions. These implementations are generally faster and smaller than those provided by the C compiler/library, though they don't support all the features of a fully compliant floating point implementation; they are however usually fine for the majority of cases

On Arm, (replacement) optimized implementations are provided for the following compiler built-ins and math library functions when using _pico variants of pico_float:

• basic arithmetic: (except pico_float_pico_vfp)

  __aeabi_fadd, __aeabi_fdiv, __aeabi_fmul, __aeabi_frsub, __aeabi_fsub

• comparison: (except pico_float_pico_vfp)

  __aeabi_cfcmpeq, __aeabi_cfrcmple, __aeabi_cfcmple, __aeabi_fcmpeq, __aeabi_fcmplt, __aeabi_fcmple, __aeabi_fcmpge, __aeabi_fcmpgt, __aeabi_fcmpun

• (u)int32 <-> float: (except pico_float_pico_vfp)

  __aeabi_i2f, __aeabi_ui2f, __aeabi_f2iz, __aeabi_f2uiz

• (u)int64 <-> float: (except pico_float_pico_vfp)

  __aeabi_l2f, __aeabi_ul2f, __aeabi_f2lz, __aeabi_f2ulz

• float -> double: (except pico_float_pico_vfp)

  __aeabi_f2d

• basic trigonometric:

  sqrtf, cosf, sinf, tanf, atan2f, expf, logf

• trigonometric and scientific

  ldexpf, copysignf, truncf, floorf, ceilf, roundf, asinf, acosf, atanf, sinhf, coshf, tanhf, asinhf, acoshf, atanhf, exp2f, log2f, exp10f, log10f, powf, hypotf, cbrtf, fmodf, dremf, remainderf, remquof, expm1f, log1pf, fmaf

• GNU exetnsions:

  powintf, sincosf

On Arm, the following additional optimized functions are also provided (when using _pico variants of pico_float):

• Conversions to/from integer types:

  • (u)int -> float (round to nearest):

    int2float, uint2float, int642float, uint642float

    note: on pico_float_pico_vfp the 32-bit functions are also provided as C macros since they map to inline VFP code

  • (u)float -> int (round towards zero):

    float2int_z, float2uint_z, float2int64_z, float2uint64_z

    note: on pico_float_pico_vfp the 32-bit functions are also provided as C macros since they map to inline VFP code

  • (u)float -> int (round towards -infinity):

    float2int, float2uint, float2int64, float2uint64

• Conversions to/from fixed point integers:

  • (u)fix -> float (round to nearest):

    fix2float, ufix2float, fix642float, ufix642float

  • float -> (u)fix (round towards zero):

    float2fix_z, float2ufix_z, float2fix64_z, float2ufix64_z

    note: on pico_float_pico_vfp the 32-bit functions are also provided as C macros since they can map to inline VFP code when the number of fractional bits is a compile time constant between 1 and 32

  • float -> (u)fix (round towards -infinity):

    float2fix, float2ufix, float2fix64, float2ufix64

    note: on pico_float_pico_vfp the 32-bit functions are also provided as C macros since they can map to inline VFP code when the number of fractional bits is a compile time constant between 1 and 32

• Even faster versions of divide and square-root functions that do not round correctly: (pico_float_pico_dcp only)

  fdiv_fast, sqrtf_fast