uint128_t Class Reference

class for 128-bit unsigned integer More...

#include <uint128_t.hpp>

Public Member Functions
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
	uint128_t (T low)
	Parameterized constructor.
	uint128_t (const std::string &str)
	Parameterized constructor.
	uint128_t (const uint64_t high, const uint64_t low)
	Parameterized constructor.
	uint128_t (const uint128_t &num)=default
	Copy constructor.
	uint128_t (uint128_t &&num) noexcept
	Move constructor.
	~uint128_t ()=default
	Destructor for uint128_t.
uint32_t	_lez ()
	Leading zeroes in binary.
uint32_t	_trz ()
	Trailing zeroes in binary.
	operator bool () const
	casting operator to boolean value
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
	operator T () const
	casting operator to any integer valu
uint64_t	lower () const
	returns lower 64-bit integer part
uint64_t	upper () const
	returns upper 64-bit integer part
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t &	operator= (const T &p)
	operator = for other types
uint128_t &	operator= (const std::string &p)
	operator = for type string
uint128_t &	operator= (const uint128_t &p)=default
	operator = for uint128_t
uint128_t &	operator= (uint128_t &&p)=default
	Move assignment operator.
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t	operator+ (const T p)
	operator + for uint128_t and other integer types.
uint128_t	operator+ (const uint128_t &p)
	operator + for uint128_t and other integer types.
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t &	operator+= (const T p)
	operator += for uint128_t and other integer types.
uint128_t &	operator+= (const uint128_t &p)
	operator += for uint128_t
uint128_t &	operator++ ()
	pre-increment operator
uint128_t	operator++ (int)
	post-increment operator
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t	operator- (const T &p)
	operator - for uint128_t and other integer types.
uint128_t	operator- (const uint128_t &p)
	operator - for uint128_t
uint128_t	operator- ()
	operator - using twos complement
uint128_t &	operator-- ()
	operator – (pre-decrement)
uint128_t	operator-- (int p)
	operator – (post-decrement)
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t &	operator-= (const T &p)
	operator -= for uint128_t and other integer types.
uint128_t &	operator-= (const uint128_t &p)
	operator -= for uint128_t
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t	operator* (const T p)
	operator * for uint128_t and other integer types.
uint128_t	operator* (const uint128_t &p)
	operator * for uint128_t and other integer types.
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t &	operator*= (const T p)
	operator *= for uint128_t and other integer types.
uint128_t &	operator*= (const uint128_t &p)
	operator *= for uint128_t and other integer types.
std::pair< uint128_t, uint128_t >	divide (const uint128_t &p)
	divide function for uint128_t and other integer types.
uint128_t	operator/ (const uint128_t &p)
	operator / for uint128_t and other integer types.
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t	operator/ (const T p)
	operator / for uint128_t and other integer types.
uint128_t &	operator/= (const uint128_t &p)
	operator /= for uint128_t
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t &	operator/= (const T p)
	operator /= for uint128_t and other integer types.
uint128_t	operator% (const uint128_t &p)
	operator % for uint128_t
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t	operator% (const T &p)
	operator % for uint128_t and other integer types.
uint128_t &	operator%= (const uint128_t &p)
	operator %= for uint128_t
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t &	operator%= (const T &p)
	operator %= for uint128_t
bool	operator< (const uint128_t &other)
	operator < for uint128_t
bool	operator<= (const uint128_t &other)
	operator <= for uint128_t
bool	operator> (const uint128_t &other)
	operator > for uint128_t
bool	operator>= (const uint128_t &other)
	operator >= for uint128_t
bool	operator== (const uint128_t &other)
	operator == for uint128_t
bool	operator!= (const uint128_t &other)
	operator != for uint128_t
bool	operator! ()
	operator ! for uint128_t
bool	operator&& (const uint128_t &b)
	operator && for uint128_t
bool	operator|| (const uint128_t &b)
	operator || for uint128_t
