GncInt128 Class Reference

Public Types
enum	{ pos = 0 , neg = 1 , overflow = 2 , NaN = 4 }

Public Member Functions
	GncInt128 ()
	Default constructor.
template<typename T , std::enable_if_t< std::is_integral< T >::value, bool > = true>
	GncInt128 (T lower)
	GncInt128 (uint64_t lower)
template<typename T , typename U , std::enable_if_t<(std::is_integral< T >::value &&std::is_integral< U >::value), bool > = true>
	GncInt128 (T upper, U lower, unsigned char flags='\0')
	Double-integer constructor template.
	GncInt128 (int64_t upper, int64_t lower, unsigned char flags='\0')
template<typename T , std::enable_if_t< std::is_integral< T >::value, bool > = true>
	GncInt128 (T upper, uint64_t lower)
	GncInt128 (int64_t upper, uint64_t lower, unsigned char flags='\0')
	GncInt128 (uint64_t upper, uint64_t lower, unsigned char flags='\0')
GncInt128 &	zero () noexcept
	Clear the object.
int	cmp (const GncInt128 &b) const noexcept
	Compare function.
GncInt128	gcd (GncInt128 b) const noexcept
	Computes the Greatest Common Divisor between the object and parameter.
GncInt128	lcm (const GncInt128 &b) const noexcept
	Computes the Least Common Multiple between the object and parameter.
GncInt128	pow (unsigned int n) const noexcept
	Computes the object raised to the parameter's power.
void	div (const GncInt128 &d, GncInt128 &q, GncInt128 &r) const noexcept
	Computes a quotient and a remainder, passed as reference parameters.
	operator int64_t () const
	Explicit conversion to int64_t.
	operator uint64_t () const
	Explicit conversion to uint64_t.
bool	isNeg () const noexcept
bool	isBig () const noexcept
bool	isOverflow () const noexcept
bool	isNan () const noexcept
bool	isZero () const noexcept
bool	valid () const noexcept
unsigned int	bits () const noexcept
char *	asCharBufR (char *buf, uint32_t size) const noexcept
	Fills a supplied buffer with a representation of the number in base 10.
GncInt128	abs () const noexcept
GncInt128	operator- () const noexcept
	operator bool () const noexcept
GncInt128 &	operator++ () noexcept
GncInt128 &	operator++ (int) noexcept
GncInt128 &	operator-- () noexcept
GncInt128 &	operator-- (int) noexcept
GncInt128 &	operator<<= (unsigned int i) noexcept
GncInt128 &	operator>>= (unsigned int i) noexcept
GncInt128 &	operator+= (const GncInt128 &b) noexcept
GncInt128 &	operator-= (const GncInt128 &b) noexcept
GncInt128 &	operator*= (const GncInt128 &b) noexcept
GncInt128 &	operator/= (const GncInt128 &b) noexcept
GncInt128 &	operator%= (const GncInt128 &b) noexcept
GncInt128 &	operator&= (const GncInt128 &b) noexcept
GncInt128 &	operator|= (const GncInt128 &b) noexcept
GncInt128 &	operator^= (const GncInt128 &b) noexcept

Static Public Attributes
static const unsigned int	flagbits = 3
static const unsigned int	numlegs = 2
static const unsigned int	legbits = 64
static const unsigned int	maxbits = legbits * numlegs - flagbits

Detailed Description

Definition at line 61 of file gnc-int128.hpp.

Member Enumeration Documentation

anonymous enum

anonymous enum

Definition at line 72 of file gnc-int128.hpp.

{
    pos = 0,
    neg = 1,
    overflow = 2,
    NaN = 4
};

Member Function Documentation

abs()

GncInt128 GncInt128::abs ( ) const

noexcept

Definition at line 284 of file gnc-int128.cpp.

{
    if (isNeg())
        return operator-();
 
    return *this;
}

asCharBufR()

char * GncInt128::asCharBufR ( char *  buf, uint32_t  size  ) const

noexcept

Fills a supplied buffer with a representation of the number in base 10.

