u8x24.h

Go to the documentation of this file.

#pragma once
 
// Unsigned 8.24 fixed-point arithmetic.
// All operations are integer-only in the hot path.
// Range: [0, 256) with 24 fractional bits.
 
#include "fl/stl/int.h"
#include "fl/math/fixed_point/isqrt.h"
#include "fl/stl/compiler_control.h"
#include "fl/math/fixed_point/traits.h"
#include "fl/stl/undef.h"  // Undefine abs/min/max macros from Arduino.h
#include "fl/stl/noexcept.h"
 
FL_OPTIMIZATION_LEVEL_O3_BEGIN
 
namespace fl {
 
// Unsigned 8.24 fixed-point value type.
class u8x24 {
  public:
    static constexpr int INT_BITS = 8;
    static constexpr int FRAC_BITS = 24;
    static constexpr i32 SCALE = static_cast<i32>(1) << FRAC_BITS;
 
    // ---- Construction ------------------------------------------------------
 
    constexpr u8x24() FL_NOEXCEPT = default;
 
    explicit constexpr u8x24(float f) FL_NOEXCEPT
        : mValue(static_cast<u32>(f * (SCALE))) {}
 
    // Integer constructor — any integer width (portable: AVR 16-bit int, ARM/x86 32-bit).
    // Compile error if constexpr value exceeds INT_BITS range.
    template <typename IntT, detail::enable_if_integer_t<IntT> = 0>
    explicit constexpr u8x24(IntT n) FL_NOEXCEPT
        : mValue(detail::int_to_fixed<INT_BITS, FRAC_BITS>::from_unsigned(n)) {}
 
    // Auto-promotion from other fixed-point types
    template <typename OtherFP>
    constexpr u8x24(const OtherFP& other,
                    typename fl::enable_if<
                        (OtherFP::INT_BITS <= INT_BITS) &&
                        (OtherFP::FRAC_BITS <= FRAC_BITS) &&
                        (OtherFP::INT_BITS != INT_BITS || OtherFP::FRAC_BITS != FRAC_BITS),
                        int>::type = 0)
 FL_NOEXCEPT : mValue(static_cast<u32>(
            static_cast<u64>(other.raw()) << (FRAC_BITS - OtherFP::FRAC_BITS))) {}
 
    // Raw constructor for C++11 constexpr from_raw
    struct RawTag {};
    constexpr explicit u8x24(u32 raw, RawTag) FL_NOEXCEPT : mValue(raw) {}
 
    static constexpr FASTLED_FORCE_INLINE u8x24 from_raw(u32 raw) FL_NOEXCEPT {
        return u8x24(raw, RawTag());
    }
 
    // ---- Access ------------------------------------------------------------
 
    constexpr u32 raw() const FL_NOEXCEPT { return mValue; }
    constexpr u32 to_int() const FL_NOEXCEPT { return mValue >> FRAC_BITS; }
    constexpr float to_float() const FL_NOEXCEPT { return static_cast<float>(mValue) / (SCALE); }
 
    // ---- Fixed-point arithmetic --------------------------------------------
 
    constexpr FASTLED_FORCE_INLINE u8x24 operator*(u8x24 b) const FL_NOEXCEPT {
        return from_raw(static_cast<u32>(
            (static_cast<u64>(mValue) * b.mValue) >> FRAC_BITS));
    }
 
    constexpr FASTLED_FORCE_INLINE u8x24 operator/(u8x24 b) const FL_NOEXCEPT {
        return from_raw(static_cast<u32>(
            (static_cast<u64>(mValue) * (static_cast<u64>(1) << FRAC_BITS)) / b.mValue));
    }
 
    constexpr FASTLED_FORCE_INLINE u8x24 operator+(u8x24 b) const FL_NOEXCEPT {
        return from_raw(mValue + b.mValue);
    }
 
    constexpr FASTLED_FORCE_INLINE u8x24 operator-(u8x24 b) const FL_NOEXCEPT {
        return from_raw(mValue - b.mValue);
    }
 
    constexpr FASTLED_FORCE_INLINE u8x24 operator>>(int shift) const FL_NOEXCEPT {
        return from_raw(mValue >> shift);
    }
 
    constexpr FASTLED_FORCE_INLINE u8x24 operator<<(int shift) const FL_NOEXCEPT {
        return from_raw(mValue << shift);
    }
 