bool	operator() ()
	operator () for uint128_t
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
bool	operator< (const T other)
	operator < for other types
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
bool	operator<= (const T other)
	operator <= for other types
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
bool	operator> (const T other)
	operator > for other types
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
bool	operator>= (const T other)
	operator >= for other types
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
bool	operator== (const T other)
	operator == for other types
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
bool	operator!= (const T other)
	operator != for other types
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
bool	operator&& (const T b)
	operator && for other types
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
bool	operator|| (const T b)
	operator || for other types
uint128_t	operator~ ()
	operator ~ for uint128_t
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t	operator<< (const T p)
	operator << for uint128_t
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t &	operator<<= (const T p)
	operator <<= for uint128_t
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t	operator>> (const T p)
	operator >> for uint128_t
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t &	operator>>= (const T p)
	operator >>= for uint128_t
uint128_t	operator& (const uint128_t &p)
	operator & for uint128_t (bitwise operator)
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t	operator& (const T p)
	operator & for other types (bitwise operator)
uint128_t &	operator&= (const uint128_t &p)
	operator &= for uint128_t (bitwise operator)
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t &	operator&= (const T p)
	operator &= for other types (bitwise operator)
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t	operator| (const T p)
	operator | for other types (bitwise operator)
uint128_t	operator| (const uint128_t &p)
	operator | for uint128_t (bitwise operator)
uint128_t &	operator|= (const uint128_t &p)
	operator |= for uint128_t (bitwise operator)
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t &	operator|= (const T p)
	operator |= for other types (bitwise operator)
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t	operator^ (const T p)
	operator ^ for other types (bitwise operator)
uint128_t	operator^ (const uint128_t &p)
	operator ^ for uint128_t (bitwise operator)
uint128_t &	operator^= (const uint128_t &p)
	operator ^= for uint128_t (bitwise operator)
template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>
uint128_t &	operator^= (const T &p)
	operator ^= for other types (bitwise operator)

Private Member Functions
void	__get_integer_from_string (const std::string &str)
	First and second half of 128 bit number.

Private Attributes
uint64_t	f {}
uint64_t	s {}

Friends
std::ostream &	operator<< (std::ostream &op, const uint128_t &p)
	operator << for printing uint128_t integer

Detailed Description

class for 128-bit unsigned integer

Constructor & Destructor Documentation

uint128_t() [1/5]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t::uint128_t ( T low )

inlineexplicit

Parameterized constructor.

Template Parameters

T	integral type

Parameters

low	lower part 8-bit unisgned integer

: s(low) {}

uint128_t() [2/5]

uint128_t::uint128_t ( const std::string & str )

inlineexplicit

Parameterized constructor.

Parameters

str	Integer string (hexadecimal starting with 0x.. or decimal)

                                             {
        __get_integer_from_string(str);
    }

Here is the call graph for this function:

uint128_t() [3/5]

uint128_t::uint128_t ( const uint64_t high, const uint64_t low )

inline

Parameterized constructor.

Parameters

high	higher part 64-bit unsigned integer
low	lower part 64-bit unsigned integer

: f(high), s(low) {}

uint128_t() [4/5]

uint128_t::uint128_t ( const uint128_t & num )

default

Copy constructor.

Parameters

num	128-bit unsigned integer

uint128_t() [5/5]

uint128_t::uint128_t ( uint128_t && num )

inlinenoexcept

Move constructor.

Parameters

num	128-bit unsigned integer

: f(num.f), s(num.s) {}

Member Function Documentation

__get_integer_from_string()

void uint128_t::__get_integer_from_string ( const std::string & str )

inlineprivate

First and second half of 128 bit number.

Get integer from given string.

Create an integer from a given string

Parameters

str	integer string, can be hexadecimal (starting on 0x... or number)

Returns

void

                                                         {
        this->f = this->s = 0;
        if (str.size() > 1 && str[1] == 'x') {  // if hexadecimal
            for (auto i = 2; i < str.size(); ++i) {
                *this *= 16LL;
                if (str[i] >= '0' && str[i] <= '9') {
                    *this += (str[i] - '0');
                } else if (str[i] >= 'A' && str[i] <= 'F') {
                    *this += (str[i] - 'A' + 10);
                } else if (str[i] >= 'a' && str[i] <= 'f') {
                    *this += (str[i] - 'a' + 10);
                }
            }
        } else {  // if decimal
            for (auto &x : str) {
                *this *= 10LL;
                *this += (x - '0');
            }
        }
    }

