grisu2.hpp

Go to the documentation of this file.

 
#ifndef __DCONV_GRISU2_HPP__
#define __DCONV_GRISU2_HPP__
 
// dconv.
#include <dconv/grisu.hpp>
 
// C.
#include <cassert>
#include <cstdint>
 
namespace dconv
{
    namespace grisu2
    {
        inline void scaledBoundaries (double value, DiyFp& w, DiyFp& minus, DiyFp& plus, int& k) noexcept
        {
            w = DiyFp (value);
            w.normalizedBoundaries (minus, plus);
 
            const DiyFp& power = grisu::cachedPower (plus._exponent, k);
            minus *= power;
            plus *= power;
            w.normalize ();
            w *= power;
        }
 
        inline void round (char* buffer, int length, uint64_t delta, uint64_t rest, uint64_t tenKappa,
                           uint64_t wpW) noexcept
        {
            while ((rest < wpW && delta - rest >= tenKappa) &&
                   (rest + tenKappa < wpW || wpW - rest > rest + tenKappa - wpW))
            {
                --buffer[length - 1];
                rest += tenKappa;
            }
        }
 
        inline void digitsGen (const DiyFp& w, const DiyFp& high, uint64_t delta, char* buffer, int& length,
                               int& k) noexcept
        {
            const DiyFp one (static_cast<uint64_t> (1) << -high._exponent, high._exponent);
            const DiyFp wpW = high - w;
            uint32_t p1 = static_cast<uint32_t> (high._mantissa >> -one._exponent);
            uint64_t p2 = high._mantissa & (one._mantissa - 1);
            int kappa = details::countDigits (p1);
            length = 0;
 
            while (kappa > 0)
            {
                assert (kappa >= 1 && kappa <= 10);
                uint32_t d = p1 / details::pow10[kappa - 1];
                p1 %= details::pow10[kappa - 1];
                if (d || length)
                {
                    buffer[length++] = '0' + d;
                }
                --kappa;
                uint64_t rest = (static_cast<uint64_t> (p1) << -one._exponent) + p2;
                if (rest <= delta)
                {
                    k += kappa;
                    round (buffer, length, delta, rest, static_cast<uint64_t> (details::pow10[kappa]) << -one._exponent,
                           wpW._mantissa);
                    return;
                }
            }
 
            uint64_t unit = 1;
            for (;;)
            {
                assert (unit <= UINT64_MAX / 10);
                p2 *= 10;
                delta *= 10;
                unit *= 10;
                char d = static_cast<char> (p2 >> -one._exponent);
                buffer[length] = '0' + d;
                length += (d || length);
                p2 &= one._mantissa - 1;
                --kappa;
                if (p2 < delta)
                {
                    k += kappa;
                    round (buffer, length, delta, p2, one._mantissa, wpW._mantissa * unit);
                    return;
                }
            }
        }
 
        inline void generate (char* buffer, int& length, int& k, double value) noexcept
        {
            DiyFp w, minus, plus;
            scaledBoundaries (value, w, minus, plus, k);
 
            ++minus._mantissa;
            --plus._mantissa;
 
            digitsGen (w, plus, plus._mantissa - minus._mantissa, buffer, length, k);
        }
 
        inline char* dtoa (char* buffer, double value) noexcept
        {
            return grisu::details::dtoa (buffer, value, generate);
        }
    }
}
 
#endif