If the GncInt128 is overflowed or NaN it will contain the words "Overflow" or "NaN" respectively.

Parameters

buf	char[41], 39 digits plus sign and trailing 0.

Returns

pointer to the buffer for convenience

Definition at line 918 of file gnc-int128.cpp.

{
    if (isOverflow())
    {
        snprintf (buf, size, "%s", "Overflow");
        return buf;
    }
    if (isNan())
    {
        snprintf (buf, size, "%s", "NaN");
        return buf;
    }
    if (isZero())
    {
        snprintf (buf, size, "%d", 0);
        return buf;
    }
    uint64_t d[dec_array_size] {};
    decimal_from_binary(d, get_num(m_hi), m_lo);
    char* next = buf;
    char neg {'-'};
 
    if (isNeg()) *(next++) = neg;
    bool trailing {false};
    for (unsigned int i {dec_array_size}; i; --i)
        if (d[i - 1] || trailing)
        {
            uint32_t new_size = size - (next - buf);
            if (trailing)
                next += snprintf (next, new_size, "%8.8" PRIu64, d[i - 1]);
            else
                next += snprintf (next, new_size, "%" PRIu64, d[i - 1]);
 
            trailing = true;
        }
 
    return buf;
}

bits()

unsigned int GncInt128::bits ( ) const

noexcept

Returns

the number of bits used to represent the value

Definition at line 293 of file gnc-int128.cpp.

{
    auto hi = get_num(m_hi);
    unsigned int bits {static_cast<unsigned int>(hi == 0 ? 0 : 64)};
    uint64_t temp {(hi == 0 ? m_lo : hi)};
    for (;temp > 0; temp >>= 1)
        ++bits;
    return bits;
}

cmp()

int GncInt128::cmp ( const GncInt128 &  b ) const

noexcept

Compare function.

Returns

-1 if the object is less than the parameter, 0 if they're equal, and 1 if the object is greater.

Definition at line 151 of file gnc-int128.cpp.

{
    auto flags = get_flags(m_hi);
    if (flags & (overflow | NaN))
        return -1;
    if (b.isOverflow () || b.isNan ())
        return 1;
    auto hi = get_num(m_hi);
    auto bhi = get_num(b.m_hi);
    if (isZero() && b.isZero()) return 0;
    if (flags & neg)
    {
        if (!b.isNeg()) return -1;
        if (hi > bhi) return -1;
        if (hi < bhi) return 1;
        if (m_lo > b.m_lo) return -1;
        if (m_lo < b.m_lo) return 1;
        return 0;
    }
    if (b.isNeg()) return 1;
    if (hi < bhi) return -1;
    if (hi > bhi) return 1;
    if (m_lo < b.m_lo) return -1;
    if (m_lo > b.m_lo) return 1;
    return 0;
}

div()

void GncInt128::div ( const GncInt128 &  d, GncInt128 &  q, GncInt128 &  r  ) const

noexcept

Computes a quotient and a remainder, passed as reference parameters.

'this' is the dividend. The quotient and remainder args must be initialized to zero.

Parameters

d	The divisor
q	The quotient; will be NaN if divisor = 0
r	The remainder; will be 0 if divisor = 0

Definition at line 723 of file gnc-int128.cpp.

