internal::DiyFp Struct Reference

#include <diyfp.h>

Public Member Functions
	DiyFp ()
	DiyFp (uint64_t fp, int exp)
	DiyFp (double d)
DiyFp	operator- (const DiyFp &rhs) const
DiyFp	operator* (const DiyFp &rhs) const
DiyFp	Normalize () const
DiyFp	NormalizeBoundary () const
void	NormalizedBoundaries (DiyFp *minus, DiyFp *plus) const
double	ToDouble () const

Public Attributes
uint64_t	f
int	e

Static Public Attributes
static const int	kDiySignificandSize = 64
static const int	kDpSignificandSize = 52
static const int	kDpExponentBias = 0x3FF + kDpSignificandSize
static const int	kDpMaxExponent = 0x7FF - kDpExponentBias
static const int	kDpMinExponent = -kDpExponentBias
static const int	kDpDenormalExponent = -kDpExponentBias + 1
static const uint64_t	kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000)
static const uint64_t	kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF)
static const uint64_t	kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000)

Constructor & Destructor Documentation

internal::DiyFp::DiyFp ( )

inline

{}

Here is the caller graph for this function:

internal::DiyFp::DiyFp ( uint64_t  fp, int  exp  )

inline

: f(fp), e(exp) {}

internal::DiyFp::DiyFp ( double  d )

inlineexplicit

 {
 union {
 double d;
 uint64_t u64;
 } u = { d };

 int biased_e = static_cast<int>((u.u64 & kDpExponentMask) >> kDpSignificandSize);
 uint64_t significand = (u.u64 & kDpSignificandMask);
 if (biased_e != 0) {
 f = significand + kDpHiddenBit;
 e = biased_e - kDpExponentBias;
 } 
 else {
 f = significand;
 e = kDpMinExponent + 1;
 }
 }

Member Function Documentation

DiyFp internal::DiyFp::Normalize ( ) const

inline

 {
#if defined(_MSC_VER) && defined(_M_AMD64)
 unsigned long index;
 _BitScanReverse64(&index, f);
 return DiyFp(f << (63 - index), e - (63 - index));
#elif defined(__GNUC__) && __GNUC__ >= 4
 int s = __builtin_clzll(f);
 return DiyFp(f << s, e - s);
#else
 DiyFp res = *this;
 while (!(res.f & (static_cast<uint64_t>(1) << 63))) {
 res.f <<= 1;
 res.e--;
 }
 return res;
#endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

DiyFp internal::DiyFp::NormalizeBoundary ( ) const

inline

 {
 DiyFp res = *this;
 while (!(res.f & (kDpHiddenBit << 1))) {
 res.f <<= 1;
 res.e--;
 }
 res.f <<= (kDiySignificandSize - kDpSignificandSize - 2);
 res.e = res.e - (kDiySignificandSize - kDpSignificandSize - 2);
 return res;
 }

void internal::DiyFp::NormalizedBoundaries ( DiyFp *  minus, DiyFp *  plus  ) const

inline

 {
 DiyFp pl = DiyFp((f << 1) + 1, e - 1).NormalizeBoundary();
 DiyFp mi = (f == kDpHiddenBit) ? DiyFp((f << 2) - 1, e - 2) : DiyFp((f << 1) - 1, e - 1);
 mi.f <<= mi.e - pl.e;
 mi.e = pl.e;
 *plus = pl;
 *minus = mi;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

DiyFp internal::DiyFp::operator* ( const DiyFp &  rhs ) const

inline

mult_round

 {
#if defined(_MSC_VER) && defined(_M_AMD64)
 uint64_t h;
 uint64_t l = _umul128(f, rhs.f, &h);
 if (l & (uint64_t(1) << 63)) // rounding
 h++;
 return DiyFp(h, e + rhs.e + 64);
#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) && defined(__x86_64__)
 __extension__ typedef unsigned __int128 uint128;
 uint128 p = static_cast<uint128>(f) * static_cast<uint128>(rhs.f);
 uint64_t h = static_cast<uint64_t>(p >> 64);
 uint64_t l = static_cast<uint64_t>(p);
 if (l & (uint64_t(1) << 63)) // rounding
 h++;
 return DiyFp(h, e + rhs.e + 64);
#else
 const uint64_t M32 = 0xFFFFFFFF;
 const uint64_t a = f >> 32;
 const uint64_t b = f & M32;
 const uint64_t c = rhs.f >> 32;
 const uint64_t d = rhs.f & M32;
 const uint64_t ac = a * c;
 const uint64_t bc = b * c;
 const uint64_t ad = a * d;
 const uint64_t bd = b * d;
 uint64_t tmp = (bd >> 32) + (ad & M32) + (bc & M32);
 tmp += 1U << 31; 
 return DiyFp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32), e + rhs.e + 64);
#endif
 }

Here is the call graph for this function:

DiyFp internal::DiyFp::operator- ( const DiyFp &  rhs ) const

inline

 {
 return DiyFp(f - rhs.f, e);
 }

Here is the call graph for this function:

double internal::DiyFp::ToDouble ( ) const

inline

 {
 union {
 double d;
 uint64_t u64;
 }u;
 const uint64_t be = (e == kDpDenormalExponent && (f & kDpHiddenBit) == 0) ? 0 : 
 static_cast<uint64_t>(e + kDpExponentBias);
 u.u64 = (f & kDpSignificandMask) | (be << kDpSignificandSize);
 return u.d;
 }

Here is the caller graph for this function:

Member Data Documentation

int internal::DiyFp::e

uint64_t internal::DiyFp::f

const int internal::DiyFp::kDiySignificandSize = 64

static

const int internal::DiyFp::kDpDenormalExponent = -kDpExponentBias + 1

static

const int internal::DiyFp::kDpExponentBias = 0x3FF + kDpSignificandSize

static

const uint64_t internal::DiyFp::kDpExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000)

static

const uint64_t internal::DiyFp::kDpHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000)

static

const int internal::DiyFp::kDpMaxExponent = 0x7FF - kDpExponentBias

static

const int internal::DiyFp::kDpMinExponent = -kDpExponentBias

static

const uint64_t internal::DiyFp::kDpSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF)

static

const int internal::DiyFp::kDpSignificandSize = 52

static

---

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

• dep/rapidjson/rapidjson/internal/diyfp.h