Here is the call graph for this function:

_lez()

uint32_t uint128_t::_lez ( )

inline

Leading zeroes in binary.

Calculates leading zeros in 128-bit integer

Returns

Integer denoting leading zeroes

                           {
#ifndef _MSC_VER
        if (f) {
            return __builtin_clzll(f);
        }
        return 64 + __builtin_clzll(s);
#else
        unsigned long r = 0;
        _BitScanForward64(&r, f);
        if (r == 64) {
            unsigned long l = 0;
            _BitScanForward64(&l, s);
            return 64 + l;
        }
        return r;
#endif
    }

_trz()

uint32_t uint128_t::_trz ( )

inline

Trailing zeroes in binary.

Calculates leading zeros in 128-bit integer

Returns

Integer denoting Trailing zeroes

                           {
#ifndef _MSC_VER
        if (f) {
            return __builtin_ctzll(f);
        }
        return 64 + __builtin_ctzll(s);
#else
        unsigned long r = 0;
        _BitScanReverse64(&r, s);
        if (r == 64) {
            unsigned long l = 0;
            _BitScanReverse64(&l, f);
            return 64 + l;
        }
        return r;
#endif
    }

divide()

std::pair< uint128_t, uint128_t > uint128_t::divide ( const uint128_t & p )

inline

divide function for uint128_t and other integer types.

divide this value and

Parameters

p	128-bit unsigned integer

Returns

pair denoting quotient and remainder.

                                                             {
        if (*this < p) {  // if this is less than divisor
            return {uint128_t(0), *this};
        } else if (*this == p) {  // if this is equal to divisor
            return {uint128_t(1), uint128_t(0)};
        }
        uint128_t tmp = p, tmp2 = *this;
        uint16_t left = tmp._lez() - _lez();
        tmp <<= left;
        uint128_t quotient(0);
        uint128_t zero(0);
        while (tmp2 >= p) {
            uint16_t shf = tmp2._lez() - tmp._lez();
            if (shf) {
                tmp >>= shf;
                quotient <<= shf;
                left -= shf;
            }
            if (tmp2 < tmp) {
                tmp >>= 1;
                quotient <<= 1;
                --left;
            }
            tmp2 -= tmp;
            ++quotient;
        }
        return {quotient << left, tmp2};
    }

Here is the call graph for this function:

lower()

uint64_t uint128_t::lower ( ) const

inline

returns lower 64-bit integer part

Returns

returns lower 64-bit integer part

{ return s; }

operator bool()

uint128_t::operator bool ( ) const

inlineexplicit

casting operator to boolean value

Returns

true if value of this is non-zero, else false

{ return (f || s); }

operator T()

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t::operator T ( ) const

inlineexplicit

casting operator to any integer valu

Template Parameters

T	any integer type

Returns

integer value casted to mentioned type

                                       {
        return static_cast<T>(s);
    }

operator!()

bool uint128_t::operator! ( )

inline

operator ! for uint128_t

Returns

true if this has zero value, else false

{ return !f && !s; }

operator!=() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

bool uint128_t::operator!= ( const T other )

inline

operator != for other types

Template Parameters

T	integral type

Parameters

other

number to be compared with this

Returns

true if this is not equal to other, else false

                                          {
        return *this != uint128_t(other);
    }

operator!=() [2/2]

bool uint128_t::operator!= ( const uint128_t & other )

inline

operator != for uint128_t

Parameters

other

number to be compared with this

Returns

true if this is not equal than other, else false

                                                   {
        return f != other.f || s != other.s;
    }

operator%() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t uint128_t::operator% ( const T & p )

inline

operator % for uint128_t and other integer types.

Template Parameters

T	denoting integral type

Parameters

p	a type of integer variable

Returns

unsigned 128-bit remainder.

                                           {
        return *this % uint128_t(p);
    }

operator%() [2/2]

uint128_t uint128_t::operator% ( const uint128_t & p )

