grisu.hpp

Go to the documentation of this file.

 
#ifndef __DCONV_GRISU_HPP__
#define __DCONV_GRISU_HPP__
 
// dconv.
#include <dconv/grisupow.hpp>
#include <dconv/format.hpp>
 
// C.
#include <cassert>
#include <cstring>
#include <cstdint>
 
namespace dconv
{
    namespace grisu
    {
        namespace details
        {
            inline char* dtoa (char* buffer, double value,
                               void (*generate) (char*, int&, int&, double) noexcept) noexcept
            {
                uint64_t bits;
                memcpy (&bits, &value, sizeof (double));
                bool is_negative = (bits >> 63) != 0;
 
                *buffer = '-';
                buffer += is_negative;
                value = is_negative ? -value : value;
 
                if (value == 0.0)
                {
                    memcpy (buffer, "0.0", 3);
                    return buffer + 3;
                }
 
                int length = 0, k = 0;
                generate (buffer, length, k, value);
                return dconv::details::prettify (buffer, length, k);
            }
        }
 
        inline const DiyFp& cachedPower (int exponent, int& k) noexcept
        {
            const int expr = -59 - (exponent + 64) + 63;
            const int mk = (expr * 30103 + 99999) / 100000;
 
            assert (mk + 343 >= 0 && mk + 343 < 687);
            k = -mk;
            return dconv::details::grisupow[mk + 343];
        }
 
        inline void generate (char* buffer, int& length, int& k, double value) noexcept
        {
            DiyFp w (value);
            w.normalize ();
            w *= cachedPower (w._exponent, k);
 
            const DiyFp one (static_cast<uint64_t> (1) << -w._exponent, w._exponent);
            uint32_t part1 = static_cast<uint32_t> (w._mantissa >> -one._exponent);
            uint64_t part2 = w._mantissa & (one._mantissa - 1);
 
            length = 0;
            for (int kappa = dconv::details::countDigits (part1); kappa > 0; --kappa)
            {
                buffer[length++] = static_cast<char> ('0' + part1 / dconv::details::pow10[kappa - 1]);
                part1 %= dconv::details::pow10[kappa - 1];
            }
 
            while ((length < 18) && (part2 != 0))
            {
                part2 *= 10;
                buffer[length++] = static_cast<char> ('0' + (part2 >> -one._exponent));
                part2 &= one._mantissa - 1;
                --k;
            }
        }
 
        inline char* dtoa (char* buffer, double value) noexcept
        {
            return details::dtoa (buffer, value, generate);
        }
    }
}
 
#endif