Number.h

Go to the documentation of this file.

 
#pragma once
 
#include <WString.h>
#include <Print.h>
#include <Data/BitSet.h>
#include <cmath>
 
namespace ConfigDB
{
struct number_t {
    int32_t mantissa : 26;
    int32_t exponent : 6;
 
    static constexpr unsigned maxMantissa{0x1ffffff}; // 33554431
    static constexpr int maxExponent{0x1f};           // 31
    static constexpr unsigned maxSignificantDigits{8};
    static constexpr unsigned minBufferSize{17};
 
    static constexpr const number_t min()
    {
        return {1, -maxExponent};
    }
 
    static constexpr const number_t max()
    {
        return {maxMantissa, maxExponent};
    }
 
    static constexpr const number_t lowest()
    {
        return {-int(maxMantissa), maxExponent};
    }
 
    bool operator==(const number_t& other) const
    {
        return mantissa == other.mantissa && exponent == other.exponent;
    }
 
    bool operator!=(const number_t& other) const
    {
        return !operator==(other);
    }
 
    bool sign() const
    {
        return mantissa < 0;
    }
 
    bool operator<(const number_t& other) const
    {
        return compare(*this, other) < 0;
    }
 
    bool operator>(const number_t& other) const
    {
        return compare(*this, other) > 0;
    }
 
    static double asFloat(number_t number);
 
    static int64_t asInt64(number_t number);
 
    size_t printTo(Print& p) const
    {
        char buf[minBufferSize];
        return p.print(format(buf, *this));
    }
 
    static int compare(number_t num1, number_t num2);
 
    static const char* format(char* buf, number_t number);
 
    static bool parse(const char* value, unsigned length, number_t& number);
 
    static number_t parse(const char* value, unsigned length)
    {
        number_t num{};
        parse(value, length, num);
        return num;
    }
 
    static constexpr number_t normalise(unsigned mantissa, int exponent, bool isNeg)
    {
        // A non-zero exponent indicates rounding occurred, so 0 isn't zero!
        if(mantissa == 0 && exponent != 0) {
            return number_t{isNeg ? -1 : 1, -number_t::maxExponent};
        }
 
        // Discard non-significant digits
        while(mantissa > number_t::maxMantissa * 10) {
            mantissa /= 10;
            ++exponent;
        }
 
        // Round down
        if(mantissa > number_t::maxMantissa && exponent < number_t::maxExponent) {
            auto newMantissa = (mantissa + 5) / 10;
            if(newMantissa > mantissa) {
                // Number was rounded up and gained a digit
                newMantissa /= 10;
            }
            mantissa = newMantissa;
            ++exponent;
        }
 
        // Drop any trailing 0's from mantissa
        while(mantissa >= 10 && mantissa % 10 == 0 && exponent < number_t::maxExponent) {
            mantissa /= 10;
            ++exponent;
        }
 
        // Adjust exponent to keep it in range (without losing precision)
        while(exponent > number_t::maxExponent) {
            mantissa *= 10;
            if(mantissa > number_t::maxMantissa) {
                break;
            }
            --exponent;
        }
 
        if(exponent > number_t::maxExponent) {
            mantissa = number_t::maxMantissa;
            exponent = number_t::maxExponent;
        } else if(exponent < -number_t::maxExponent) {
            mantissa = 1;
            exponent = -number_t::maxExponent;
        } else {
            mantissa = std::min(mantissa, number_t::maxMantissa);
        }
 
        return number_t{isNeg ? -int32_t(mantissa) : int32_t(mantissa), exponent};
    }
 
    static constexpr number_t normalise(double mantissa)
    {
        // Check for special values. NB. NaN values always fail self-compare
        if(mantissa == 0 || mantissa != mantissa) {
            return {};
        }
        if(mantissa == std::numeric_limits<double>::infinity()) {
            return max();
        }
        if(mantissa == -std::numeric_limits<double>::infinity()) {
            return lowest();
        }
 
        // Pull significant digits into integer part
        int exponent = 0;
        while(mantissa > -double(number_t::maxMantissa) && mantissa < double(number_t::maxMantissa) &&
              exponent > -number_t::maxExponent) {
            mantissa *= 10.0;
            --exponent;
        }
        // Reduce integer part to int32 range
        while(mantissa < -0x7fffffff || mantissa > 0x7fffffff) {
            mantissa /= 10;
            ++exponent;
        }
 
        return (mantissa < 0) ? normalise(unsigned(-mantissa), exponent, true)
                              : normalise(unsigned(mantissa), exponent, false);
    }
 
    static constexpr number_t normalise(int mantissa, int exponent)
    {
        return normalise(abs(mantissa), exponent, mantissa < 0);
    }
 
    static constexpr number_t normalise(int64_t value)
    {
        bool isNeg{false};
        if(value < 0) {
            isNeg = true;
            value = -value;
        }
        int exponent = 0;
        while(value > 0xffffffffll) {
            value /= 10;
            ++exponent;
        }
        return normalise(unsigned(value), exponent, isNeg);
    }
};
 
static_assert(sizeof(number_t) == 4, "Bad number_t size");
 
struct const_number_t : public number_t {
    const_number_t() = default;
 
    constexpr const_number_t(double value) : number_t(normalise(value))
    {
    }
};
 
class __attribute__((packed)) Number
{
public:
    Number() = default;
 
    constexpr Number(const number_t& number) : number(number)
    {
    }
 
    constexpr Number(const const_number_t& number) : number(number)
    {
    }
 
    constexpr Number(const Number& number) = default;
 
    constexpr Number(double value) : number(number_t::normalise(value))
    {
    }
 
    constexpr Number(int64_t value) : number(number_t::normalise(value))
    {
    }
 
    constexpr Number(int value) : Number(int64_t(value))
    {
    }
 
    constexpr Number(unsigned int value) : Number(int64_t(value))
    {
    }
 
    Number(const char* value, unsigned length) : number(number_t::parse(value, length))
    {
    }
 
    Number(const char* value) : Number(value, value ? strlen(value) : 0)
    {
    }
 
    Number(const String& str) : Number(str.c_str(), str.length())
    {
    }
 
    bool operator<(const Number& other) const
    {
        return number < other.number;
    }
 
    bool operator>(const Number& other) const
    {
        return number > other.number;
    }
 
    bool operator==(const number_t& other) const
    {
        return number == other;
    }
 
    bool operator!=(const number_t& other) const
    {
        return number != other;
    }
 
    int compare(const Number& other) const
    {
        return number_t::compare(number, other.number);
    }
 
    size_t printTo(Print& p) const
    {
        char buf[number_t::minBufferSize];
        return p.print(number_t::format(buf, number));
    }
 
    double asFloat() const
    {
        return number_t::asFloat(number);
    }
 
    int64_t asInt64() const
    {
        return number_t::asInt64(number);
    }
 
    String toString() const
    {
        char buf[number_t::minBufferSize];
        return number_t::format(buf, number);
    }
 
    explicit operator String() const
    {
        return toString();
    }
 
    constexpr operator number_t() const
    {
        return number;
    }
 
private:
    number_t number;
};
 
} // namespace ConfigDB
 
using number_t = ConfigDB::number_t;
using const_number_t = ConfigDB::const_number_t;
 
inline String toString(number_t number)
{
    return ConfigDB::Number(number).toString();
}