inline

operator % for uint128_t

Parameters

p	128-bit unsigned integer

Returns

unsigned 128-bit remainder.

{ return divide(p).second; }

Here is the call graph for this function:

operator%=() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t & uint128_t::operator%= ( const T & p )

inline

operator %= for uint128_t

Template Parameters

T	denoting integral type

Parameters

p	a type of integer variable

Returns

this set as unsigned 128-bit remainder.

                                             {
        *this %= uint128_t(p);
        return *this;
    }

operator%=() [2/2]

uint128_t & uint128_t::operator%= ( const uint128_t & p )

inline

operator %= for uint128_t

Parameters

p	128-bit unsigned integer

Returns

this set as unsigned 128-bit remainder.

                                                     {
        *this = divide(p).second;
        return *this;
    }

Here is the call graph for this function:

operator&() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t uint128_t::operator& ( const T p )

inline

operator & for other types (bitwise operator)

Template Parameters

T	integral type

Parameters

p	number to be operated

Returns

value of this & p (& is bit-wise operator)

                                   {
        uint128_t tmp = *this;
        return tmp & uint128_t(p);
    }

operator&() [2/2]

uint128_t uint128_t::operator& ( const uint128_t & p )

inline

operator & for uint128_t (bitwise operator)

Parameters

p	number to be operated

Returns

value of this & p (& is bit-wise operator)

                                                   {
        return uint128_t(this->f & p.f, this->s & p.s);
    }

operator&&() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

bool uint128_t::operator&& ( const T b )

inline

operator && for other types

Template Parameters

T	integral type

Parameters

other

number to be compared with this

Returns

true if this is both values are non-zero, else false

                                      {
        return (f || s) && b;
    }

operator&&() [2/2]

bool uint128_t::operator&& ( const uint128_t & b )

inline

operator && for uint128_t

Parameters

b	number to be compared with this

Returns

true if both of the values are not zero, else false

                                               {
        return (s || f) && (b.s || b.f);
    }

operator&=() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t & uint128_t::operator&= ( const T p )

inline

operator &= for other types (bitwise operator)

Template Parameters

T	integral type

Parameters

p	number to be operated

Returns

this = this & p (& is bit-wise operator)

                                     {
        *this &= uint128_t(p);
        return *this;
    }

operator&=() [2/2]

uint128_t & uint128_t::operator&= ( const uint128_t & p )

inline

operator &= for uint128_t (bitwise operator)

Parameters

p	number to be operated

Returns

this = this & p (& is bit-wise operator)

                                              {
        this->f &= p.f;
        this->s &= p.s;
        return *this;
    }

operator()()

bool uint128_t::operator() ( )

inline

operator () for uint128_t

Returns

true if this value is non-zero, else false

{ return s || f; }

operator*() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t uint128_t::operator* ( const T p )

inline

operator * for uint128_t and other integer types.

Template Parameters

T	denoting integral type

Parameters

p	a type of integer variable

Returns

multiplication of this and p, returning uint128_t integer

                                          {
        return *this * uint128_t(p);
    }

operator*() [2/2]

uint128_t uint128_t::operator* ( const uint128_t & p )

inline

operator * for uint128_t and other integer types.

Parameters

p	128-bit unsigned integer

Returns

multiplication of this and p, returning uint128_t integer

                                            {
        uint64_t f_first = s >> 32, f_second = s & 0xFFFFFFFF,
                 s_first = p.s >> 32, s_second = p.s & 0xFFFFFFFF;
        uint64_t fi = f_first * s_first, se = f_first * s_second,
                 th = s_first * f_second, fo = s_second * f_second;
        uint64_t tmp = ((se & 0xFFFFFFFF) << 32), tmp2 = (th & 0xFFFFFFFF)
                                                         << 32;
        int cc = (tmp + tmp2 < tmp);
        tmp += tmp2;
        cc += (tmp + fo < tmp);
        uint64_t carry = fi + (se >> 32) + (th >> 32);
        return uint128_t(this->f * p.s + this->s * p.f + carry + cc, tmp + fo);
    }

