Fixed16.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_FIXED16_HXX_
#define _UTILS_FIXED16_HXX_
 
#include <stdint.h>
 
#include "utils/macros.h"
 
class Fixed16
{
public:
    constexpr Fixed16(int16_t integer, uint16_t frac = 0)
        : value_(((integer < 0 ? -integer : integer) << 16) | frac)
        , sign_(integer < 0 ? 1 : 0)
    {
    }
 
    enum FromDouble
    {
        FROM_DOUBLE
    };
 
    constexpr Fixed16(FromDouble, double value)
        : value_(value < 0 ? -value * 65536 + 0.5 : value * 65536 + 0.5)
        , sign_(value < 0 ? 1 : 0)
    {
        // it would be nice to make this work:
        // static_assert(value < 32767 && value > -32767,
        //   "fixed16 constructor out of range");
    }
    
    Fixed16(const Fixed16 &o) = default;
    Fixed16 &operator=(const Fixed16 &o) = default;
 
    Fixed16 &operator+=(Fixed16 o)
    {
        from_int(to_int() + o.to_int());
        return *this;
    }
 
    template <class T> Fixed16 operator+(T o) const
    {
        Fixed16 ret(*this);
        ret += o;
        return ret;
    }
 
    Fixed16 &operator-=(Fixed16 o)
    {
        from_int(to_int() - o.to_int());
        return *this;
    }
 
    template <typename T> Fixed16 operator-(T o) const
    {
        Fixed16 ret(*this);
        ret -= o;
        return ret;
    }
 
    Fixed16 &operator*=(Fixed16 o)
    {
        uint64_t v = value_;
        v *= o.value_;
        v >>= 16;
        value_ = v;
        sign_ ^= o.sign_;
        return *this;
    }
 
    template <typename T> Fixed16 operator*(T o) const
    {
        Fixed16 ret(*this);
        ret *= o;
        return ret;
    }
 
    Fixed16 &operator/=(Fixed16 o)
    {
        uint64_t v = value_;
        v <<= 32;
        v /= o.value_;
        v >>= 16;
        value_ = v;
        sign_ ^= o.sign_;
        return *this;
    }
 
    template <typename T> Fixed16 operator/(T o) const
    {
        Fixed16 ret(*this);
        ret /= o;
        return ret;
    }
 
    bool operator<(Fixed16 o)
    {
        return to_key() < o.to_key();
    }
 
    bool operator<=(Fixed16 o)
    {
        return to_key() <= o.to_key();
    }
 
    bool operator>(Fixed16 o)
    {
        return to_key() > o.to_key();
    }
 
    bool operator>=(Fixed16 o)
    {
        return to_key() >= o.to_key();
    }
 
    bool operator==(Fixed16 o)
    {
        return to_key() == o.to_key();
    }
 
    bool operator!=(Fixed16 o)
    {
        return to_key() != o.to_key();
    }
    
    Fixed16 &mulpow2(Fixed16 o)
    {
        const Fixed16* coeffs;
        uint16_t f;
        if (o.is_positive())
        {
            // multiplying
            value_ <<= o.trunc();
            f = o.frac();
            static constexpr const Fixed16 pown[6] = {
                {FROM_DOUBLE, 1.4142135623730951},  // 2^(1/2)
                {FROM_DOUBLE, 1.1892071150027210},  // 2^(1/4)
                {FROM_DOUBLE, 1.0905077326652577},  // 2^(1/8)
                {FROM_DOUBLE, 1.0442737824274138},  // 2^(1/16)
                {FROM_DOUBLE, 1.0218971486541166},  // 2^(1/32)
                {FROM_DOUBLE, 1.0108892860517005}}; // 2^(1/64)
            coeffs = pown;
        }
        else
        {
            // dividing
            o.negate();
            value_ >>= o.trunc();
            f = o.frac();
            static constexpr const Fixed16 pown[6] = {
                {FROM_DOUBLE, 0.7071067811865476},  // 2^(-1/2)
                {FROM_DOUBLE, 0.8408964152537145},  // 2^(-1/4)
                {FROM_DOUBLE, 0.9170040432046712},  // 2^(-1/8)
                {FROM_DOUBLE, 0.9576032806985737},  // 2^(-1/16)
                {FROM_DOUBLE, 0.9785720620877001},  // 2^(-1/32)
                {FROM_DOUBLE, 0.9892280131939755}}; // 2^(-1/64)
            coeffs = pown;
        }
        for (unsigned idx = 0, bit = 0x8000; idx < 6; ++idx, bit >>= 1)
        {
            if (f & bit)
            {
                *this *= coeffs[idx];
            }
        }
        return *this;
    }
 
    int16_t round() const {
        int16_t b = (value_ + 0x8000) >> 16;
        if (sign_) return -b;
        return b;
    }
    
    int16_t trunc() const
    {
        int16_t b = value_ >> 16;
        if (sign_) return -b;
        return b;
    }
 
    uint16_t frac() const
    {
        return value_ & 0xffff;
    }
 
    float to_float() const
    {
        if (!value_) {
            if (sign_)
            {
                return -0.0f;
            }
            else
            {
                return 0.0f;
            }
        }
        uint32_t f = 0;
        if (sign_) f |= 0x80000000u;
        int lz = __builtin_clz(value_);
        if (lz <= 8)
        {
            HASSERT(((value_ >> (8 - lz)) & 0xFF800000U) == 0x800000U);
            f |= (value_ >> (8 - lz)) & 0x7FFFFF;
        }
        else
        {
            HASSERT(((value_ << (lz - 8)) & 0xFF800000U) == 0x800000U);
            f |= (value_ << (lz - 8)) & 0x7FFFFF;
        }
        uint32_t exp = (127 + 15 - lz) & 0xFF;
        f |= exp << 23;
        return *reinterpret_cast<float *>(&f);
    }
 
    /*    uint16_t to_float16() {
            if (!value_) return 0;
 
            }*/
 
    bool is_positive() const {
        return sign_ == 0;
    }
 
    void negate() {
        sign_ ^= 1;
    }
 
    int32_t to_key()
    {
        return to_int();
    }
    
private:
    int32_t to_int() const
    {
        int32_t r = value_;
        if (sign_)
        {
            return -r;
        }
        else
        {
            return r;
        }
    }
 
    void from_int(int32_t v) {
        if (v<0) {
            sign_ = 1;
            v = -v;
        } else {
            sign_ = 0;
        }
        value_ = v & 0x7fffffffu;
    }
 
    uint32_t value_ : 31;
    uint32_t sign_ : 1;
};
 
#endif // _UTILS_FIXED16_HXX_