    // ---- Scalar multiply (no fixed-point shift) ----------------------------
 
    constexpr FASTLED_FORCE_INLINE u8x24 operator*(u32 scalar) const FL_NOEXCEPT {
        return from_raw(mValue * scalar);
    }
 
    friend constexpr u8x24 operator*(u32 scalar, u8x24 fp) FL_NOEXCEPT {
        return u8x24::from_raw(scalar * fp.mValue);
    }
 
    // ---- Comparisons -------------------------------------------------------
 
    constexpr bool operator<(u8x24 b) const FL_NOEXCEPT { return mValue < b.mValue; }
    constexpr bool operator>(u8x24 b) const FL_NOEXCEPT { return mValue > b.mValue; }
    constexpr bool operator<=(u8x24 b) const FL_NOEXCEPT { return mValue <= b.mValue; }
    constexpr bool operator>=(u8x24 b) const FL_NOEXCEPT { return mValue >= b.mValue; }
    constexpr bool operator==(u8x24 b) const FL_NOEXCEPT { return mValue == b.mValue; }
    constexpr bool operator!=(u8x24 b) const FL_NOEXCEPT { return mValue != b.mValue; }
 
    // ---- Math ---------------------------------------------------------------
 
    static constexpr FASTLED_FORCE_INLINE u8x24 mod(u8x24 a, u8x24 b) FL_NOEXCEPT {
        return from_raw(a.mValue % b.mValue);
    }
 
    static constexpr FASTLED_FORCE_INLINE u8x24 floor(u8x24 x) FL_NOEXCEPT {
        return from_raw(x.mValue & ~(u32((SCALE) - 1)));
    }
 
    static constexpr FASTLED_FORCE_INLINE u8x24 ceil(u8x24 x) FL_NOEXCEPT {
        return from_raw((x.mValue & ~(u32((SCALE) - 1))) +
                        ((x.mValue & u32((SCALE) - 1)) ? (SCALE) : 0));
    }
 
    static constexpr FASTLED_FORCE_INLINE u8x24 fract(u8x24 x) FL_NOEXCEPT {
        return from_raw(x.mValue & u32((SCALE) - 1));
    }
 
    static constexpr FASTLED_FORCE_INLINE u8x24 min(u8x24 a, u8x24 b) FL_NOEXCEPT {
        return a.mValue < b.mValue ? a : b;
    }
 
    static constexpr FASTLED_FORCE_INLINE u8x24 max(u8x24 a, u8x24 b) FL_NOEXCEPT {
        return a.mValue > b.mValue ? a : b;
    }
 
    static constexpr FASTLED_FORCE_INLINE u8x24 lerp(u8x24 a, u8x24 b, u8x24 t) FL_NOEXCEPT {
        return a + (b - a) * t;
    }
 
    static constexpr FASTLED_FORCE_INLINE u8x24 clamp(u8x24 x, u8x24 lo, u8x24 hi) FL_NOEXCEPT {
        return x < lo ? lo : (x > hi ? hi : x);
    }
 
    static constexpr FASTLED_FORCE_INLINE u8x24 step(u8x24 edge, u8x24 x) FL_NOEXCEPT {
        return x < edge ? u8x24() : u8x24(1.0f);
    }
 
    static FASTLED_FORCE_INLINE u8x24 smoothstep(u8x24 edge0, u8x24 edge1, u8x24 x) FL_NOEXCEPT {
        constexpr u8x24 zero(0.0f);
        constexpr u8x24 one(1.0f);
        constexpr u8x24 two(2.0f);
        constexpr u8x24 three(3.0f);
        u8x24 t = clamp((x - edge0) / (edge1 - edge0), zero, one);
        return t * t * (three - two * t);
    }
 
    static constexpr FASTLED_FORCE_INLINE u8x24 sqrt(u8x24 x) FL_NOEXCEPT {
        return x.mValue == 0 ? u8x24() : from_raw(static_cast<u32>(
            fl::isqrt64(static_cast<u64>(x.mValue) << FRAC_BITS)));
    }
 
    static constexpr FASTLED_FORCE_INLINE u8x24 rsqrt(u8x24 x) FL_NOEXCEPT {
        return sqrt(x).mValue == 0
            ? u8x24()
            : from_raw(static_cast<u32>(1) << FRAC_BITS) / sqrt(x);
    }
 