operator*=() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t & uint128_t::operator*= ( const T p )

inline

operator *= for uint128_t and other integer types.

Template Parameters

T	denoting integral type

Parameters

p	a type of integer variable

Returns

multiplication of this and p, returning this

                                            {
        *this *= uint128_t(p);
        return *this;
    }

operator*=() [2/2]

uint128_t & uint128_t::operator*= ( const uint128_t & p )

inline

operator *= for uint128_t and other integer types.

Parameters

p	128-bit unsigned integer

Returns

multiplication of this and p, returning this

                                              {
        uint64_t f_first = s >> 32, f_second = s & 0xFFFFFFFF,
                 s_first = p.s >> 32, s_second = p.s & 0xFFFFFFFF;
        uint64_t fi = f_first * s_first, se = f_first * s_second,
                 th = s_first * f_second, fo = s_second * f_second;
        uint64_t tmp = (se << 32), tmp2 = (th << 32);
        int cc = (tmp + tmp2 < tmp);
        tmp += tmp2;
        cc += (tmp + fo < tmp);
        uint64_t carry = fi + (se >> 32) + (th >> 32);
        f = this->f * p.s + this->s * p.f + carry + cc;
        s = tmp + fo;
        return *this;
    }

operator+() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t uint128_t::operator+ ( const T p )

inline

operator + for uint128_t and other integer types.

Template Parameters

T	denoting integral type

Parameters

p	a type of integer variable

Returns

addition of this and p, returning uint128_t integer

                                          {
        return uint128_t(f + (p + s < s), p + s);
    }

operator+() [2/2]

uint128_t uint128_t::operator+ ( const uint128_t & p )

inline

operator + for uint128_t and other integer types.

Parameters

p	128-bit unsigned integer

Returns

addition of this and p, returning uint128_t integer

                                                   {
        return uint128_t(f + (p.s + s < s) + p.f, p.s + s);
    }

operator++() [1/2]

uint128_t & uint128_t::operator++ ( )

inline

pre-increment operator

Returns

incremented value of this.

                                   {
        *this += 1;
        return *this;
    }

operator++() [2/2]

uint128_t uint128_t::operator++ ( int )

inline

post-increment operator

Returns

incremented value of this.

                                     {
        ++*this;
        return *this;
    }

operator+=() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t & uint128_t::operator+= ( const T p )

inline

operator += for uint128_t and other integer types.

Template Parameters

T	denoting integral type

Parameters

p	a type of integer variable

Returns

addition of this and p, returning this

                                            {
        bool app = p + s < s;
        this->f += app;
        this->s += p;
        return *this;
    }

operator+=() [2/2]

uint128_t & uint128_t::operator+= ( const uint128_t & p )

inline

operator += for uint128_t

Parameters

p	128-bit unsigned integer

Returns

addition of this and p, returning this

                                              {
        bool app = p.s + s < s;
        f = f + app + p.f;
        s = p.s + s;
        return *this;
    }

operator-() [1/3]

uint128_t uint128_t::operator- ( )

inline

operator - using twos complement

Returns

2's complement of this.

{ return ~*this + uint128_t(1); }

operator-() [2/3]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t uint128_t::operator- ( const T & p )

inline

operator - for uint128_t and other integer types.

Template Parameters

T	denoting integral type

Parameters

p	a type of integer variable

Returns

subtraction of this and p, returning uint128_t integer

                                           {
        bool app = p > s;
        return uint128_t(f - app, s - p);
    }

operator-() [3/3]

uint128_t uint128_t::operator- ( const uint128_t & p )

inline

operator - for uint128_t

Parameters

p	a type of integer variable

Returns

subtraction of this and p, returning uint128_t integer

                                                   {
        bool app = p.s > s;
        return uint128_t(f - p.f - app, s - p.s);
    }

operator--() [1/2]

uint128_t & uint128_t::operator-- ( )

inline

operator – (pre-decrement)

Returns

decremented value of this

                                   {
        *this -= 1;
        return *this;
    }

operator--() [2/2]

uint128_t uint128_t::operator-- ( int p )

inline

operator – (post-decrement)