{
    // clear remainder and quotient
    r = GncInt128(0);
    q = GncInt128(0);
 
    auto qflags = get_flags(q.m_hi);
    auto rflags = get_flags(r.m_hi);
    if (isOverflow() || b.isOverflow())
    {
        qflags |= overflow;
        rflags |= overflow;
        q.m_hi = set_flags(q.m_hi, qflags);
        r.m_hi = set_flags(r.m_hi, rflags);
        return;
    }
 
    if (isNan() || b.isNan())
    {
        qflags |= NaN;
        rflags |= NaN;
        q.m_hi = set_flags(q.m_hi, qflags);
        r.m_hi = set_flags(r.m_hi, rflags);
        return;
    }
    assert (&q != this);
    assert (&r != this);
    assert (&q != &b);
    assert (&r != &b);
 
    q.zero(), r.zero();
    qflags = rflags = 0;
    if (b.isZero())
    {
        qflags |= NaN;
        rflags |= NaN;
        q.m_hi = set_flags(q.m_hi, qflags);
        r.m_hi = set_flags(r.m_hi, rflags);
        return;
    }
 
    if (isNeg())
    {
        qflags |= neg;
        rflags |= neg;          // the remainder inherits the dividend's sign
    }
 
    if (b.isNeg())
        qflags ^= neg;
 
    q.m_hi = set_flags(q.m_hi, qflags);
    r.m_hi = set_flags(r.m_hi, rflags);
 
    if (abs() < b.abs())
    {
        r = *this;
        return;
    }
    auto hi = get_num(m_hi);
    auto bhi = get_num(b.m_hi);
 
    if (hi == 0 && bhi == 0) //let the hardware do it
    {
        assert (b.m_lo != 0); // b.m_hi is 0 but b isn't or we didn't get here.
        q.m_lo = m_lo / b.m_lo;
        r.m_lo = m_lo % b.m_lo;
        return;
    }
 
    uint64_t u[sublegs + 2] {(m_lo & sublegmask), (m_lo >> sublegbits),
            (hi & sublegmask), (hi >> sublegbits), 0, 0};
    uint64_t v[sublegs] {(b.m_lo & sublegmask), (b.m_lo >> sublegbits),
            (bhi & sublegmask), (bhi >> sublegbits)};
    auto m = u[3] ? 4 : u[2] ? 3 : u[1] ? 2 : u[0] ? 1 : 0;
    auto n = v[3] ? 4 : v[2] ? 3 : v[1] ? 2 : v[0] ? 1 : 0;
    if (m == 0 || n == 0) //Shouldn't happen
        return;
    if (n == 1)
        return div_single_leg (u, m, v[0], q, r);
 
    return div_multi_leg (u, m, v, n, q, r);
}

gcd()

GncInt128 GncInt128::gcd ( GncInt128  b ) const

noexcept

Computes the Greatest Common Divisor between the object and parameter.

Returns

A GncInt128 having the GCD.

Definition at line 182 of file gnc-int128.cpp.

{
    if (b.isZero())
        return *this;
    if (isZero())
        return b;
 
    if (b.isOverflow() || b.isNan())
        return b;
    if (isOverflow() || isNan())
        return *this;
 
    GncInt128 a (isNeg() ? -(*this) : *this);
    if (b.isNeg()) b = -b;
 
    unsigned int k {};
    const uint64_t one {1};
    while (!((a & one) || (b & one))) //B1
    {
        a >>= 1;
        b >>= 1;
        ++k;
    }
    GncInt128 t {a & one ? -b : a}; //B2
    while (a != b)
    {
        while (t && ((t & one) ^ one)) t >>= 1;  //B3 & B4
        if (t.isNeg())  //B5
            b = -t;
        else
            a = t;
        t = a - b;  //B6
    }
    return a << k;
}

isBig()

bool GncInt128::isBig ( ) const

noexcept

Returns

true if the object value is > INT64_MAX or < INT64_MIN

Definition at line 253 of file gnc-int128.cpp.

{
    return (get_num(m_hi) || m_lo > INT64_MAX);
}

isNan()

bool GncInt128::isNan ( ) const

noexcept

Returns

true if an illegal calculation has occurred.

Definition at line 265 of file gnc-int128.cpp.

{
    return (get_flags(m_hi) & NaN);
}

isNeg()

bool GncInt128::isNeg ( ) const

noexcept

Returns

true if the object value is < 0

Definition at line 247 of file gnc-int128.cpp.

{
    return (get_flags(m_hi) & neg);
}

isOverflow()

bool GncInt128::isOverflow ( ) const

noexcept

Returns

true if a calculation has produced a result of larger magnitude than can be contained in the 128 bits available.

Definition at line 259 of file gnc-int128.cpp.

{
    return (get_flags(m_hi) & overflow);
}

isZero()

bool GncInt128::isZero ( ) const

noexcept

Returns

true if the object represents 0.

