internal::dtoa_impl::diyfp Struct Reference

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 163 of file ToChars.cpp.

Constructor & Destructor Documentation

diyfp()

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

inlineconstexprnoexcept

Definition at line 170 of file ToChars.cpp.

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

Member Function Documentation

mul()

static diyfp internal::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 190 of file ToChars.cpp.

   {
      static_assert(kPrecision == 64, "internal error");
 
      // Computes:
      //  f = round((x.f * y.f) / 2^q)
      //  e = x.e + y.e + q
 
#if defined(_MSC_VER) && defined(_M_X64)
 
      uint64_t h = 0;
      uint64_t l = _umul128(x.f, y.f, &h);
      h += l >> 63; // round, ties up: [h, l] += 2^q / 2
 
      return { h, x.e + y.e + 64 };
 
#elif defined(__GNUC__) && defined(__SIZEOF_INT128__)
 
    __extension__ using Uint128 = unsigned __int128;
 
    Uint128 const p = Uint128{x.f} * Uint128{y.f};
 
    uint64_t h = static_cast<uint64_t>(p >> 64);
    uint64_t l = static_cast<uint64_t>(p);
    h += l >> 63; // round, ties up: [h, l] += 2^q / 2
 
    return { h, x.e + y.e + 64 };
 
#else
 
      // 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 };
#endif
   }

References kPrecision.

Referenced by internal::dtoa_impl::grisu2().

Here is the caller graph for this function:

normalize()

static diyfp internal::dtoa_impl::diyfp::normalize ( diyfp  x )

inlinestaticnoexcept

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

Precondition

x.f != 0

Definition at line 280 of file ToChars.cpp.

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

References f.

Referenced by internal::dtoa_impl::compute_boundaries().

Here is the caller graph for this function:

normalize_to()

static diyfp internal::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 296 of file ToChars.cpp.

   {
      const int delta = x.e - target_exponent;
 
      return { x.f << delta, target_exponent };
   }

References e.

Referenced by internal::dtoa_impl::compute_boundaries().

Here is the caller graph for this function:

sub()

static diyfp internal::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 180 of file ToChars.cpp.

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

References f.

Referenced by internal::dtoa_impl::grisu2_digit_gen().

Here is the caller graph for this function:

Member Data Documentation

e

int internal::dtoa_impl::diyfp::e = 0

Definition at line 168 of file ToChars.cpp.

Referenced by internal::dtoa_impl::compute_boundaries(), internal::dtoa_impl::grisu2(), internal::dtoa_impl::grisu2_digit_gen(), and normalize_to().

f

std::uint64_t internal::dtoa_impl::diyfp::f = 0

Definition at line 167 of file ToChars.cpp.

Referenced by internal::dtoa_impl::compute_boundaries(), internal::dtoa_impl::grisu2(), internal::dtoa_impl::grisu2_digit_gen(), normalize(), and sub().

kPrecision

constexpr int internal::dtoa_impl::diyfp::kPrecision = 64

staticconstexpr

Definition at line 165 of file ToChars.cpp.

Referenced by internal::dtoa_impl::grisu2(), and mul().

---

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

• ToChars.cpp