Returns

decremented value of this

                                       {
        --*this;
        return *this;
    }

operator-=() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t & uint128_t::operator-= ( const T & p )

inline

operator -= for uint128_t and other integer types.

Template Parameters

T	denoting integral type

Parameters

p	a type of integer variable

Returns

subtraction of this and p, returning this

                                      {
        bool app = p > s;
        f -= app;
        s -= p;
        return *this;
    }

operator-=() [2/2]

uint128_t & uint128_t::operator-= ( const uint128_t & p )

inline

operator -= for uint128_t

Parameters

p	128-bit unsigned integer

Returns

subtraction of this and p, returning this

                                              {
        bool app = p.s > s;
        f = f - p.f - app;
        s = s - p.s;
        return *this;
    }

operator/() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t uint128_t::operator/ ( const T p )

inline

operator / for uint128_t and other integer types.

Template Parameters

T	denoting integral type

Parameters

p	a type of integer variable

Returns

unsigned 128-bit quotient.

                                          {
        uint128_t tmp = *this;
        tmp /= uint128_t(0, p);
        return tmp;
    }

operator/() [2/2]

uint128_t uint128_t::operator/ ( const uint128_t & p )

inline

operator / for uint128_t and other integer types.

Parameters

p	128-bit unsigned integer

Returns

unsigned 128-bit quotient.

{ return divide(p).first; }

Here is the call graph for this function:

operator/=() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t & uint128_t::operator/= ( const T p )

inline

operator /= for uint128_t and other integer types.

Template Parameters

T	denoting integral type

Parameters

p	a type of integer variable

Returns

this set as unsigned 128-bit quotient.

                                            {
        *this /= uint128_t(0, p);
        return *this;
    }

operator/=() [2/2]

uint128_t & uint128_t::operator/= ( const uint128_t & p )

inline

operator /= for uint128_t

Parameters

p	128-bit unsigned integer

Returns

this set as unsigned 128-bit quotient.

                                                     {
        *this = divide(p).first;
        return *this;
    }

Here is the call graph for this function:

operator<() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

bool uint128_t::operator< ( const T other )

inline

operator < for other types

Template Parameters

T	integral type

Parameters

other

number to be compared with this

Returns

true if this is less than other, else false

                                         {
        return *this < uint128_t(other);
    }

operator<() [2/2]

bool uint128_t::operator< ( const uint128_t & other )

inline

operator < for uint128_t

Parameters

other

number to be compared with this

Returns

true if this is less than other, else false

                                                  {
        return f < other.f || (f == other.f && s < other.s);
    }

operator<<()

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t uint128_t::operator<< ( const T p )

inline

operator << for uint128_t

Template Parameters

T	integral type

Parameters

p	number denoting number of shifts

Returns

value of this shifted by p to left

                                    {
        if (!p) {
            return uint128_t(f, s);
        } else if (p >= 64 && p <= 128) {
            return uint128_t((this->s << (p - 64)), 0);
        } else if (p < 64 && p > 0) {
            return uint128_t((this->f << p) + ((this->s >> (64 - p))),
                             this->s << p);
        }
        return uint128_t(0);
    }

operator<<=()

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t & uint128_t::operator<<= ( const T p )

inline

operator <<= for uint128_t

Template Parameters

T	integral type

Parameters

p	number denoting number of shifts

Returns

this shifted by p to left

                                      {
        if (p) {
            if (p >= 64 && p <= 128) {
                this->f = (this->s << (p - 64));
                this->s = 0;
            } else {
                f = ((this->f << p) + (this->s >> (64 - p)));
                s = (this->s << p);
            }
        }
        return *this;
    }

operator<=() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

bool uint128_t::operator<= ( const T other )

inline

operator <= for other types

Template Parameters

T	integral type

Parameters

other

number to be compared with this

Returns

true if this is less than or equal to other, else false

                                          {
        return *this <= uint128_t(other);
    }

operator<=() [2/2]

bool uint128_t::operator<= ( const uint128_t & other )

inline

operator <= for uint128_t

Parameters

other

number to be compared with this

Returns