Definition at line 277 of file gnc-int128.cpp.

{
    return ((get_flags(m_hi) & (overflow | NaN)) == 0 &&
            get_num(m_hi) == 0 && m_lo == 0);
}

lcm()

GncInt128 GncInt128::lcm ( const GncInt128 &  b ) const

noexcept

Computes the Least Common Multiple between the object and parameter.

Returns

A GncInt128 having the LCM.

Definition at line 221 of file gnc-int128.cpp.

{
    auto common = gcd(b);
    return *this / common * b.abs(); //Preserve our sign, discard the other's.
}

operator bool()

GncInt128::operator bool ( ) const

explicitnoexcept

Definition at line 317 of file gnc-int128.cpp.

{
    return ! isZero ();
}

operator int64_t()

GncInt128::operator int64_t ( ) const

explicit

Explicit conversion to int64_t.

Returns

A int64_t

Exceptions

std::overflow_error	if the object's value is > INT64_MAX or NaN.
std::underflow_error	if the object's value is < INT64_MIN

Definition at line 128 of file gnc-int128.cpp.

{
    auto flags = get_flags(m_hi);
    if ((flags & neg) && isBig())
        throw std::underflow_error ("Negative value too large to represent as int64_t");
    if ((flags & (overflow | NaN)) || isBig())
        throw std::overflow_error ("Value too large to represent as int64_t");
    int64_t retval = static_cast<int64_t>(m_lo);
    return flags & neg ? -retval : retval;
}

operator uint64_t()

GncInt128::operator uint64_t ( ) const

explicit

Explicit conversion to uint64_t.

Returns

A uint64_t

Exceptions

std::overflow_error	if the object's value is > UINT64_MAX or NaN.
std::underflow_error	if the object's value is < 0.

Definition at line 139 of file gnc-int128.cpp.

{
    auto flags = get_flags(m_hi);
    if ((flags & neg) && !isZero()) // exclude negative zero
        throw std::underflow_error ("Can't represent negative value as uint64_t");
    if ((flags & (overflow | NaN)) || (m_hi || m_lo > UINT64_MAX))
        throw std::overflow_error ("Value to large to represent as uint64_t");
    return m_lo;
}

operator%=()

GncInt128 & GncInt128::operator%= ( const GncInt128 &  b )

noexcept

Definition at line 816 of file gnc-int128.cpp.

{
    GncInt128 q {}, r {};
    div(b, q, r);
    std::swap (*this, r);
    if (q.isNan())
        m_hi = set_flags(m_hi, (get_flags(m_hi) | NaN));
    return *this;
}

operator&=()

GncInt128 & GncInt128::operator&= ( const GncInt128 &  b )

noexcept

Definition at line 827 of file gnc-int128.cpp.

{
    auto flags = get_flags(m_hi);
    if (b.isOverflow())
        flags |= overflow;
    if (b.isNan())
        flags |= NaN;
    m_hi = set_flags(m_hi, flags);
    if (isOverflow() || isNan())
        return *this;
    auto hi = get_num(m_hi);
    hi &= get_num(b.m_hi);
    m_lo &= b.m_lo;
    m_hi = set_flags(hi, flags);
    return *this;
}

operator*=()

GncInt128 & GncInt128::operator*= ( const GncInt128 &  b )

noexcept

Definition at line 475 of file gnc-int128.cpp.

