G3D::uint128 Class Reference

#include <uint128.h>

Public Member Functions
	uint128 (const uint64 &lo)
	uint128 (const uint64 &hi, const uint64 &lo)
uint128 &	operator+= (const uint128 &x)
uint128 &	operator*= (const uint128 &x)
uint128 &	operator^= (const uint128 &x)
uint128 &	operator&= (const uint128 &x)
uint128 &	operator|= (const uint128 &x)
bool	operator== (const uint128 &x)
uint128 &	operator>>= (const int x)
uint128 &	operator<<= (const int x)
uint128	operator& (const uint128 &x)

Public Attributes
G3D::uint64	hi
G3D::uint64	lo

Detailed Description

Limited functionality 128-bit unsigned integer. This is primarily to support FNV hashing and other cryptography applications. See the GMP library for high-precision C++ math support.

Constructor & Destructor Documentation

G3D::uint128::uint128

(

const uint64 &

lo

)

 : hi(0), lo(lo) {
}

Here is the caller graph for this function:

G3D::uint128::uint128	(	const uint64 &	hi,
		const uint64 &	lo
	)

 : hi(hi), lo(lo) {
}

Member Function Documentation

uint128 G3D::uint128::operator&

(

const uint128 &

x

)

 {
 return uint128(hi & x.hi, lo & x.lo);
}

Here is the call graph for this function:

uint128 & G3D::uint128::operator&=

(

const uint128 &

x

)

 {
 hi &= x.hi;
 lo &= x.lo;
 return *this;
}

uint128 & G3D::uint128::operator*=

(

const uint128 &

x

)

 {

 // The low bits will get overwritten when doing the multiply, so back up both (in case &x == this)
 const uint64 oldLo = lo;
 const uint64 oldXLo = x.lo;

 G3D::uint64 carry;
 multiplyAndCarry(oldLo, oldXLo, carry, lo);

 // Overflow doesn't matter here because the result is going into hi - any overflow will exceed the capacity of a 128-bit number
 // Note: hi * x.hi will always overflow, since (x * 2^64) * (y * 2^64) = x*y*(2^128). The largest number expressable in 128 bits is
 // 2^128 - 1.
 hi = carry + (oldLo * x.hi) + (hi * oldXLo);

 return *this;
}

Here is the call graph for this function:

uint128 & G3D::uint128::operator+=

(

const uint128 &

x

)

 {

 G3D::uint64 carry;
 addAndCarry(lo, x.lo, carry, lo);

 // Adding the carry will change hi. Save the old hi bits in case this == x.
 const uint64 xHi = x.hi;
 hi += carry;
 hi += xHi;
 return *this;
}

Here is the call graph for this function:

uint128 & G3D::uint128::operator<<=

(

const int

x

)

 {

 //Before shifting, mask out the bits that will be shifted out of lo.
 //Put a 1 in the last bit that will be lost in the shift, then subtract 1 to get the logical inverse of the mask.
 //A bitwise NOT will then produce the correct mask.
 uint64 mask = ~((((uint64)1L) << (64 - x)) - 1);
 uint64 tmp = lo & mask;
 lo <<= x;

 //Shift hi and add the bits shifted up from lo
 hi = (hi << x) + (tmp >> (64 - x));
 
 return *this;
}

bool G3D::uint128::operator==

(

const uint128 &

x

)

 {
 return (hi == x.hi) && (lo == x.lo);
}

uint128 & G3D::uint128::operator>>=

(

const int

x

)

 {

 //Before shifting, mask out the bits that will be shifted out of hi.
 //Put a 1 in the first bit that will not be lost in the shift, then subtract 1 to get the mask.
 uint64 mask = ((uint64)1L << x) - 1;
 uint64 tmp = hi & mask;
 hi >>= x;

 //Shift lo and add the bits shifted down from hi
 lo = (lo >> x) + (tmp << (64 - x));
 
 return *this;
}

uint128 & G3D::uint128::operator^=

(

const uint128 &

x

)

 {
 hi ^= x.hi;
 lo ^= x.lo;
 return *this;
}

uint128 & G3D::uint128::operator|=

(

const uint128 &

x

)

 {
 hi |= x.hi;
 lo |= x.lo;
 return *this;
}

Member Data Documentation

G3D::uint64 G3D::uint128::hi

G3D::uint64 G3D::uint128::lo

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/uint128.h
• dep/g3dlite/source/uint128.cpp