grisu3.hpp

Go to the documentation of this file.

 
#ifndef __DCONV_GRISU3_HPP__
#define __DCONV_GRISU3_HPP__
 
// dconv.
#include <dconv/grisu2.hpp>
 
// C++.
#include <charconv>
 
// C.
#include <cstdint>
 
namespace dconv
{
    namespace grisu3
    {
        inline bool roundWeed (char* buffer, int length, uint64_t wpW, uint64_t delta, uint64_t rest, uint64_t tenKappa,
                               uint64_t ulp) noexcept
        {
            const uint64_t wpWup = wpW - ulp;
            const uint64_t wpWdown = wpW + ulp;
 
            while ((rest < wpWup) && (delta - rest >= tenKappa) &&
                   ((rest + tenKappa < wpWup) || (wpWup - rest >= rest + tenKappa - wpWup)))
            {
                --buffer[length - 1];
                rest += tenKappa;
            }
 
            if ((rest < wpWdown) && (delta - rest >= tenKappa) &&
                ((rest + tenKappa < wpWdown) || (wpWdown - rest > rest + tenKappa - wpWdown)))
            {
                return false;
            }
 
            return (2 * ulp <= rest) && (rest <= delta - 4 * ulp);
        }
 
        inline bool digitsGen (const DiyFp& low, const DiyFp& w, const DiyFp& high, char* buffer, int& length,
                               int& k) noexcept
        {
            uint64_t unit = 1;
            const uint64_t tooLow = low._mantissa - unit;
            const uint64_t tooHigh = high._mantissa + unit;
            uint64_t unsafe = tooHigh - tooLow;
 
            const DiyFp one (static_cast<uint64_t> (1) << -w._exponent, w._exponent);
            uint32_t p1 = static_cast<uint32_t> (tooHigh >> -one._exponent);
            uint64_t p2 = tooHigh & (one._mantissa - 1);
            int kappa = details::countDigits (p1);
            length = 0;
 
            while (kappa > 0)
            {
                buffer[length++] = static_cast<char> ('0' + p1 / details::pow10[kappa - 1]);
                p1 %= details::pow10[kappa - 1];
                --kappa;
 
                const uint64_t rest = (static_cast<uint64_t> (p1) << -one._exponent) + p2;
                if (rest < unsafe)
                {
                    k += kappa;
                    return roundWeed (buffer, length, tooHigh - w._mantissa, unsafe, rest,
                                      static_cast<uint64_t> (details::pow10[kappa]) << -one._exponent, unit);
                }
            }
 
            for (;;)
            {
                p2 *= 10;
                unit *= 10;
                unsafe *= 10;
                buffer[length++] = static_cast<char> ('0' + (p2 >> -one._exponent));
                p2 &= one._mantissa - 1;
                --kappa;
 
                if (p2 < unsafe)
                {
                    k += kappa;
                    return roundWeed (buffer, length, (tooHigh - w._mantissa) * unit, unsafe, p2, one._mantissa, unit);
                }
            }
        }
 
        inline void fallback (char* buffer, int& length, int& k, double value) noexcept
        {
            char text[32];
            const char* end = std::to_chars (text, text + sizeof (text), value, std::chars_format::scientific).ptr;
            const char* cur = text;
 
            length = 0;
            for (; *cur != 'e'; ++cur)
            {
                if (*cur != '.')
                {
                    buffer[length++] = *cur;
                }
            }
 
            int exponent = 0;
            std::from_chars (cur + 2, end, exponent);
            k = ((cur[1] == '-') ? -exponent : exponent) - (length - 1);
        }
 
        inline void generate (char* buffer, int& length, int& k, double value) noexcept
        {
            DiyFp w, minus, plus;
            grisu2::scaledBoundaries (value, w, minus, plus, k);
 
            if (!digitsGen (minus, w, plus, buffer, length, k))
            {
                fallback (buffer, length, k, value);
            }
        }
 
        inline char* dtoa (char* buffer, double value) noexcept
        {
            return grisu::details::dtoa (buffer, value, generate);
        }
    }
}
 
#endif