{
    /* Test for 0 first */
    auto flags = get_flags(m_hi);
    /* Handle the sign; ^ flips if b is negative */
    flags ^= (get_flags(b.m_hi) & neg);
    if (isZero() || b.isZero())
    {
        m_lo = 0;
        m_hi = set_flags(0, flags);
        return *this;
    }
    if (b.isOverflow())
        flags |= overflow;
    if (b.isNan())
        flags |= NaN;
    m_hi = set_flags(m_hi, flags);
    if (isOverflow() || isNan())
        return *this;
 
    /* Test for overflow before spending time on the calculation */
    auto hi = get_num(m_hi);
    auto bhi = get_num(b.m_hi);
    if (hi && bhi)
    {
        flags |= overflow;
        m_hi = set_flags(hi, flags);
        return *this;
    }
 
    unsigned int abits {bits()}, bbits {b.bits()};
    /* If the product of the high bytes < 7fff then the result will have abits +
     * bbits -1 bits and won't actually overflow. It's not worth the effort to
     * work that out for this corner-case, so we'll take the risk and calculate
     * the product and catch the overflow later.
     */
    if (abits + bbits - 1 > maxbits)
    {
        flags |= overflow;
        m_hi = set_flags(m_hi, flags);
        return *this;
    }
 
    /* The trivial case */
    if (abits + bbits <= legbits)
    {
        m_lo *= b.m_lo;
        m_hi = set_flags(m_hi, flags);
        return *this;
    }
 
/* This is Knuth's "classical" multi-precision multiplication algorithm
 * truncated to a GncInt128 result with the loop unrolled for clarity and with
 * overflow and zero checks beforehand to save time. See Donald Knuth, "The Art
 * of Computer Programming Volume 2: Seminumerical Algorithms", Addison-Wesley,
 * 1998, p 268.
 *
 * There are potentially faster algorithms (O(n^1.6) instead of O(n^2) for the
 * full precision), but this is already close to that fast because of truncation
 * and it's not clear that the truncation is applicable to the faster
 * algorithms.
 */
 
    uint64_t av[sublegs] {(m_lo & sublegmask), (m_lo >> sublegbits),
            (hi & sublegmask), (hi >> sublegbits)};
    uint64_t bv[sublegs] {(b.m_lo & sublegmask), (b.m_lo >> sublegbits),
            (bhi & sublegmask), (bhi >> sublegbits)};
    uint64_t rv[sublegs] {};
    uint64_t carry {}, scratch {};
 
    rv[0] = av[0] * bv[0];
 
    rv[1] = av[1] * bv [0];
    scratch = rv[1] + av[0] * bv[1];
    carry = rv[1] > scratch ? 1 : 0;
    rv[1] = scratch;
 
    rv[2] = av[2] * bv[0] + carry; //0xffff^2 + 1 < 0xffffffff, can't overflow
    scratch = rv[2] + av[1] * bv[1];
    carry = rv[2] > scratch ? 1 : 0;
    rv[2] = scratch + av[0] * bv[2];
    carry += scratch > rv[2] ? 1 : 0;
 
    rv[3] = av[3] * bv[0] + carry;
    scratch = rv[3] + av[2] * bv[1];
    carry = rv[3] > scratch ? 1 : 0;
    rv[3] = scratch + av[1] * bv[2];
    carry += scratch > rv[3] ? 1 : 0;
    scratch = rv[3] + av[0] * bv[3];
    carry += rv[3] > scratch ? 1 : 0;
    rv[3] = scratch;
 
    if (carry) //Shouldn't happen because of the checks above
    {
        flags |= overflow;
        m_hi = set_flags(m_hi, flags);
        return *this;
    }
 
    m_lo = rv[0] + (rv[1] << sublegbits);
    carry = rv[1] >> sublegbits;
    carry += (rv[1] << sublegbits) > m_lo || rv[0] > m_lo ? 1 : 0;
    hi = rv[2] + (rv[3] << sublegbits) + carry;
    if ((rv[3] << sublegbits) > hi || rv[2] > hi || (rv[3] >> sublegbits) ||
        hi & flagmask)
    {
        flags |= overflow;
        m_hi = set_flags(hi, flags);
        return *this;
    }
    m_hi = set_flags(hi, flags);
    return *this;
}

operator++() [1/2]

GncInt128 & GncInt128::operator++ ( )

noexcept

Definition at line 323 of file gnc-int128.cpp.

{
    return operator+=(UINT64_C(1));
}

operator++() [2/2]

GncInt128 & GncInt128::operator++ ( int  )

noexcept

Definition at line 329 of file gnc-int128.cpp.

{
    return operator+=(UINT64_C(1));
}

operator+=()

GncInt128 & GncInt128::operator+= ( const GncInt128 &  b )

