/*----------------------------------------------------------------------------- * eaint128_t.h * * Copyright (c) Electronic Arts Inc. All rights reserved. *---------------------------------------------------------------------------*/ #ifndef INCLUDED_int128_h #define INCLUDED_int128_h /////////////////////////////////////////////////////////////////////////////////////////////////////// // EA_INT128_INTRINSIC_AVAILABLE // #if (EA_COMPILER_INTMAX_SIZE >= 16) && (defined(EA_COMPILER_GNUC) || defined(EA_COMPILER_CLANG)) // __int128_t/__uint128_t is supported #define EA_INT128_INTRINSIC_AVAILABLE 1 #else #define EA_INT128_INTRINSIC_AVAILABLE 0 #endif /////////////////////////////////////////////////////////////////////////////////////////////////////// // EA_INT128_ALIGNAS // #if EA_INT128_INTRINSIC_AVAILABLE && !defined(EA_COMPILER_NO_ALIGNAS) #define EA_INT128_ALIGNAS alignas(unsigned __int128) #else #define EA_INT128_ALIGNAS #endif /////////////////////////////////////////////////////////////////////////////////////////////////////// // EA_HAVE_INT128 // // Indicates that EABase implements 128-bit integer types // #define EA_HAVE_INT128 1 /////////////////////////////////////////////////////////////////////////////////////////////////////// // uint128_t_base // struct EA_INT128_ALIGNAS int128_t_base { // Constructors / destructors int128_t_base() = default; int128_t_base(uint32_t nPart0, uint32_t nPart1, uint32_t nPart2, uint32_t nPart3); int128_t_base(uint64_t nPart0, uint64_t nPart1); int128_t_base(uint8_t value); int128_t_base(uint16_t value); int128_t_base(uint32_t value); int128_t_base(uint64_t value); int128_t_base(const int128_t_base& value) = default; // Assignment operator int128_t_base& operator=(const int128_t_base& value) = default; // Explicit operators to convert back to basic types EA_CONSTEXPR explicit operator bool() const; EA_CONSTEXPR explicit operator char() const; EA_CONSTEXPR explicit operator int() const; EA_CONSTEXPR explicit operator long() const; EA_CONSTEXPR explicit operator long long() const; EA_CONSTEXPR explicit operator short() const; EA_CONSTEXPR explicit operator signed char() const; EA_CONSTEXPR explicit operator unsigned char() const; EA_CONSTEXPR explicit operator unsigned int() const; EA_CONSTEXPR explicit operator unsigned long long() const; EA_CONSTEXPR explicit operator unsigned long() const; EA_CONSTEXPR explicit operator unsigned short() const; #if EA_WCHAR_UNIQUE // EA_CONSTEXPR explicit operator char16_t() const; // EA_CONSTEXPR explicit operator char32_t() const; // EA_CONSTEXPR explicit operator wchar_t() const; #endif EA_CONSTEXPR explicit operator float() const; EA_CONSTEXPR explicit operator double() const; EA_CONSTEXPR explicit operator long double() const; #if EA_INT128_INTRINSIC_AVAILABLE EA_CONSTEXPR explicit operator __int128() const; EA_CONSTEXPR explicit operator unsigned __int128() const; #endif // Math operators static void OperatorPlus (const int128_t_base& value1, const int128_t_base& value2, int128_t_base& result); static void OperatorMinus(const int128_t_base& value1, const int128_t_base& value2, int128_t_base& result); static void OperatorMul (const int128_t_base& value1, const int128_t_base& value2, int128_t_base& result); // Shift operators static void OperatorShiftRight(const int128_t_base& value, int nShift, int128_t_base& result); static void OperatorShiftLeft (const int128_t_base& value, int nShift, int128_t_base& result); // Unary arithmetic/logic operators bool operator!() const; // Logical operators static void OperatorXOR(const int128_t_base& value1, const int128_t_base& value2, int128_t_base& result); static void OperatorOR (const int128_t_base& value1, const int128_t_base& value2, int128_t_base& result); static void OperatorAND(const int128_t_base& value1, const int128_t_base& value2, int128_t_base& result); bool IsZero() const; void SetZero(); void TwosComplement(); void InverseTwosComplement(); int GetBit(int nIndex) const; void SetBit(int nIndex, int value); protected: void DoubleToUint128(double value); EA_CONSTEXPR uint64_t Low() const { return mPart0; } EA_CONSTEXPR uint64_t High() const { return mPart1; } protected: #ifdef EA_SYSTEM_BIG_ENDIAN uint64_t mPart1; // Most significant byte. uint64_t mPart0; // Least significant byte. #else uint64_t mPart0; // Least significant byte. uint64_t mPart1; // Most significant byte. #endif }; /////////////////////////////////////////////////////////////////////////////////////////////////////// // int128_t // // Implements signed 128 bit integer. // struct int128_t : public int128_t_base { // Constructors / destructors using int128_t_base::int128_t_base; // Assignment operator using int128_t_base::operator=; // Unary arithmetic/logic operators int128_t operator-() const; int128_t& operator++(); int128_t& operator--(); int128_t operator++(int); int128_t operator--(int); int128_t operator~() const; int128_t operator+() const; // Math operators int128_t operator+ (const int128_t& other); int128_t operator- (const int128_t& other); int128_t operator* (const int128_t& other); int128_t operator/ (const int128_t& other); int128_t operator% (const int128_t& other); int128_t& operator+=(const int128_t& other); int128_t& operator-=(const int128_t& other); int128_t& operator*=(const int128_t& other); int128_t& operator/=(const int128_t& other); int128_t& operator%=(const int128_t& other); // Shift operators int128_t operator>> (int nShift) const; int128_t operator<< (int nShift) const; int128_t& operator>>=(int nShift); int128_t& operator<<=(int nShift); // Logical operators int128_t operator^ (const int128_t& other) const; int128_t operator| (const int128_t& other) const; int128_t operator& (const int128_t& other) const; int128_t& operator^=(const int128_t& other); int128_t& operator|=(const int128_t& other); int128_t& operator&=(const int128_t& other); // Equality operators bool operator==(const int128_t& other) const; bool operator!=(const int128_t& other) const; bool operator> (const int128_t& other) const; bool operator>=(const int128_t& other) const; bool operator< (const int128_t& other) const; bool operator<=(const int128_t& other) const; protected: int compare(const int128_t& other) const; void Negate(); void Modulus(const int128_t& divisor, int128_t& quotient, int128_t& remainder) const; bool IsNegative() const; // Returns true for value < 0 bool IsPositive() const; // Returns true for value >= 0 }; /////////////////////////////////////////////////////////////////////////////////////////////////////// // uint128_t // // Implements unsigned 128 bit integer. // struct uint128_t : public int128_t_base { // Constructors / destructors using int128_t_base::int128_t_base; // Assignment operator using int128_t_base::operator=; // Unary arithmetic/logic operators uint128_t operator-() const; uint128_t& operator++(); uint128_t& operator--(); uint128_t operator++(int); uint128_t operator--(int); uint128_t operator~() const; uint128_t operator+() const; // Math operators uint128_t operator+ (const uint128_t& other); uint128_t operator- (const uint128_t& other); uint128_t operator* (const uint128_t& other); uint128_t operator/ (const uint128_t& other); uint128_t operator% (const uint128_t& other); uint128_t& operator+=(const uint128_t& other); uint128_t& operator-=(const uint128_t& other); uint128_t& operator*=(const uint128_t& other); uint128_t& operator/=(const uint128_t& other); uint128_t& operator%=(const uint128_t& other); // Shift operators uint128_t operator>> (int nShift) const; uint128_t operator<< (int nShift) const; uint128_t& operator>>=(int nShift); uint128_t& operator<<=(int nShift); // Logical operators uint128_t operator^ (const uint128_t& other) const; uint128_t operator| (const uint128_t& other) const; uint128_t operator& (const uint128_t& other) const; uint128_t& operator^=(const uint128_t& other); uint128_t& operator|=(const uint128_t& other); uint128_t& operator&=(const uint128_t& other); // Equality operators bool operator==(const uint128_t& other) const; bool operator!=(const uint128_t& other) const; bool operator> (const uint128_t& other) const; bool operator>=(const uint128_t& other) const; bool operator< (const uint128_t& other) const; bool operator<=(const uint128_t& other) const; protected: int compare(const uint128_t& other) const; void Negate(); void Modulus(const uint128_t& divisor, uint128_t& quotient, uint128_t& remainder) const; bool IsNegative() const; // Returns true for value < 0 bool IsPositive() const; // Returns true for value >= 0 }; /////////////////////////////////////////////////////////////////////////////////////////////////////// // uint128_t_base implementation /////////////////////////////////////////////////////////////////////////////////////////////////////// EA_CONSTEXPR inline int128_t_base::operator bool() const { return mPart0 || mPart1; } EA_CONSTEXPR inline int128_t_base::operator char() const { return static_cast(Low()); } #if EA_WCHAR_UNIQUE // EA_CONSTEXPR inline int128_t_base::operator char16_t() const { return static_cast(Low()); } // EA_CONSTEXPR inline int128_t_base::operator char32_t() const { return static_cast(Low()); } // EA_CONSTEXPR inline int128_t_base::operator wchar_t() const { return static_cast(Low()); } #endif EA_CONSTEXPR inline int128_t_base::operator int() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator long() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator long long() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator short() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator signed char() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator unsigned char() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator unsigned int() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator unsigned long long() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator unsigned long() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator unsigned short() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator float() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator double() const { return static_cast(Low()); } EA_CONSTEXPR inline int128_t_base::operator long double() const { return static_cast(Low()); } #if EA_INT128_INTRINSIC_AVAILABLE EA_CONSTEXPR inline int128_t_base::operator __int128() const { return static_cast<__int128>(Low()); } EA_CONSTEXPR inline int128_t_base::operator unsigned __int128() const { return static_cast(Low()); } #endif inline void int128_t_base::SetBit(int nIndex, int value) { // EA_ASSERT((nIndex >= 0) && (nIndex < 128)); const uint64_t nBitMask = ((uint64_t)1 << (nIndex % 64)); if(nIndex < 64) { if(value) mPart0 = mPart0 | nBitMask; else mPart0 = mPart0 & ~nBitMask; } else if(nIndex < 128) { if(value) mPart1 = mPart1 | nBitMask; else mPart1 = mPart1 & ~nBitMask; } } inline int int128_t_base::GetBit(int nIndex) const { // EA_ASSERT((nIndex >= 0) && (nIndex < 128)); const uint64_t nBitMask = ((uint64_t)1 << (nIndex % 64)); if(nIndex < 64) return ((mPart0 & nBitMask) ? 1 : 0); else if(nIndex < 128) return ((mPart1 & nBitMask) ? 1 : 0); return 0; } inline int128_t_base::int128_t_base(uint32_t nPart0, uint32_t nPart1, uint32_t nPart2, uint32_t nPart3) { mPart1 = ((uint64_t)nPart3 << 32) + nPart2; mPart0 = ((uint64_t)nPart1 << 32) + nPart0; } inline int128_t_base::int128_t_base(uint64_t nPart0, uint64_t nPart1) { mPart1 = nPart1; mPart0 = nPart0; } inline int128_t_base::int128_t_base(uint8_t value) { mPart1 = 0; mPart0 = value; } inline int128_t_base::int128_t_base(uint16_t value) { mPart1 = 0; mPart0 = value; } inline int128_t_base::int128_t_base(uint32_t value) { mPart1 = 0; mPart0 = value; } inline int128_t_base::int128_t_base(uint64_t value) { mPart1 = 0; mPart0 = value; } /////////////////////////////////////////////////////////////////////////////// // OperatorPlus // // Returns: (value1 + value2) into result. // The output 'result' *is* allowed to point to the same memory as one of the inputs. // To consider: Fix 'defect' of this function whereby it doesn't implement overflow wraparound. // inline void int128_t_base::OperatorPlus(const int128_t_base& value1, const int128_t_base& value2, int128_t_base& result) { uint64_t t = value1.mPart0 + value2.mPart0; uint64_t nCarry = (t < value1.mPart0) && (t < value2.mPart0); result.mPart0 = t; result.mPart1 = value1.mPart1 + value2.mPart1 + nCarry; } /////////////////////////////////////////////////////////////////////////////// // OperatorMinus // // Returns: (value1 - value2) into result. // The output 'result' *is* allowed to point to the same memory as one of the inputs. // To consider: Fix 'defect' of this function whereby it doesn't implement overflow wraparound. // inline void int128_t_base::OperatorMinus(const int128_t_base& value1, const int128_t_base& value2, int128_t_base& result) { uint64_t t = (value1.mPart0 - value2.mPart0); uint64_t nCarry = (value1.mPart0 < value2.mPart0) ? 1u : 0u; result.mPart0 = t; result.mPart1 = (value1.mPart1 - value2.mPart1) - nCarry; } /////////////////////////////////////////////////////////////////////////////// // OperatorMul // // 64 bit systems: // This is how it would be able to work if we could get a 128 bit result from // two 64 bit values. None of the 64 bit systems that we are currently working // with have C language support for multiplying two 64 bit numbers and retrieving // the 128 bit result. However, many 64 bit platforms have support at the asm // level for doing such a thing. // Part 1 Part 0 // 0000000000000002 0000000000000001 // x 0000000000000002 0000000000000001 // ------------------------------------------- // | 0000000000000002 0000000000000001 // + 0000000000000004 | 0000000000000002 (0000000000000000) // ------------------------------------------------------------------------- // inline void int128_t_base::OperatorMul(const int128_t_base& a, const int128_t_base& b, int128_t_base& result) { // To consider: Use compiler or OS-provided custom functionality here, such as // Windows UnsignedMultiply128 and GCC's built-in int128_t. #if defined(DISABLED_PLATFORM_WIN64) // To do: Implement x86-64 asm here. #else // Else we are stuck doing something less efficient. In this case we // fall back to doing 32 bit multiplies as with 32 bit platforms. result = (a.mPart0 & 0xffffffff) * (b.mPart0 & 0xffffffff); int128_t v01 = (a.mPart0 & 0xffffffff) * ((b.mPart0 >> 32) & 0xffffffff); int128_t v02 = (a.mPart0 & 0xffffffff) * (b.mPart1 & 0xffffffff); int128_t v03 = (a.mPart0 & 0xffffffff) * ((b.mPart1 >> 32) & 0xffffffff); int128_t v10 = ((a.mPart0 >> 32) & 0xffffffff) * (b.mPart0 & 0xffffffff); int128_t v11 = ((a.mPart0 >> 32) & 0xffffffff) * ((b.mPart0 >> 32) & 0xffffffff); int128_t v12 = ((a.mPart0 >> 32) & 0xffffffff) * (b.mPart1 & 0xffffffff); int128_t v20 = (a.mPart1 & 0xffffffff) * (b.mPart0 & 0xffffffff); int128_t v21 = (a.mPart1 & 0xffffffff) * ((b.mPart0 >> 32) & 0xffffffff); int128_t v30 = ((a.mPart1 >> 32) & 0xffffffff) * (b.mPart0 & 0xffffffff); // Do row addition, shifting as needed. OperatorPlus(result, v01 << 32, result); OperatorPlus(result, v02 << 64, result); OperatorPlus(result, v03 << 96, result); OperatorPlus(result, v10 << 32, result); OperatorPlus(result, v11 << 64, result); OperatorPlus(result, v12 << 96, result); OperatorPlus(result, v20 << 64, result); OperatorPlus(result, v21 << 96, result); OperatorPlus(result, v30 << 96, result); #endif } /////////////////////////////////////////////////////////////////////////////// // OperatorShiftRight // // Returns: value >> nShift into result // The output 'result' may *not* be the same as one the input. // With rightward shifts of negative numbers, shift in zero from the left side. // inline void int128_t_base::OperatorShiftRight(const int128_t_base& value, int nShift, int128_t_base& result) { if(nShift >= 0) { if(nShift < 64) { // 0 - 63 result.mPart1 = (value.mPart1 >> nShift); if(nShift == 0) result.mPart0 = (value.mPart0 >> nShift); else result.mPart0 = (value.mPart0 >> nShift) | (value.mPart1 << (64 - nShift)); } else { // 64+ result.mPart1 = 0; result.mPart0 = (value.mPart1 >> (nShift - 64)); } } else // (nShift < 0) OperatorShiftLeft(value, -nShift, result); } /////////////////////////////////////////////////////////////////////////////// // OperatorShiftRight // // Returns: value << nShift into result // The output 'result' may *not* be the same as one the input. // With rightward shifts of negative numbers, shift in zero from the left side. // inline void int128_t_base::OperatorShiftLeft(const int128_t_base& value, int nShift, int128_t_base& result) { if(nShift >= 0) { if(nShift < 64) { if(nShift) // We need to have a special case because CPUs convert a shift by 64 to a no-op. { // 1 - 63 result.mPart0 = (value.mPart0 << nShift); result.mPart1 = (value.mPart1 << nShift) | (value.mPart0 >> (64 - nShift)); } else { result.mPart0 = value.mPart0; result.mPart1 = value.mPart1; } } else { // 64+ result.mPart0 = 0; result.mPart1 = (value.mPart0 << (nShift - 64)); } } else // (nShift < 0) OperatorShiftRight(value, -nShift, result); } inline bool int128_t_base::operator!() const { return (mPart0 == 0) && (mPart1 == 0); } /////////////////////////////////////////////////////////////////////////////// // OperatorXOR // // Returns: value1 ^ value2 into result // The output 'result' may be the same as one the input. // inline void int128_t_base::OperatorXOR(const int128_t_base& value1, const int128_t_base& value2, int128_t_base& result) { result.mPart0 = (value1.mPart0 ^ value2.mPart0); result.mPart1 = (value1.mPart1 ^ value2.mPart1); } /////////////////////////////////////////////////////////////////////////////// // OperatorOR // // Returns: value1 | value2 into result // The output 'result' may be the same as one the input. // inline void int128_t_base::OperatorOR(const int128_t_base& value1, const int128_t_base& value2, int128_t_base& result) { result.mPart0 = (value1.mPart0 | value2.mPart0); result.mPart1 = (value1.mPart1 | value2.mPart1); } /////////////////////////////////////////////////////////////////////////////// // OperatorAND // // Returns: value1 & value2 into result // The output 'result' may be the same as one the input. // inline void int128_t_base::OperatorAND(const int128_t_base& value1, const int128_t_base& value2, int128_t_base& result) { result.mPart0 = (value1.mPart0 & value2.mPart0); result.mPart1 = (value1.mPart1 & value2.mPart1); } inline bool int128_t_base::IsZero() const { return (mPart0 == 0) && // Check mPart0 first as this will likely yield faster execution. (mPart1 == 0); } inline void int128_t_base::SetZero() { mPart1 = 0; mPart0 = 0; } inline void int128_t_base::TwosComplement() { mPart1 = ~mPart1; mPart0 = ~mPart0; // What we want to do, but isn't available at this level: // operator++(); // Alternative: int128_t_base one((uint32_t)1); OperatorPlus(*this, one, *this); } inline void int128_t_base::InverseTwosComplement() { // What we want to do, but isn't available at this level: // operator--(); // Alternative: int128_t_base one((uint32_t)1); OperatorMinus(*this, one, *this); mPart1 = ~mPart1; mPart0 = ~mPart0; } inline void int128_t_base::DoubleToUint128(double value) { // Currently this function is limited to 64 bits of integer input. // We need to make a better version of this function. Perhaps we should implement // it via dissecting the IEEE floating point format (sign, exponent, matissa). // EA_ASSERT(fabs(value) < 18446744073709551616.0); // Assert that the input is <= 64 bits of integer. mPart1 = 0; mPart0 = (value >= 0 ? (uint64_t)value : (uint64_t)-value); } /////////////////////////////////////////////////////////////////////////////////////////////////////// // uint128_t implementation /////////////////////////////////////////////////////////////////////////////////////////////////////// inline uint128_t uint128_t::operator^(const uint128_t& other) const { uint128_t temp; uint128_t::OperatorXOR(*this, other, temp); return temp; } inline uint128_t uint128_t::operator|(const uint128_t& other) const { uint128_t temp; uint128_t::OperatorOR(*this, other, temp); return temp; } inline uint128_t uint128_t::operator&(const uint128_t& other) const { uint128_t temp; uint128_t::OperatorAND(*this, other, temp); return temp; } inline uint128_t& uint128_t::operator^=(const uint128_t& value) { OperatorXOR(*this, value, *this); return *this; } inline uint128_t& uint128_t::operator|=(const uint128_t& value) { OperatorOR(*this, value, *this); return *this; } inline uint128_t& uint128_t::operator&=(const uint128_t& value) { OperatorAND(*this, value, *this); return *this; } // With rightward shifts of negative numbers, shift in zero from the left side. inline uint128_t uint128_t::operator>>(int nShift) const { uint128_t temp; OperatorShiftRight(*this, nShift, temp); return temp; } // With rightward shifts of negative numbers, shift in zero from the left side. inline uint128_t uint128_t::operator<<(int nShift) const { uint128_t temp; OperatorShiftLeft(*this, nShift, temp); return temp; } inline uint128_t& uint128_t::operator>>=(int nShift) { uint128_t temp; OperatorShiftRight(*this, nShift, temp); *this = temp; return *this; } inline uint128_t& uint128_t::operator<<=(int nShift) { uint128_t temp; OperatorShiftLeft(*this, nShift, temp); *this = temp; return *this; } inline uint128_t& uint128_t::operator+=(const uint128_t& value) { OperatorPlus(*this, value, *this); return *this; } inline uint128_t& uint128_t::operator-=(const uint128_t& value) { OperatorMinus(*this, value, *this); return *this; } inline uint128_t& uint128_t::operator*=(const uint128_t& value) { *this = *this * value; return *this; } inline uint128_t& uint128_t::operator/=(const uint128_t& value) { *this = *this / value; return *this; } inline uint128_t& uint128_t::operator%=(const uint128_t& value) { *this = *this % value; return *this; } inline uint128_t uint128_t::operator+(const uint128_t& other) { uint128_t temp; uint128_t::OperatorPlus(*this, other, temp); return temp; } inline uint128_t uint128_t::operator-(const uint128_t& other) { uint128_t temp; uint128_t::OperatorMinus(*this, other, temp); return temp; } inline uint128_t uint128_t::operator*(const uint128_t& other) { uint128_t returnValue; int128_t_base::OperatorMul(*this, other, returnValue); return returnValue; } inline uint128_t uint128_t::operator/(const uint128_t& other) { uint128_t remainder; uint128_t quotient; this->Modulus(other, quotient, remainder); return quotient; } inline uint128_t uint128_t::operator%(const uint128_t& other) { uint128_t remainder; uint128_t quotient; this->Modulus(other, quotient, remainder); return remainder; } inline uint128_t uint128_t::operator+() const { return *this; } inline uint128_t uint128_t::operator~() const { return uint128_t(~mPart0, ~mPart1); } inline uint128_t& uint128_t::operator--() { int128_t_base one((uint32_t)1); OperatorMinus(*this, one, *this); return *this; } inline uint128_t uint128_t::operator--(int) { uint128_t temp((uint32_t)1); OperatorMinus(*this, temp, temp); return temp; } inline uint128_t uint128_t::operator++(int) { uint128_t prev = *this; uint128_t temp((uint32_t)1); OperatorPlus(*this, temp, *this); return prev; } inline uint128_t& uint128_t::operator++() { int128_t_base one((uint32_t)1); OperatorPlus(*this, one, *this); return *this; } inline void uint128_t::Negate() { TwosComplement(); } inline uint128_t uint128_t::operator-() const { uint128_t returnValue(*this); returnValue.Negate(); return returnValue; } // This function forms the basis of all logical comparison functions. // If value1 < value2, the return value is -1. // If value1 == value2, the return value is 0. // If value1 > value2, the return value is 1. inline int uint128_t::compare(const uint128_t& other) const { // Compare individual parts. At this point, the two numbers have the same sign. if(mPart1 == other.mPart1) { if(mPart0 == other.mPart0) return 0; else if(mPart0 > other.mPart0) return 1; // return -1; //Just fall through to the end. } else if(mPart1 > other.mPart1) return 1; return -1; } EA_DISABLE_VC_WARNING(4723) // warning C4723: potential divide by 0 inline void uint128_t::Modulus(const uint128_t& divisor, uint128_t& quotient, uint128_t& remainder) const { uint128_t tempDividend(*this); uint128_t tempDivisor(divisor); if(tempDivisor.IsZero()) { // Force a divide by zero exception. // We know that tempDivisor.mPart0 is zero. quotient.mPart0 /= tempDivisor.mPart0; } else if(tempDividend.IsZero()) { quotient = uint128_t((uint32_t)0); remainder = uint128_t((uint32_t)0); } else { remainder.SetZero(); for(int i(0); i < 128; i++) { remainder += (uint32_t)tempDividend.GetBit(127 - i); const bool bBit(remainder >= tempDivisor); quotient.SetBit(127 - i, bBit); if(bBit) remainder -= tempDivisor; if((i != 127) && !remainder.IsZero()) remainder <<= 1; } } } EA_RESTORE_VC_WARNING() inline bool uint128_t::operator==(const uint128_t& other) const { return (mPart0 == other.mPart0) && // Check mPart0 first as this will likely yield faster execution. (mPart1 == other.mPart1); } inline bool uint128_t::operator< (const uint128_t& other) const { return (compare(other) < 0); } inline bool uint128_t::operator!=(const uint128_t& other) const { return !(*this == other); } inline bool uint128_t::operator> (const uint128_t& other) const { return other < *this; } inline bool uint128_t::operator>=(const uint128_t& other) const { return !(*this < other); } inline bool uint128_t::operator<=(const uint128_t& other) const { return !(other < *this); } inline bool uint128_t::IsNegative() const { // True if value < 0 return false; } inline bool uint128_t::IsPositive() const { // True of value >= 0 return true; } /////////////////////////////////////////////////////////////////////////////////////////////////////// // int128_t implementation /////////////////////////////////////////////////////////////////////////////////////////////////////// inline void int128_t::Negate() { if (IsPositive()) TwosComplement(); else InverseTwosComplement(); } inline int128_t int128_t::operator-() const { int128_t returnValue(*this); returnValue.Negate(); return returnValue; } inline int128_t& int128_t::operator++() { int128_t_base one((uint32_t)1); OperatorPlus(*this, one, *this); return *this; } inline int128_t& int128_t::operator--() { int128_t_base one((uint32_t)1); OperatorMinus(*this, one, *this); return *this; } inline int128_t int128_t::operator++(int) { int128_t prev = *this; int128_t temp((uint32_t)1); OperatorPlus(*this, temp, *this); return prev; } inline int128_t int128_t::operator--(int) { int128_t temp((uint32_t)1); OperatorMinus(*this, temp, temp); return temp; } inline int128_t int128_t::operator+() const { return *this; } inline int128_t int128_t::operator~() const { return int128_t(~mPart0, ~mPart1); } inline int128_t int128_t::operator+(const int128_t& other) { int128_t temp; int128_t::OperatorPlus(*this, other, temp); return temp; } inline int128_t int128_t::operator-(const int128_t& other) { int128_t temp; int128_t::OperatorMinus(*this, other, temp); return temp; } // This function forms the basis of all logical comparison functions. // If value1 < value2, the return value is -1. // If value1 == value2, the return value is 0. // If value1 > value2, the return value is 1. inline int int128_t::compare(const int128_t& other) const { // Cache some values. Positive means >= 0. Negative means < 0 and thus means '!positive'. const bool bValue1IsPositive( IsPositive()); const bool bValue2IsPositive(other.IsPositive()); // Do positive/negative tests. if(bValue1IsPositive != bValue2IsPositive) return bValue1IsPositive ? 1 : -1; // Compare individual parts. At this point, the two numbers have the same sign. if(mPart1 == other.mPart1) { if(mPart0 == other.mPart0) return 0; else if(mPart0 > other.mPart0) return 1; // return -1; //Just fall through to the end. } else if(mPart1 > other.mPart1) return 1; return -1; } inline bool int128_t::operator==(const int128_t& other) const { return (mPart0 == other.mPart0) && // Check mPart0 first as this will likely yield faster execution. (mPart1 == other.mPart1); } inline bool int128_t::operator!=(const int128_t& other) const { return (mPart0 != other.mPart0) || // Check mPart0 first as this will likely yield faster execution. (mPart1 != other.mPart1); } inline bool int128_t::operator>(const int128_t& other) const { return (compare(other) > 0); } inline bool int128_t::operator>=(const int128_t& other) const { return (compare(other) >= 0); } inline bool int128_t::operator<(const int128_t& other) const { return (compare(other) < 0); } inline bool int128_t::operator<=(const int128_t& other) const { return (compare(other) <= 0); } inline bool int128_t::IsNegative() const { // True if value < 0 return ((mPart1 & UINT64_C(0x8000000000000000)) != 0); } inline bool int128_t::IsPositive() const { // True of value >= 0 return ((mPart1 & UINT64_C(0x8000000000000000)) == 0); } inline int128_t int128_t::operator*(const int128_t& other) { int128_t a(*this); int128_t b(other); int128_t returnValue; // Correctly handle negative values bool bANegative(false); bool bBNegative(false); if(a.IsNegative()) { bANegative = true; a.Negate(); } if(b.IsNegative()) { bBNegative = true; b.Negate(); } int128_t_base::OperatorMul(a, b, returnValue); // Do negation as needed. if(bANegative != bBNegative) returnValue.Negate(); return returnValue; } inline int128_t int128_t::operator/(const int128_t& other) { int128_t remainder; int128_t quotient; this->Modulus(other, quotient, remainder); return quotient; } inline int128_t int128_t::operator<<(int nShift) const { int128_t temp; OperatorShiftLeft(*this, nShift, temp); return temp; } inline int128_t& int128_t::operator+=(const int128_t& value) { OperatorPlus(*this, value, *this); return *this; } inline int128_t& int128_t::operator-=(const int128_t& value) { OperatorMinus(*this, value, *this); return *this; } inline int128_t& int128_t::operator<<=(int nShift) { int128_t temp; OperatorShiftLeft(*this, nShift, temp); *this = temp; return *this; } inline int128_t& int128_t::operator*=(const int128_t& value) { *this = *this * value; return *this; } inline int128_t& int128_t::operator%=(const int128_t& value) { *this = *this % value; return *this; } inline int128_t int128_t::operator%(const int128_t& other) { int128_t remainder; int128_t quotient; this->Modulus(other, quotient, remainder); return remainder; } inline int128_t& int128_t::operator/=(const int128_t& value) { *this = *this / value; return *this; } // With rightward shifts of negative numbers, shift in zero from the left side. inline int128_t int128_t::operator>>(int nShift) const { int128_t temp; OperatorShiftRight(*this, nShift, temp); return temp; } inline int128_t& int128_t::operator>>=(int nShift) { int128_t temp; OperatorShiftRight(*this, nShift, temp); *this = temp; return *this; } inline int128_t int128_t::operator^(const int128_t& other) const { int128_t temp; int128_t::OperatorXOR(*this, other, temp); return temp; } inline int128_t int128_t::operator|(const int128_t& other) const { int128_t temp; int128_t::OperatorOR(*this, other, temp); return temp; } inline int128_t int128_t::operator&(const int128_t& other) const { int128_t temp; int128_t::OperatorAND(*this, other, temp); return temp; } inline int128_t& int128_t::operator^=(const int128_t& value) { OperatorXOR(*this, value, *this); return *this; } inline int128_t& int128_t::operator|=(const int128_t& value) { OperatorOR(*this, value, *this); return *this; } inline int128_t& int128_t::operator&=(const int128_t& value) { OperatorAND(*this, value, *this); return *this; } EA_DISABLE_VC_WARNING(4723) // warning C4723: potential divide by 0 inline void int128_t::Modulus(const int128_t& divisor, int128_t& quotient, int128_t& remainder) const { int128_t tempDividend(*this); int128_t tempDivisor(divisor); bool bDividendNegative = false; bool bDivisorNegative = false; if(tempDividend.IsNegative()) { bDividendNegative = true; tempDividend.Negate(); } if(tempDivisor.IsNegative()) { bDivisorNegative = true; tempDivisor.Negate(); } // Handle the special cases if(tempDivisor.IsZero()) { // Force a divide by zero exception. // We know that tempDivisor.mPart0 is zero. quotient.mPart0 /= tempDivisor.mPart0; } else if(tempDividend.IsZero()) { quotient = int128_t((uint32_t)0); remainder = int128_t((uint32_t)0); } else { remainder.SetZero(); for(int i(0); i < 128; i++) { remainder += (uint32_t)tempDividend.GetBit(127 - i); const bool bBit(remainder >= tempDivisor); quotient.SetBit(127 - i, bBit); if(bBit) remainder -= tempDivisor; if((i != 127) && !remainder.IsZero()) remainder <<= 1; } } if((bDividendNegative && !bDivisorNegative) || (!bDividendNegative && bDivisorNegative)) { // Ensure the following formula applies for negative dividends // dividend = divisor * quotient + remainder quotient.Negate(); } } EA_RESTORE_VC_WARNING() /////////////////////////////////////////////////////////////////////////////////////////////////////// // INT128_C / UINT128_C // // The C99 language defines macros for portably defining constants of // sized numeric types. For example, there might be: // #define UINT64_C(x) x##ULL // Since our int128 data type is not a built-in type, we can't define a // UINT128_C macro as something that pastes ULLL at the end of the digits. // Instead we define it to create a temporary that is constructed from a // string of the digits. This will work in most cases that suffix pasting // would work. // /* EA_CONSTEXPR */ inline uint128_t UINT128_C(uint64_t nPart1, uint64_t nPart0) { return uint128_t(nPart0, nPart1); } /* EA_CONSTEXPR */ inline int128_t INT128_C(int64_t nPart1, int64_t nPart0) { return int128_t(static_cast(nPart0), static_cast(nPart1)); } #endif // INCLUDED_int128_h