true if this is less than or equal to other, else false

                                                   {
        return f < other.f || (f == other.f && s <= other.s);
    }

operator=() [1/3]

uint128_t & uint128_t::operator= ( const std::string & p )

inline

operator = for type string

Parameters

p	a string to assign it's value to equivalent integer

Returns

this pointer with it's value equal to p

                                                    {
        this->__get_integer_from_string(p);
        return *this;
    }

Here is the call graph for this function:

operator=() [2/3]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t & uint128_t::operator= ( const T & p )

inline

operator = for other types

Template Parameters

T	denoting any integer type

Parameters

p	an integer to assign it's value

Returns

this pointer with it's value equal to p

                                            {
        this->s = p;
        return *this;
    }

operator=() [3/3]

uint128_t & uint128_t::operator= ( const uint128_t & p )

inlinedefault

operator = for uint128_t

Parameters

p	an 128-bit integer to assign it's value

Returns

this pointer with it's value equal to p

operator==() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

bool uint128_t::operator== ( const T other )

inline

operator == for other types

Template Parameters

T	integral type

Parameters

other

number to be compared with this

Returns

true if this is equal to other, else false

                                          {
        return *this == uint128_t(other);
    }

operator==() [2/2]

bool uint128_t::operator== ( const uint128_t & other )

inline

operator == for uint128_t

Parameters

other

number to be compared with this

Returns

true if this is equal than other, else false

                                                   {
        return f == other.f && s == other.s;
    }

operator>() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

bool uint128_t::operator> ( const T other )

inline

operator > for other types

Template Parameters

T	integral type

Parameters

other

number to be compared with this

Returns

true if this is greater than other, else false

                                         {
        return *this > uint128_t(other);
    }

operator>() [2/2]

bool uint128_t::operator> ( const uint128_t & other )

inline

operator > for uint128_t

Parameters

other

number to be compared with this

Returns

true if this is greater than other, else false

                                                  {
        return f > other.f || (f == other.f && s > other.s);
    }

operator>=() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

bool uint128_t::operator>= ( const T other )

inline

operator >= for other types

Template Parameters

T	integral type

Parameters

other

number to be compared with this

Returns

true if this is greater than or equal other, else false

                                          {
        return *this >= uint128_t(other);
    }

operator>=() [2/2]

bool uint128_t::operator>= ( const uint128_t & other )

inline

operator >= for uint128_t

Parameters

other

number to be compared with this

Returns

true if this is greater than or equal than other, else false

                                                   {
        return (f > other.f) || (f == other.f && s >= other.s);
    }

operator>>()

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t uint128_t::operator>> ( const T p )

inline

operator >> for uint128_t

Template Parameters

T	integral type

Parameters

p	number denoting number of shifts

Returns

value of this shifted by p to right

                                    {
        if (!p) {
            return uint128_t(this->f, this->s);
        } else if (p >= 64 && p <= 128) {
            return uint128_t(0, (this->f >> (p - 64)));
        } else if (p < 64 && p > 0) {
            return uint128_t((this->f >> p),
                             (this->s >> p) + (this->f << (64 - p)));
        }
        return uint128_t(0);
    }

operator>>=()

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t & uint128_t::operator>>= ( const T p )

inline

operator >>= for uint128_t

Template Parameters

T	integral type

Parameters

p	number denoting number of shifts

Returns

this shifted by p to right

                                      {
        if (p) {
            if (p >= 64) {
                f = 0;
                s = (this->f >> (p - 64));
            } else {
                s = (this->s >> p) + (this->f << (64 - p));
                f = (this->f >> p);
            }
        }
        return *this;
    }

operator^() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t uint128_t::operator^ ( const T p )

inline

operator ^ for other types (bitwise operator)

Template Parameters

T	integral type

Parameters

p	number to be operated

Returns

value of this ^ p (^ is bit-wise XOR operator)

                                          {
        return uint128_t(this->f, this->s ^ p);
    }

operator^() [2/2]

uint128_t uint128_t::operator^ ( const uint128_t & p )

inline

operator ^ for uint128_t (bitwise operator)

Parameters