noexcept

Definition at line 347 of file gnc-int128.cpp.

{
    auto flags = get_flags(m_hi);
    if (b.isOverflow())
        flags |= overflow;
    if (b.isNan())
        flags |= NaN;
    m_hi = set_flags(m_hi, flags);
    if (isOverflow() || isNan())
        return *this;
    if ((isNeg () && !b.isNeg ()) || (!isNeg () && b.isNeg ()))
        return this->operator-= (-b);
    uint64_t result = m_lo + b.m_lo;
    uint64_t carry = static_cast<int64_t>(result < m_lo);  //Wrapping
    m_lo = result;
    auto hi = get_num(m_hi);
    auto bhi = get_num(b.m_hi);
    result = hi + bhi + carry;
    if (result < hi || result & flagmask)
        flags |= overflow;
    m_hi = set_flags(result, flags);
    return *this;
}

operator-()

GncInt128 GncInt128::operator- ( ) const

noexcept

Definition at line 305 of file gnc-int128.cpp.

{
    auto retval = *this;
    auto flags = get_flags(retval.m_hi);
    if (isNeg())
        flags ^= neg;
    else
        flags |= neg;
    retval.m_hi = set_flags(retval.m_hi, flags);
    return retval;
}

operator--() [1/2]

GncInt128 & GncInt128::operator-- ( )

noexcept

Definition at line 335 of file gnc-int128.cpp.

{
    return operator-=(UINT64_C(1));
}

operator--() [2/2]

GncInt128 & GncInt128::operator-- ( int  )

noexcept

Definition at line 341 of file gnc-int128.cpp.

{
    return operator-=(UINT64_C(1));
}

operator-=()

GncInt128 & GncInt128::operator-= ( const GncInt128 &  b )

noexcept

Definition at line 427 of file gnc-int128.cpp.

{
    auto flags = get_flags(m_hi);
    if (b.isOverflow())
        flags |= overflow;
    if (b.isNan())
        flags |= NaN;
    m_hi = set_flags(m_hi, flags);
 
    if (isOverflow() || isNan())
        return *this;
 
    if ((!isNeg() && b.isNeg()) || (isNeg() && !b.isNeg()))
        return this->operator+= (-b);
    bool operand_bigger {abs().cmp (b.abs()) < 0};
    auto hi = get_num(m_hi);
    auto far_hi = get_num(b.m_hi);
    if (operand_bigger)
    {
        flags ^= neg; // ^= flips the bit
        if (m_lo > b.m_lo)
        {
            /* The + 1 on the end is because we really want to use 2^64, or
             * UINT64_MAX + 1, but that can't be represented in a uint64_t.
             */
            m_lo = UINT64_MAX - m_lo + b.m_lo + 1;
            --far_hi; //borrow
        }
        else
            m_lo = b.m_lo - m_lo;
        hi = far_hi - hi;
        m_hi = set_flags(hi, flags);
        return *this;
    }
    if (m_lo < b.m_lo)
    {
        m_lo = UINT64_MAX - b.m_lo + m_lo + 1; //See UINT64_MAX comment above
        --hi; //borrow
    }
    else
        m_lo -= b.m_lo;
 
    hi -= far_hi;
    m_hi = set_flags(hi, flags);
    return *this;
}

operator/=()

GncInt128 & GncInt128::operator/= ( const GncInt128 &  b )

noexcept

Definition at line 807 of file gnc-int128.cpp.

{
    GncInt128 q {}, r {};
    div(b, q, r);
    std::swap (*this, q);
    return *this;
}

operator<<=()

GncInt128 & GncInt128::operator<<= ( unsigned int  i )

noexcept

Definition at line 371 of file gnc-int128.cpp.

