fixed_point.h

// DISCLAIMER_PLACEHOLDER
#pragma once
 
#include <cassert>
#include <cstdint>
#include <cstddef>
#include <string>
 
#include "../../core/utilities/converters.h"
 
namespace llfix
{
 
class FixedPoint
{
public:
 
    void set_decimal_points(uint32_t n)
    {
        assert(n>0 && n <= MAX_ALLOWED_DECIMAL_POINTS);
        m_decimal_points = n;
    }
 
    uint32_t get_decimal_points() const
    {
        return m_decimal_points;
    }
 
    void set_raw_value(uint64_t raw_value)
    {
        m_raw_value = raw_value;
    }
 
    uint64_t get_raw_value() const
    {
        return m_raw_value;
    }
 
    void set_from_chars(const char* buffer, std::size_t length)
    {
        assert(m_decimal_points >0 && m_decimal_points <= MAX_ALLOWED_DECIMAL_POINTS);
        assert(buffer != nullptr);
        assert(length > 0);
 
        char temp_buffer[MAX_DIGITS];
        std::size_t temp_buffer_length = 0;
 
        std::size_t length_fractal_part = 0;
        bool in_fractal_part = false;
 
        for (std::size_t i = 0; i < length; i++)
        {
            char current_char = buffer[i];
 
            if (current_char != '.')
            {
                assert(temp_buffer_length < MAX_DIGITS);
 
                temp_buffer[temp_buffer_length] = current_char;
                temp_buffer_length++;
 
                if (in_fractal_part )
                {
                    length_fractal_part++;
                }
            }
            else
            {
                in_fractal_part = true;
            }
        }
 
        assert(length_fractal_part <= m_decimal_points && length_fractal_part <= MAX_ALLOWED_DECIMAL_POINTS);
 
        uint64_t scale = POWERS_OF_TEN[m_decimal_points];
        scale /= static_cast<uint64_t>(POWERS_OF_TEN[length_fractal_part]);
 
        auto value = Converters::chars_to_unsigned_int<uint64_t>(temp_buffer, temp_buffer_length);
 
        m_raw_value = static_cast<uint64_t>(value * scale);
    }
 
    std::size_t to_chars(char* buffer) const
    {
        assert(m_decimal_points >0 && m_decimal_points <= MAX_ALLOWED_DECIMAL_POINTS);
        assert(buffer != nullptr);
 
        char temp_buffer[MAX_DIGITS];
        Converters::unsigned_int_to_chars<uint64_t>(m_raw_value, temp_buffer);
 
        std::size_t length = Converters::get_chars_length_of_uint64_t(m_raw_value);
 
        assert(length > 0);
 
        if (length > m_decimal_points)
        {
            assert(length + 1 < MAX_DIGITS);
 
            std::size_t integer_part_length = length - m_decimal_points;
 
            // Copy integer part
            for (std::size_t i = 0; i < integer_part_length; i++)
            {
                buffer[i] = temp_buffer[i];
            }
 
            buffer[integer_part_length] = '.';
 
            // Copy fractal part
            for (std::size_t i = 0; i < m_decimal_points; i++)
            {
                buffer[integer_part_length + 1 + i] = temp_buffer[integer_part_length + i];
            }
 
            return length + 1; // +1 is because of '.'
        }
        else
        {
            assert(2 + m_decimal_points < MAX_DIGITS);
 
            buffer[0] = '0';
            buffer[1] = '.';
 
            std::size_t max_buffer_index = 2 + m_decimal_points - 1;
 
            for (std::size_t i = 0; i < length; i++)
            {
                buffer[max_buffer_index - i] = temp_buffer[length-1-i];
            }
 
            for (std::size_t i = 0; i < m_decimal_points-length; i++)
            {
                buffer[2 + i] = '0';
            }
 
            return 2 + m_decimal_points; // +2 is because of "0."
        }
    }
 
    std::string to_string() const
    {
        assert(m_decimal_points >0 && m_decimal_points <= MAX_ALLOWED_DECIMAL_POINTS);
 
        char temp_buffer[MAX_DIGITS];
        auto length = to_chars(temp_buffer);
        temp_buffer[length] = '\0';
 
        std::string ret = temp_buffer;
        return ret;
    }
 
    bool operator ==(const FixedPoint& other) const
    {
        assert(m_decimal_points > 0 && m_decimal_points <= MAX_ALLOWED_DECIMAL_POINTS);
        assert(m_decimal_points == other.m_decimal_points);
 
        return m_raw_value == other.m_raw_value;
    }
 
    bool operator !=(const FixedPoint& other) const
    {
        assert(m_decimal_points > 0 && m_decimal_points <= MAX_ALLOWED_DECIMAL_POINTS);
        assert(m_decimal_points == other.m_decimal_points);
 
        return m_raw_value != other.m_raw_value;
    }
 
    bool operator >(const FixedPoint& other) const
    {
        assert(m_decimal_points > 0 && m_decimal_points <= MAX_ALLOWED_DECIMAL_POINTS);
        assert(m_decimal_points == other.m_decimal_points);
        return m_raw_value > other.m_raw_value;
    }
 
    bool operator >=(const FixedPoint& other) const
    {
        assert(m_decimal_points > 0 && m_decimal_points <= MAX_ALLOWED_DECIMAL_POINTS);
        assert(m_decimal_points == other.m_decimal_points);
        return m_raw_value >= other.m_raw_value;
    }
 
    bool operator <(const FixedPoint& other) const
    {
        assert(m_decimal_points > 0 && m_decimal_points <= MAX_ALLOWED_DECIMAL_POINTS);
        assert(m_decimal_points == other.m_decimal_points);
        return m_raw_value < other.m_raw_value;
    }
 
    bool operator <=(const FixedPoint& other) const
    {
        assert(m_decimal_points > 0 && m_decimal_points <= MAX_ALLOWED_DECIMAL_POINTS);
        assert(m_decimal_points == other.m_decimal_points);
        return m_raw_value <= other.m_raw_value;
    }
 
private:
    uint64_t m_raw_value = 0;
    uint32_t m_decimal_points = 0;
 
    static constexpr inline std::size_t MAX_DIGITS = 64;
    static constexpr inline std::size_t MAX_ALLOWED_DECIMAL_POINTS = 9;
 
    static constexpr inline uint64_t POWERS_OF_TEN[] =
    {
        UINT64_C(1),          UINT64_C(10),       UINT64_C(100),
        UINT64_C(1000),       UINT64_C(10000),    UINT64_C(100000),
        UINT64_C(1000000),    UINT64_C(10000000), UINT64_C(100000000),
        UINT64_C(1000000000),
    };
};
 
} // namespace