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)

Detailed Description

Definition at line 44 of file diyfp.h.

Constructor & Destructor Documentation

DiyFp() [1/3]

internal::DiyFp::DiyFp ( )

inline

Definition at line 45 of file diyfp.h.

: f(), e() {}

Here is the caller graph for this function:

DiyFp() [2/3]

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

inline

Definition at line 47 of file diyfp.h.

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

DiyFp() [3/3]

internal::DiyFp::DiyFp ( double d )

inlineexplicit

Definition at line 49 of file diyfp.h.

                             {
        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

Normalize()

DiyFp internal::DiyFp::Normalize ( ) const

inline

Definition at line 102 of file diyfp.h.

                            {
        RAPIDJSON_ASSERT(f != 0); // https://stackoverflow.com/a/26809183/291737
#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:

NormalizeBoundary()

DiyFp internal::DiyFp::NormalizeBoundary ( ) const

inline

Definition at line 121 of file diyfp.h.

                                    {
        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;
    }

Here is the caller graph for this function:

NormalizedBoundaries()

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

inline

Definition at line 132 of file diyfp.h.

                                                               {
        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:

operator*()

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

inline

mult_round

Definition at line 71 of file diyfp.h.

                                            {
#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:

operator-()

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

inline

Definition at line 67 of file diyfp.h.

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

Here is the call graph for this function:

ToDouble()

double internal::DiyFp::ToDouble ( ) const

inline

Definition at line 141 of file diyfp.h.

                            {
        union {
            double d;
            uint64_t u64;
        }u;
        RAPIDJSON_ASSERT(f <= kDpHiddenBit + kDpSignificandMask);
        if (e < kDpDenormalExponent) {
            // Underflow.
            return 0.0;
        }
        if (e >= kDpMaxExponent) {
            // Overflow.
            return std::numeric_limits<double>::infinity();
        }
        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

e

int internal::DiyFp::e

Definition at line 172 of file diyfp.h.

f

uint64_t internal::DiyFp::f

Definition at line 171 of file diyfp.h.

kDiySignificandSize

const int internal::DiyFp::kDiySignificandSize = 64

static

Definition at line 161 of file diyfp.h.

kDpDenormalExponent

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

static

Definition at line 166 of file diyfp.h.

kDpExponentBias

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

static

Definition at line 163 of file diyfp.h.

kDpExponentMask

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

static

Definition at line 167 of file diyfp.h.

kDpHiddenBit

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

static

Definition at line 169 of file diyfp.h.

kDpMaxExponent

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

static

Definition at line 164 of file diyfp.h.

kDpMinExponent

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

static

Definition at line 165 of file diyfp.h.

kDpSignificandMask

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

static

Definition at line 168 of file diyfp.h.

kDpSignificandSize

const int internal::DiyFp::kDpSignificandSize = 52

static

Definition at line 162 of file diyfp.h.

---

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

• libraries/fc/include/fc/crypto/webauthn_json/include/rapidjson/internal/diyfp.h