    static FASTLED_FORCE_INLINE u8x24 pow(u8x24 base, u8x24 exp) FL_NOEXCEPT {
        if (base.mValue == 0) return u8x24();
        constexpr u8x24 one(1.0f);
        if (exp.mValue == 0) return one;
        if (base == one) return one;
        // Snap base values within ~2 ULPs of 1.0 to exactly 1.0 to dodge the
        // log2(1+t) minimax polynomial's upper-endpoint residual (#2969).
        constexpr u32 kOneRaw = static_cast<u32>(SCALE);
        if (base.mValue >= (kOneRaw - 2u) && base.mValue <= kOneRaw) {
            return one;
        }
        return exp2_fp(exp * log2_fp(base));
    }
 
  private:
    u32 mValue = 0;
 
    // Returns 0-based position of highest set bit, or -1 if v==0.
    static constexpr FASTLED_FORCE_INLINE int highest_bit(u32 v) FL_NOEXCEPT {
        return v == 0 ? -1 : _highest_bit_step(v, 0);
    }
 
    static constexpr int _highest_bit_step(u32 v, int r) FL_NOEXCEPT {
        return (v & 0xFFFF0000u) ? _highest_bit_step(v >> 16, r + 16)
             : (v & 0x0000FF00u) ? _highest_bit_step(v >> 8,  r + 8)
             : (v & 0x000000F0u) ? _highest_bit_step(v >> 4,  r + 4)
             : (v & 0x0000000Cu) ? _highest_bit_step(v >> 2,  r + 2)
             : (v & 0x00000002u) ? r + 1
             : r;
    }
 
    // Fixed-point log base 2 for positive values.
    // Uses 4-term minimax polynomial for log2(1+t), t in [0,1).
    static FASTLED_FORCE_INLINE u8x24 log2_fp(u8x24 x) FL_NOEXCEPT {
        u32 val = x.mValue;
        int msb = highest_bit(val);
        if (msb < 0) return u8x24(); // log2(0) = -inf, return 0
 
        u32 int_part = msb - FRAC_BITS;
        u32 t;
        if (msb >= FRAC_BITS) {
            t = (val >> (msb - FRAC_BITS)) - (SCALE);
        } else {
            t = (val << (FRAC_BITS - msb)) - (SCALE);
        }
 
        // 4-term minimax coefficients for log2(1+t), t in [0,1).
        constexpr int IFRAC = 24;
        constexpr u64 c0 = 24189248ULL;  // 1.44179 * 2^24
        constexpr i64 c1 = -11728384LL;  // -0.69907 * 2^24
        constexpr i64 c2 = 6098176LL;    // 0.36348 * 2^24
        constexpr i64 c3 = -1788416LL;   // -0.10660 * 2^24
 
        i64 t24 = static_cast<i64>(t);
        // Horner: t * (c0 + t * (c1 + t * (c2 + t * c3)))
        i64 acc = c3;
        acc = c2 + ((acc * t24) >> IFRAC);
        acc = c1 + ((acc * t24) >> IFRAC);
        acc = static_cast<i64>(c0) + ((acc * t24) >> IFRAC);
        i64 frac_part = (acc * t24) >> IFRAC;
 
        // Combine integer and fractional parts
        i64 result = (static_cast<i64>(int_part) << FRAC_BITS) + frac_part;
        return from_raw(result >= 0 ? static_cast<u32>(result) : 0);
    }
 
    // Fixed-point 2^x. Uses 4-term minimax polynomial for 2^t, t in [0,1).
    static FASTLED_FORCE_INLINE u8x24 exp2_fp(u8x24 x) FL_NOEXCEPT {
        u8x24 fl_val = floor(x);
        u8x24 fr = x - fl_val;
        u32 n = fl_val.mValue >> FRAC_BITS;
 
        // Prevent overflow
        if (n >= INT_BITS) return from_raw(0xFFFFFFFFu);
 
        u32 int_pow = static_cast<u32>(SCALE) << n;
 
        // 4-term minimax coefficients for 2^t - 1, t in [0,1).
        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
 
        u64 fr24 = static_cast<u64>(fr.mValue);
        // 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);
 
        // Scale by int_pow (result stays at 24 frac bits).
        u64 result = (static_cast<u64>(int_pow) * frac_pow24) >> FRAC_BITS;
        return from_raw(static_cast<u32>(result));
    }
};
 
} // namespace fl
 
FL_OPTIMIZATION_LEVEL_O3_END