nlohmann::detail::dtoa_impl::diyfp Struct Reference

#include <json.hpp>

Public Member Functions
constexpr	diyfp (std::uint64_t f_, int e_) noexcept

Static Public Member Functions
static diyfp	sub (const diyfp &x, const diyfp &y) noexcept
	returns x - y More...
static diyfp	mul (const diyfp &x, const diyfp &y) noexcept
	returns x * y More...
static diyfp	normalize (diyfp x) noexcept
	normalize x such that the significand is >= 2^(q-1) More...
static diyfp	normalize_to (const diyfp &x, const int target_exponent) noexcept
	normalize x such that the result has the exponent E More...

Public Attributes
std::uint64_t	f = 0
int	e = 0

Static Public Attributes
static constexpr int	kPrecision = 64

Detailed Description

Definition at line 12699 of file json.hpp.

Constructor & Destructor Documentation

constexpr nlohmann::detail::dtoa_impl::diyfp::diyfp ( std::uint64_t  f_, int  e_  )

inlinenoexcept

Definition at line 12706 of file json.hpp.

: f(f_), e(e_) {}

Member Function Documentation

static diyfp nlohmann::detail::dtoa_impl::diyfp::mul ( const diyfp &  x, const diyfp &  y  )

inlinestaticnoexcept

returns x * y

Note

The result is rounded. (Only the upper q bits are returned.)

Definition at line 12724 of file json.hpp.

    {
        static_assert(kPrecision == 64, "internal error");

        // Computes:
        //  f = round((x.f * y.f) / 2^q)
        //  e = x.e + y.e + q

        // Emulate the 64-bit * 64-bit multiplication:
        //
        // p = u * v
        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
        //
        // (Since Q might be larger than 2^32 - 1)
        //
        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
        //
        // (Q_hi + H does not overflow a 64-bit int)
        //
        //   = p_lo + 2^64 p_hi

        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
        const std::uint64_t u_hi = x.f >> 32u;
        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
        const std::uint64_t v_hi = y.f >> 32u;

        const std::uint64_t p0 = u_lo * v_lo;
        const std::uint64_t p1 = u_lo * v_hi;
        const std::uint64_t p2 = u_hi * v_lo;
        const std::uint64_t p3 = u_hi * v_hi;

        const std::uint64_t p0_hi = p0 >> 32u;
        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
        const std::uint64_t p1_hi = p1 >> 32u;
        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
        const std::uint64_t p2_hi = p2 >> 32u;

        std::uint64_t Q = p0_hi + p1_lo + p2_lo;

        // The full product might now be computed as
        //
        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
        // p_lo = p0_lo + (Q << 32)
        //
        // But in this particular case here, the full p_lo is not required.
        // Effectively we only need to add the highest bit in p_lo to p_hi (and
        // Q_hi + 1 does not overflow).

        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up

        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);

        return {h, x.e + y.e + 64};
    }

static diyfp nlohmann::detail::dtoa_impl::diyfp::normalize ( diyfp  x )

inlinestaticnoexcept

normalize x such that the significand is >= 2^(q-1)

Precondition

x.f != 0

Definition at line 12789 of file json.hpp.

    {
        assert(x.f != 0);

        while ((x.f >> 63u) == 0)
        {
            x.f <<= 1u;
            x.e--;
        }

        return x;
    }

static diyfp nlohmann::detail::dtoa_impl::diyfp::normalize_to ( const diyfp &  x, const int  target_exponent  )

inlinestaticnoexcept

normalize x such that the result has the exponent E

Precondition

e >= x.e and the upper e - x.e bits of x.f must be zero.

Definition at line 12806 of file json.hpp.

    {
        const int delta = x.e - target_exponent;

        assert(delta >= 0);
        assert(((x.f << delta) >> delta) == x.f);

        return {x.f << delta, target_exponent};
    }

static diyfp nlohmann::detail::dtoa_impl::diyfp::sub ( const diyfp &  x, const diyfp &  y  )

inlinestaticnoexcept

returns x - y

Precondition

x.e == y.e and x.f >= y.f

Definition at line 12712 of file json.hpp.

    {
        assert(x.e == y.e);
        assert(x.f >= y.f);

        return {x.f - y.f, x.e};
    }

Member Data Documentation

int nlohmann::detail::dtoa_impl::diyfp::e = 0

Definition at line 12704 of file json.hpp.

std::uint64_t nlohmann::detail::dtoa_impl::diyfp::f = 0

Definition at line 12703 of file json.hpp.

constexpr int nlohmann::detail::dtoa_impl::diyfp::kPrecision = 64

static

Definition at line 12701 of file json.hpp.

---

The documentation for this struct was generated from the following file:

• json.hpp