{
    auto flags = get_flags(m_hi);
    if (i == 0)
        return *this;
    if (i > maxbits)
    {
        flags &= 0xfe;
        m_hi = set_flags(0, flags);
        m_lo = 0;
        return *this;
    }
    auto hi = get_num(m_hi);
    if (i < legbits)
    {
        uint64_t carry {(m_lo & (((UINT64_C(1) << i) - 1) << (legbits - i))) >> (legbits - i)};
        m_lo <<= i;
        hi <<= i;
        hi += carry;
        m_hi = set_flags(hi, flags);
        return *this;
    }
    hi = m_lo << (i - legbits);
    m_hi = set_flags(hi, flags);
    m_lo = 0;
    return *this;
}

operator>>=()

GncInt128 & GncInt128::operator>>= ( unsigned int  i )

noexcept

Definition at line 401 of file gnc-int128.cpp.

{
    auto flags = get_flags(m_hi);
    if (i > maxbits)
    {
        flags &= 0xfe;
        m_hi = set_flags(0, flags);
        m_lo = 0;
        return *this;
    }
    auto hi = get_num(m_hi);
    if (i < legbits)
    {
        uint64_t carry {(hi & ((UINT64_C(1) << i) - 1))};
        m_lo >>= i;
        hi >>= i;
        m_lo += (carry << (legbits - i));
        m_hi = set_flags(hi, flags);
        return *this;
    }
    m_lo = hi >> (i - legbits);
    m_hi = set_flags(0, flags);
    return *this;
}

operator^=()

GncInt128 & GncInt128::operator^= ( const GncInt128 &  b )

noexcept

Definition at line 856 of file gnc-int128.cpp.

{
    auto flags = get_flags(m_hi);
    if (b.isOverflow())
        flags |= overflow;
    if (b.isNan())
        flags |= NaN;
    m_hi = set_flags(m_hi, flags);
    if (isOverflow() || isNan())
        return *this;
    auto hi = get_num(m_hi);
    hi ^= get_num(b.m_hi);
    m_hi = set_flags(hi, flags);
    m_lo ^= b.m_lo;
    return *this;
}

operator|=()

GncInt128 & GncInt128::operator|= ( const GncInt128 &  b )

noexcept

Definition at line 845 of file gnc-int128.cpp.

{
    auto flags = get_flags(m_hi);
    auto hi = get_num(m_hi);
    hi  ^= get_num(b.m_hi);
    m_hi = set_flags(hi, flags);
    m_lo ^= b.m_lo;
    return *this;
}

pow()

GncInt128 GncInt128::pow ( unsigned int  n ) const

noexcept

Computes the object raised to the parameter's power.

Parameters

b	The power to raise this to. No point in taking a GncInt128, any value greater than 128 would overflow on any value other than 1.

Returns

A GncInt128

Definition at line 229 of file gnc-int128.cpp.

{
    if (isZero() || (m_lo == 1 && m_hi == 0) || isNan() || isOverflow())
        return *this;
    if (b == 0)
        return GncInt128 (1);
    GncInt128 retval (1), squares = *this;
    while (b && !retval.isOverflow())
    {
        if (b & 1)
            retval *= squares;
        squares *= squares;
        b >>= 1;
    }
    return retval;
}

valid()

bool GncInt128::valid ( ) const

noexcept

Returns

true if neither the overflow nor nan flags are set.

Definition at line 271 of file gnc-int128.cpp.

{
    return !(get_flags(m_hi) & (overflow | NaN));
}

zero()

GncInt128 & GncInt128::zero ( )

noexcept

Clear the object.

Sets all member variables to zero.

Returns

A reference to the object for chaining.

Definition at line 122 of file gnc-int128.cpp.

{
    m_lo = m_hi = UINT64_C(0);
    return *this;
}

Field Documentation

flagbits

const unsigned int GncInt128::flagbits = 3

static

Definition at line 67 of file gnc-int128.hpp.

legbits

const unsigned int GncInt128::legbits = 64

static

Definition at line 69 of file gnc-int128.hpp.

maxbits

const unsigned int GncInt128::maxbits = legbits * numlegs - flagbits

static

Definition at line 70 of file gnc-int128.hpp.

numlegs

const unsigned int GncInt128::numlegs = 2

static

Definition at line 68 of file gnc-int128.hpp.

---

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

• gnc-int128.hpp
• gnc-int128.cpp