exp2_fp()

static FASTLED_FORCE_INLINE u16x16 fl::u16x16::exp2_fp ( u16x16 x )

inlinestaticprivate

Definition at line 264 of file u16x16.h.

                                                                      {
        u16x16 fl_val = floor(x);
        u16x16 fr = x - fl_val;
        u32 n = fl_val.mValue >> FRAC_BITS;
 
        if (n >= INT_BITS) return from_raw(0xFFFFFFFF);  // overflow
 
        u32 int_pow = (SCALE) << n;
 
        // 4-term minimax coefficients for 2^t - 1, t in [0,1).
        // Stored as u64 with 24 fractional bits.
        constexpr int IFRAC = 24;
        constexpr u64 d0 = 11629376ULL;  // 0.69316 * 2^24
        constexpr u64 d1 = 4038400ULL;   // 0.24071 * 2^24
        constexpr u64 d2 = 895232ULL;    // 0.05336 * 2^24
        constexpr u64 d3 = 214016ULL;    // 0.01276 * 2^24
 
        // Extend fr from 16 to 24 frac bits.
        u64 fr24 = static_cast<u64>(fr.mValue) << (IFRAC - FRAC_BITS);
 
        // Horner: 1 + fr * (d0 + fr * (d1 + fr * (d2 + fr * d3)))
        u64 acc = d3;
        acc = d2 + ((acc * fr24) >> IFRAC);
        acc = d1 + ((acc * fr24) >> IFRAC);
        acc = d0 + ((acc * fr24) >> IFRAC);
        constexpr u64 one24 = 1ULL << IFRAC;
        u64 frac_pow24 = one24 + ((acc * fr24) >> IFRAC);
 
        // Convert from 24 frac bits to 16 frac bits, then scale by int_pow.
        u32 frac_pow16 = static_cast<u32>(frac_pow24 >> (IFRAC - FRAC_BITS));
        u64 result = (static_cast<u64>(int_pow) * frac_pow16) >> FRAC_BITS;
        return from_raw(static_cast<u32>(result));
    }

References u16x16(), FASTLED_FORCE_INLINE, fl::FL_NO_EXCEPT, floor(), FRAC_BITS, from_raw(), INT_BITS, mValue, SCALE, and fl::x.

Referenced by pow().

Here is the call graph for this function:

Here is the caller graph for this function: