: DerivedObject(state, proto)

, m_primitiveValue(value)

{

{

ASSERT(std::isfinite(number));

sign = std::signbit(number);

uint64_t bits = bitwise_cast<uint64_t>(number);

exponent = (static_cast<int32_t>(bits >> 52) & 0x7ff) - 0x3ff;

mantissa = bits & 0xFFFFFFFFFFFFFull;

// Check for zero/denormal values; if so, adjust the exponent,

// if not insert the implicit, omitted leading 1 bit.

if (exponent == -0x3ff)

exponent = mantissa ? -0x3fe : 0;

else

mantissa |= 0x10000000000000ull;

explicit BigInteger(double number)

{

m_values.reserve(36);

ASSERT(std::isfinite(number) && !std::signbit(number));

ASSERT(number == floor(number));

bool sign;

int32_t exponent;

uint64_t mantissa;

decomposeDouble(number, sign, exponent, mantissa);

ASSERT(!sign && exponent >= 0);

int32_t zeroBits = exponent - 52;

if (zeroBits < 0) {

mantissa >>= -zeroBits;

zeroBits = 0;

}

while (zeroBits >= 32) {

m_values.push_back(0);

zeroBits -= 32;

}

// Left align the 53 bits of the mantissa within 96 bits.

uint32_t values[3];

values[0] = static_cast<uint32_t>(mantissa);

values[1] = static_cast<uint32_t>(mantissa >> 32);

values[2] = 0;

// Shift based on the remainder of the exponent.

if (zeroBits) {

values[2] = values[1] >> (32 - zeroBits);

values[1] = (values[1] << zeroBits) | (values[0] >> (32 - zeroBits));

values[0] = (values[0] << zeroBits);

}

m_values.push_back(values[0]);

m_values.push_back(values[1]);

m_values.push_back(values[2]);

// Canonicalize; remove all trailing zeros.

while (m_values.size() && !m_values.back())

m_values.pop_back();

}

uint32_t divide(uint32_t divisor)

{

uint32_t carry = 0;

for (size_t i = m_values.size(); i;) {

--i;

uint64_t dividend = (static_cast<uint64_t>(carry) << 32) + static_cast<uint64_t>(m_values[i]);

uint64_t result = dividend / static_cast<uint64_t>(divisor);

ASSERT(result == static_cast<uint32_t>(result));

uint64_t remainder = dividend % static_cast<uint64_t>(divisor);

ASSERT(remainder == static_cast<uint32_t>(remainder));

m_values[i] = static_cast<uint32_t>(result);

carry = static_cast<uint32_t>(remainder);

}

// Canonicalize; remove all trailing zeros.

while (m_values.size() && !m_values.back())

m_values.pop_back();

return carry;

}

bool operator!() { return !m_values.size(); }

std::vector<uint32_t> m_values;

explicit Uint16WithFraction(double number, uint16_t divideByExponent = 0)

{

m_values.reserve(36);

ASSERT(number && std::isfinite(number) && !std::signbit(number));

// Check for values out of uint16_t range.

if (number >= oneGreaterThanMaxUInt16) {

m_values.push_back(oneGreaterThanMaxUInt16);

m_leadingZeros = 0;

return;

}

// Append the units to m_values.

double integerPart = floor(number);

m_values.push_back(static_cast<uint32_t>(integerPart));

bool sign;

int32_t exponent;

uint64_t mantissa;

decomposeDouble(number - integerPart, sign, exponent, mantissa);

ASSERT(!sign && exponent < 0);

exponent -= divideByExponent;

int32_t zeroBits = -exponent;

--zeroBits;

// Append the append words for to m_values.

while (zeroBits >= 32) {

m_values.push_back(0);

zeroBits -= 32;

}

// Left align the 53 bits of the mantissa within 96 bits.

uint32_t values[3];

values[0] = static_cast<uint32_t>(mantissa >> 21);

values[1] = static_cast<uint32_t>(mantissa << 11);

values[2] = 0;

// Shift based on the remainder of the exponent.

if (zeroBits) {

values[2] = values[1] << (32 - zeroBits);

values[1] = (values[1] >> zeroBits) | (values[0] << (32 - zeroBits));

values[0] = (values[0] >> zeroBits);

}

m_values.push_back(values[0]);

m_values.push_back(values[1]);

m_values.push_back(values[2]);

// Canonicalize; remove any trailing zeros.

while (m_values.size() > 1 && !m_values.back())

m_values.pop_back();

// Count the number of leading zero, this is useful in optimizing multiplies.

m_leadingZeros = 0;

while (m_leadingZeros < m_values.size() && !m_values[m_leadingZeros])

++m_leadingZeros;

}

Uint16WithFraction& operator*=(uint16_t multiplier)

{

ASSERT(checkConsistency());

// iteratate backwards over the fraction until we reach the leading zeros,

// passing the carry from one calculation into the next.

uint64_t accumulator = 0;

for (size_t i = m_values.size(); i > m_leadingZeros;) {

--i;

accumulator += static_cast<uint64_t>(m_values[i]) * static_cast<uint64_t>(multiplier);

m_values[i] = static_cast<uint32_t>(accumulator);

accumulator >>= 32;

}

if (!m_leadingZeros) {

// With a multiplicand and multiplier in the uint16_t range, this cannot carry

// (even allowing for the infinity value).

ASSERT(!accumulator);

// Check for overflow & clamp to 'infinity'.

if (m_values[0] >= oneGreaterThanMaxUInt16) {

ASSERT(m_values.size() <= 1);

m_values.shrink_to_fit();

m_values[0] = oneGreaterThanMaxUInt16;

m_leadingZeros = 0;

return *this;

}

} else if (accumulator) {

// Check for carry from the last multiply, if so overwrite last leading zero.

m_values[--m_leadingZeros] = static_cast<uint32_t>(accumulator);

// The limited range of the multiplier should mean that even if we carry into

// the units, we don't need to check for overflow of the uint16_t range.

ASSERT(m_values[0] < oneGreaterThanMaxUInt16);

}

// Multiplication by an even value may introduce trailing zeros; if so, clean them

// up. (Keeping the value in a normalized form makes some of the comparison operations

// more efficient).

while (m_values.size() > 1 && !m_values.back())

m_values.pop_back();

ASSERT(checkConsistency());

return *this;

}

bool operator<(const Uint16WithFraction& other)

{

ASSERT(checkConsistency());

ASSERT(other.checkConsistency());

// Iterate over the common lengths of arrays.

size_t minSize = std::min(m_values.size(), other.m_values.size());

for (size_t index = 0; index < minSize; ++index) {

// If we find a value that is not equal, compare and return.

uint32_t fromThis = m_values[index];

uint32_t fromOther = other.m_values[index];

if (fromThis != fromOther)

return fromThis < fromOther;

}

// If these numbers have the same lengths, they are equal,

// otherwise which ever number has a longer fraction in larger.

return other.m_values.size() > minSize;

}

// Return the floor (non-fractional portion) of the number, clearing this to zero,

// leaving the fractional part unchanged.

uint32_t floorAndSubtract()

{

// 'floor' is simple the integer portion of the value.

uint32_t floor = m_values[0];

// If floor is non-zero,

if (floor) {

m_values[0] = 0;

m_leadingZeros = 1;

while (m_leadingZeros < m_values.size() && !m_values[m_leadingZeros])

++m_leadingZeros;

}

return floor;

}

// Compare this value to 0.5, returns -1 for less than, 0 for equal, 1 for greater.

int comparePoint5()

{

ASSERT(checkConsistency());

// If units != 0, this is greater than 0.5.

if (m_values[0])

return 1;

// If size == 1 this value is 0, hence < 0.5.

if (m_values.size() == 1)

return -1;

// Compare to 0.5.

if (m_values[1] > 0x80000000ul)

return 1;

if (m_values[1] < 0x80000000ul)

return -1;

// Check for more words - since normalized numbers have no trailing zeros, if

// there are more that two digits we can assume at least one more is non-zero,

// and hence the value is > 0.5.

return m_values.size() > 2 ? 1 : 0;

}

// Return true if the sum of this plus addend would be greater than 1.

bool sumGreaterThanOne(const Uint16WithFraction& addend)

{

ASSERT(checkConsistency());

ASSERT(addend.checkConsistency());

// First, sum the units. If the result is greater than one, return true.

// If equal to one, return true if either number has a fractional part.

uint32_t sum = m_values[0] + addend.m_values[0];

if (sum)

return sum > 1 || std::max(m_values.size(), addend.m_values.size()) > 1;

// We could still produce a result greater than zero if addition of the next

// word from the fraction were to carry, leaving a result > 0.

// Iterate over the common lengths of arrays.

size_t minSize = std::min(m_values.size(), addend.m_values.size());

for (size_t index = 1; index < minSize; ++index) {

// Sum the next word from this & the addend.

uint32_t fromThis = m_values[index];

uint32_t fromAddend = addend.m_values[index];

sum = fromThis + fromAddend;

// Check for overflow. If so, check whether the remaining result is non-zero,

// or if there are any further words in the fraction.

if (sum < fromThis)

return sum || (index + 1) < std::max(m_values.size(), addend.m_values.size());

// If the sum is uint32_t max, then we would carry a 1 if addition of the next

// digits in the number were to overflow.

if (sum != 0xFFFFFFFF)

return false;

}

return false;

}

bool checkConsistency() const

{

// All values should have at least one value.

return (m_values.size())

// The units value must be a uint16_t, or the value is the overflow value.

&& (m_values[0] < oneGreaterThanMaxUInt16 || (m_values[0] == oneGreaterThanMaxUInt16 && m_values.size() == 1))

// There should be no trailing zeros (unless this value is zero!).

&& (m_values.back() || m_values.size() == 1);

}

// The internal storage of the number. This vector is always at least one entry in size,

// with the first entry holding the portion of the number greater than zero. The first

// value always hold a value in the uint16_t range, or holds the value oneGreaterThanMaxUInt16 to

// indicate the value has overflowed to >= 0x10000. If the units value is oneGreaterThanMaxUInt16,

// there can be no fraction (size must be 1).

//

// Subsequent values in the array represent portions of the fractional part of this number.

// The total value of the number is the sum of (m_values[i] / pow(2^32, i)), for each i

// in the array. The vector should contain no trailing zeros, except for the value '0',

// represented by a vector contianing a single zero value. These constraints are checked

// by 'checkConsistency()', above.

//

// The inline capacity of the vector is set to be able to contain any IEEE double (1 for

// the units column, 32 for zeros introduced due to an exponent up to -3FE, and 2 for

// bits taken from the mantissa).

std::vector<uint32_t> m_values;

// Cache a count of the number of leading zeros in m_values. We can use this to optimize

// methods that would otherwise need visit all words in the vector, e.g. multiplication.

size_t m_leadingZeros;