p	number to be operated

Returns

value of this ^ p (^ is bit-wise XOR operator)

                                                   {
        return uint128_t(this->f ^ p.f, this->s ^ p.s);
    }

operator^=() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t & uint128_t::operator^= ( const T & p )

inline

operator ^= for other types (bitwise operator)

Template Parameters

T	integral type

Parameters

p	number to be operated

Returns

this = this ^ p (^ is bit-wise XOR operator)

                                             {
        s ^= p;
        return *this;
    }

operator^=() [2/2]

uint128_t & uint128_t::operator^= ( const uint128_t & p )

inline

operator ^= for uint128_t (bitwise operator)

Parameters

p	number to be operated

Returns

this = this ^ p (^ is bit-wise XOR operator)

                                              {
        f ^= p.f;
        s ^= p.s;
        return *this;
    }

operator|() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t uint128_t::operator| ( const T p )

inline

operator | for other types (bitwise operator)

Template Parameters

T	integral type

Parameters

p	number to be operated

Returns

value of this | p (| is bit-wise operator)

                                          {
        return uint128_t(p | s);
    }

operator|() [2/2]

uint128_t uint128_t::operator| ( const uint128_t & p )

inline

operator | for uint128_t (bitwise operator)

Parameters

p	number to be operated

Returns

value of this | p (| is bit-wise OR operator)

                                                   {
        return uint128_t(this->f | p.f, this->s | p.s);
    }

operator|=() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

uint128_t & uint128_t::operator|= ( const T p )

inline

operator |= for other types (bitwise operator)

Template Parameters

T	integral type

Parameters

p	number to be operated

Returns

this = this | p (| is bit-wise OR operator)

                                            {
        s |= p.s;
        return *this;
    }

operator|=() [2/2]

uint128_t & uint128_t::operator|= ( const uint128_t & p )

inline

operator |= for uint128_t (bitwise operator)

Parameters

p	number to be operated

Returns

this = this | p (| is bit-wise OR operator)

                                              {
        f |= p.f;
        s |= p.s;
        return *this;
    }

operator||() [1/2]

template<typename T , typename = typename std::enable_if< std::is_integral<T>::value, T>::type>

bool uint128_t::operator|| ( const T b )

inline

operator || for other types

Template Parameters

T	integral type

Parameters

other

number to be compared with this

Returns

true if this is either one of the values are non-zero, else false

                                      {
        return (f || s) || b;
    }

operator||() [2/2]

bool uint128_t::operator|| ( const uint128_t & b )

inline

operator || for uint128_t

Parameters

b	number to be compared with this

Returns

true if one of the values are not zero, else false

                                               {
        return (s || f) || (b.s || b.f);
    }

operator~()

uint128_t uint128_t::operator~ ( )

inline

operator ~ for uint128_t

Returns

1's complement of this number

{ return uint128_t(~this->f, ~this->s); }

upper()

uint64_t uint128_t::upper ( ) const

inline

returns upper 64-bit integer part

Returns

returns upper 64-bit integer part

{ return f; }

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & op, const uint128_t & p )

friend

operator << for printing uint128_t integer

Prints the uint128_t integer in decimal form

Note

Note that this operator is costly since it uses strings to print the value

Parameters

op	ostream object
p	128-bit integer

Returns

op, ostream object.

                                                                      {
        if (!p.f) {
            op << p.s;
        } else {
            std::string out = "0", p_2 = "1";
            for (int i = 0; i < 64; ++i) {
                if (p.s & (1LL << i)) {
                    out = add(out, p_2);
                }
                p_2 = add(p_2, p_2);
            }
            for (int i = 0; i < 64; ++i) {
                if (p.f & (1LL << i)) {
                    out = add(out, p_2);
                }
                p_2 = add(p_2, p_2);
            }
            op << out;
        }
        return op;
    }

Member Data Documentation

f

uint64_t uint128_t::f {}

private

{}, s{};  /// First and second half of 128 bit number

s

uint64_t uint128_t::s {}

private

{}, s{};  /// First and second half of 128 bit number

---

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

• ciphers/uint128_t.hpp