GncInt128 Class Reference

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

Public Member Functions
	GncInt128 ()
	Default constructor. More...
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. More...
int	cmp (const GncInt128 &b) const noexcept
	Compare function. More...
GncInt128	gcd (GncInt128 b) const noexcept
	Computes the Greatest Common Divisor between the object and parameter. More...
GncInt128	lcm (const GncInt128 &b) const noexcept
	Computes the Least Common Multiple between the object and parameter. More...
GncInt128	pow (unsigned int n) const noexcept
	Computes the object raised to the parameter's power. More...
void	div (const GncInt128 &d, GncInt128 &q, GncInt128 &r) const noexcept
	Computes a quotient and a remainder, passed as reference parameters. More...
	operator int64_t () const
	Explicit conversion to int64_t. More...
	operator uint64_t () const
	Explicit conversion to uint64_t. More...
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. More...
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 Function Documentation

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 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;
}

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;
}

---

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

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