diff --git a/po/POTFILES.in b/po/POTFILES.in index 4acbea6855..f4cb487f7a 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -429,6 +429,7 @@ src/import-export/qif-imp/gncmod-qif-import.c src/import-export/qif-imp/gnc-plugin-qif-import.c [type: gettext/gsettings]src/import-export/qif-imp/gschemas/org.gnucash.dialogs.import.qif.gschema.xml.in.in src/libqof/qof/gnc-date.cpp +src/libqof/qof/gnc-int128.cpp src/libqof/qof/gnc-numeric.cpp src/libqof/qof/gnc-rational.cpp src/libqof/qof/guid.cpp @@ -442,7 +443,6 @@ src/libqof/qof/qofevent.cpp src/libqof/qof/qofid.cpp src/libqof/qof/qofinstance.cpp src/libqof/qof/qoflog.cpp -src/libqof/qof/qofint128.cpp src/libqof/qof/qofobject.cpp src/libqof/qof/qofquerycore.cpp src/libqof/qof/qofquery.cpp diff --git a/src/libqof/qof/Makefile.am b/src/libqof/qof/Makefile.am index 0648195c24..a873164909 100644 --- a/src/libqof/qof/Makefile.am +++ b/src/libqof/qof/Makefile.am @@ -24,6 +24,7 @@ AM_CPPFLAGS = \ libgnc_qof_la_SOURCES = \ gnc-date.cpp \ + gnc-int128.cpp \ gnc-numeric.cpp \ gnc-rational.cpp \ guid.cpp \ @@ -37,7 +38,6 @@ libgnc_qof_la_SOURCES = \ qofevent.cpp \ qofid.cpp \ qofinstance.cpp \ - qofint128.cpp \ qoflog.cpp \ qofobject.cpp \ qofquery.cpp \ @@ -82,7 +82,7 @@ noinst_HEADERS = \ qofbook-p.h \ qofclass-p.h \ qofevent-p.h \ - qofint128.hpp \ + gnc-int128.hpp \ qofobject-p.h \ qofquery-p.h \ qofquerycore-p.h \ diff --git a/src/libqof/qof/qofint128.cpp b/src/libqof/qof/gnc-int128.cpp similarity index 83% rename from src/libqof/qof/qofint128.cpp rename to src/libqof/qof/gnc-int128.cpp index 97e7fd8631..d87b5b30c8 100644 --- a/src/libqof/qof/qofint128.cpp +++ b/src/libqof/qof/gnc-int128.cpp @@ -27,7 +27,7 @@ extern "C" #include } -#include "qofint128.hpp" +#include "gnc-int128.hpp" #include #include @@ -39,22 +39,22 @@ extern "C" */ namespace { - static const uint sublegs = QofInt128::numlegs * 2; - static const uint sublegbits = QofInt128::legbits / 2; + static const uint sublegs = GncInt128::numlegs * 2; + static const uint sublegbits = GncInt128::legbits / 2; static const uint64_t sublegmask = (UINT64_C(1) << sublegbits) - 1; } -QofInt128::QofInt128 () : m_flags {}, m_hi {0}, m_lo {0}{} +GncInt128::GncInt128 () : m_flags {}, m_hi {0}, m_lo {0}{} -QofInt128::QofInt128 (int64_t lower) : +GncInt128::GncInt128 (int64_t lower) : m_flags {static_cast(lower < 0 ? neg : pos)}, m_hi {0}, m_lo {static_cast(lower < 0 ? -lower : lower)} {} -QofInt128::QofInt128 (uint64_t lower) : +GncInt128::GncInt128 (uint64_t lower) : m_flags {}, m_hi {0}, m_lo {lower} {} -QofInt128::QofInt128 (int64_t upper, int64_t lower, unsigned char flags) : +GncInt128::GncInt128 (int64_t upper, int64_t lower, unsigned char flags) : m_flags {static_cast(flags ^ (upper < 0 ? neg : upper == 0 && lower < 0 ? neg : pos))}, m_hi {static_cast(upper < 0 ? -upper : upper)}, @@ -68,19 +68,19 @@ QofInt128::QofInt128 (int64_t upper, int64_t lower, unsigned char flags) : m_hi >>= 1; } -QofInt128::QofInt128 (uint64_t upper, uint64_t lower, unsigned char flags) : +GncInt128::GncInt128 (uint64_t upper, uint64_t lower, unsigned char flags) : m_flags {flags}, m_hi {upper}, m_lo {lower} {} -QofInt128& -QofInt128::zero () noexcept +GncInt128& +GncInt128::zero () noexcept { m_flags = 0; m_lo = m_hi = UINT64_C(0); return *this; } -QofInt128::operator int64_t() const +GncInt128::operator int64_t() const { if ((m_flags & neg) && isBig()) throw std::underflow_error ("Negative value to large to represent as int64_t"); @@ -90,7 +90,7 @@ QofInt128::operator int64_t() const return m_flags & neg ? -retval : retval; } -QofInt128::operator uint64_t() const +GncInt128::operator uint64_t() const { if (m_flags & neg) throw std::underflow_error ("Can't represent negative value as uint64_t"); @@ -101,7 +101,7 @@ QofInt128::operator uint64_t() const int -QofInt128::cmp (const QofInt128& b) const noexcept +GncInt128::cmp (const GncInt128& b) const noexcept { if (m_flags & (overflow | NaN)) return -1; @@ -127,8 +127,8 @@ QofInt128::cmp (const QofInt128& b) const noexcept /* Knuth 4.5.3 Algo B, recommended by GMP as much faster than Algo A (Euclidean * method). */ -QofInt128 -QofInt128::gcd(QofInt128 b) const noexcept +GncInt128 +GncInt128::gcd(GncInt128 b) const noexcept { if (b.isZero()) return *this; @@ -140,7 +140,7 @@ QofInt128::gcd(QofInt128 b) const noexcept if (isOverflow() || isNan()) return *this; - QofInt128 a (isNeg() ? -(*this) : *this); + GncInt128 a (isNeg() ? -(*this) : *this); if (b.isNeg()) b = -b; uint k {}; @@ -151,7 +151,7 @@ QofInt128::gcd(QofInt128 b) const noexcept b >>= 1; ++k; } - QofInt128 t {a & one ? -b : a}; //B2 + GncInt128 t {a & one ? -b : a}; //B2 while (a != b) { while (t && (t & one ^ one)) t >>= 1; //B3 & B4 @@ -166,22 +166,22 @@ QofInt128::gcd(QofInt128 b) const noexcept /* Since u * v = gcd(u, v) * lcm(u, v), we find lcm by u / gcd * v. */ -QofInt128 -QofInt128::lcm(const QofInt128& b) const noexcept +GncInt128 +GncInt128::lcm(const GncInt128& b) const noexcept { auto common = gcd(b); return *this / common * b.abs(); //Preserve our sign, discard the other's. } /* Knuth section 4.6.3 */ -QofInt128 -QofInt128::pow(uint b) const noexcept +GncInt128 +GncInt128::pow(uint b) const noexcept { if (isZero() || (m_lo == 1 && m_hi == 0) || isNan() || isOverflow()) return *this; if (b == 0) - return QofInt128 (1); - QofInt128 retval (1), squares = *this; + return GncInt128 (1); + GncInt128 retval (1), squares = *this; while (b && !retval.isOverflow()) { if (b & 1) @@ -193,37 +193,37 @@ QofInt128::pow(uint b) const noexcept } bool -QofInt128::isNeg () const noexcept +GncInt128::isNeg () const noexcept { return (m_flags & neg); } bool -QofInt128::isBig () const noexcept +GncInt128::isBig () const noexcept { return (m_hi || m_lo > INT64_MAX); } bool -QofInt128::isOverflow () const noexcept +GncInt128::isOverflow () const noexcept { return (m_flags & overflow); } bool -QofInt128::isNan () const noexcept +GncInt128::isNan () const noexcept { return (m_flags & NaN); } bool -QofInt128::isZero() const noexcept +GncInt128::isZero() const noexcept { return ((m_flags & (overflow | NaN)) == 0 && m_hi == 0 && m_lo == 0); } -QofInt128 -QofInt128::abs() const noexcept +GncInt128 +GncInt128::abs() const noexcept { if (isNeg()) return operator-(); @@ -232,7 +232,7 @@ QofInt128::abs() const noexcept } uint -QofInt128::bits() const noexcept +GncInt128::bits() const noexcept { uint bits {static_cast(m_hi == 0 ? 0 : 64)}; uint64_t temp {(m_hi == 0 ? m_lo : m_hi)}; @@ -242,8 +242,8 @@ QofInt128::bits() const noexcept } -QofInt128 -QofInt128::operator-() const noexcept +GncInt128 +GncInt128::operator-() const noexcept { auto retval = *this; if (isNeg()) @@ -253,37 +253,37 @@ QofInt128::operator-() const noexcept return retval; } -QofInt128::operator bool() const noexcept +GncInt128::operator bool() const noexcept { return ! isZero (); } -QofInt128& -QofInt128::operator++ () noexcept +GncInt128& +GncInt128::operator++ () noexcept { return operator+=(UINT64_C(1)); } -QofInt128& -QofInt128::operator++ (int) noexcept +GncInt128& +GncInt128::operator++ (int) noexcept { return operator+=(UINT64_C(1)); } -QofInt128& -QofInt128::operator-- () noexcept +GncInt128& +GncInt128::operator-- () noexcept { return operator-=(UINT64_C(1)); } -QofInt128& -QofInt128::operator-- (int) noexcept +GncInt128& +GncInt128::operator-- (int) noexcept { return operator-=(UINT64_C(1)); } -QofInt128& -QofInt128::operator+= (const QofInt128& b) noexcept +GncInt128& +GncInt128::operator+= (const GncInt128& b) noexcept { if (b.isOverflow()) m_flags |= overflow; @@ -304,8 +304,8 @@ QofInt128::operator+= (const QofInt128& b) noexcept return *this; } -QofInt128& -QofInt128::operator<<= (uint i) noexcept +GncInt128& +GncInt128::operator<<= (uint i) noexcept { if (i > maxbits) { @@ -321,8 +321,8 @@ QofInt128::operator<<= (uint i) noexcept return *this; } -QofInt128& -QofInt128::operator>>= (uint i) noexcept +GncInt128& +GncInt128::operator>>= (uint i) noexcept { if (i > maxbits) { @@ -338,8 +338,8 @@ QofInt128::operator>>= (uint i) noexcept return *this; } -QofInt128& -QofInt128::operator-= (const QofInt128& b) noexcept +GncInt128& +GncInt128::operator-= (const GncInt128& b) noexcept { if (b.isOverflow()) m_flags |= overflow; @@ -383,8 +383,8 @@ QofInt128::operator-= (const QofInt128& b) noexcept return *this; } -QofInt128& -QofInt128::operator*= (const QofInt128& b) noexcept +GncInt128& +GncInt128::operator*= (const GncInt128& b) noexcept { /* Test for 0 first */ if (isZero() || b.isZero()) @@ -423,7 +423,7 @@ QofInt128::operator*= (const QofInt128& b) noexcept } /* This is Knuth's "classical" multi-precision multiplication algorithm - * truncated to a QofInt128 result with the loop unrolled for clarity and with + * 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. @@ -488,7 +488,7 @@ namespace { */ /* We're using arrays here instead of vectors to avoid an alloc. */ void -div_multi_leg (uint64_t* u, size_t m, uint64_t* v, size_t n, QofInt128& q, QofInt128& r) noexcept +div_multi_leg (uint64_t* u, size_t m, uint64_t* v, size_t n, GncInt128& q, GncInt128& r) noexcept { /* D1, Normalization */ uint64_t qv[sublegs] {}; @@ -578,14 +578,14 @@ div_multi_leg (uint64_t* u, size_t m, uint64_t* v, size_t n, QofInt128& q, QofIn u[j + n] += carry; } }//D7 - q = QofInt128 ((qv[3] << sublegbits) + qv[2], (qv[1] << sublegbits) + qv[0]); - r = QofInt128 ((u[3] << sublegbits) + u[2], (u[1] << sublegbits) + u[0]); + q = GncInt128 ((qv[3] << sublegbits) + qv[2], (qv[1] << sublegbits) + qv[0]); + r = GncInt128 ((u[3] << sublegbits) + u[2], (u[1] << sublegbits) + u[0]); r /= d; if (negative) q = -q; } void -div_single_leg (uint64_t* u, size_t m, uint64_t v, QofInt128& q, QofInt128& r) noexcept +div_single_leg (uint64_t* u, size_t m, uint64_t v, GncInt128& q, GncInt128& r) noexcept { uint64_t qv[sublegs] {}; uint64_t carry {}; @@ -602,15 +602,15 @@ div_single_leg (uint64_t* u, size_t m, uint64_t v, QofInt128& q, QofInt128& r) n u[i] %= v; } - q = QofInt128 ((qv[3] << sublegbits) + qv[2], (qv[1] << sublegbits) + qv[0]); - r = QofInt128 ((u[3] << sublegbits) + u[2], (u[1] << sublegbits) + u[0]); + q = GncInt128 ((qv[3] << sublegbits) + qv[2], (qv[1] << sublegbits) + qv[0]); + r = GncInt128 ((u[3] << sublegbits) + u[2], (u[1] << sublegbits) + u[0]); if (negative) q = -q; } }// namespace void -QofInt128::div (const QofInt128& b, QofInt128& q, QofInt128& r) noexcept +GncInt128::div (const GncInt128& b, GncInt128& q, GncInt128& r) noexcept { if (isOverflow() || b.isOverflow()) { @@ -670,19 +670,19 @@ QofInt128::div (const QofInt128& b, QofInt128& q, QofInt128& r) noexcept return div_multi_leg (u, m, v, n, q, r); } -QofInt128& -QofInt128::operator/= (const QofInt128& b) noexcept +GncInt128& +GncInt128::operator/= (const GncInt128& b) noexcept { - QofInt128 q {}, r {}; + GncInt128 q {}, r {}; div(b, q, r); std::swap (*this, q); return *this; } -QofInt128& -QofInt128::operator%= (const QofInt128& b) noexcept +GncInt128& +GncInt128::operator%= (const GncInt128& b) noexcept { - QofInt128 q {}, r {}; + GncInt128 q {}, r {}; div(b, q, r); std::swap (*this, r); if (q.isNan()) @@ -690,8 +690,8 @@ QofInt128::operator%= (const QofInt128& b) noexcept return *this; } -QofInt128& -QofInt128::operator&= (const QofInt128& b) noexcept +GncInt128& +GncInt128::operator&= (const GncInt128& b) noexcept { if (b.isOverflow()) m_flags |= overflow; @@ -706,16 +706,16 @@ QofInt128::operator&= (const QofInt128& b) noexcept return *this; } -QofInt128& -QofInt128::operator|= (const QofInt128& b) noexcept +GncInt128& +GncInt128::operator|= (const GncInt128& b) noexcept { m_hi ^= b.m_hi; m_lo ^= b.m_lo; return *this; } -QofInt128& -QofInt128::operator^= (const QofInt128& b) noexcept +GncInt128& +GncInt128::operator^= (const GncInt128& b) noexcept { if (b.isOverflow()) m_flags |= overflow; @@ -775,7 +775,7 @@ decimal_from_binary (uint64_t d[dec_array_size], uint64_t hi, uint64_t lo) static const uint8_t char_buf_size {41}; //39 digits plus sign and trailing null char* -QofInt128::asCharBufR(char* buf) const noexcept +GncInt128::asCharBufR(char* buf) const noexcept { if (isOverflow()) { @@ -809,7 +809,7 @@ QofInt128::asCharBufR(char* buf) const noexcept } std::ostream& -operator<< (std::ostream& stream, const QofInt128& a) noexcept +operator<< (std::ostream& stream, const GncInt128& a) noexcept { char buf[char_buf_size] {}; stream << a.asCharBufR (buf); @@ -817,105 +817,105 @@ operator<< (std::ostream& stream, const QofInt128& a) noexcept } bool -operator== (const QofInt128& a, const QofInt128& b) noexcept +operator== (const GncInt128& a, const GncInt128& b) noexcept { return a.cmp(b) == 0; } bool -operator!= (const QofInt128& a, const QofInt128& b) noexcept +operator!= (const GncInt128& a, const GncInt128& b) noexcept { return a.cmp(b) != 0; } bool -operator< (const QofInt128& a, const QofInt128& b) noexcept +operator< (const GncInt128& a, const GncInt128& b) noexcept { return a.cmp(b) < 0; } bool -operator> (const QofInt128& a, const QofInt128& b) noexcept +operator> (const GncInt128& a, const GncInt128& b) noexcept { return a.cmp(b) > 0; } bool -operator<= (const QofInt128& a, const QofInt128& b) noexcept +operator<= (const GncInt128& a, const GncInt128& b) noexcept { return a.cmp(b) <= 0; } bool -operator>= (const QofInt128& a, const QofInt128& b) noexcept +operator>= (const GncInt128& a, const GncInt128& b) noexcept { return a.cmp(b) >= 0; } -QofInt128 -operator+ (QofInt128 a, const QofInt128& b) noexcept +GncInt128 +operator+ (GncInt128 a, const GncInt128& b) noexcept { a += b; return a; } -QofInt128 -operator- (QofInt128 a, const QofInt128& b) noexcept +GncInt128 +operator- (GncInt128 a, const GncInt128& b) noexcept { a -= b; return a; } -QofInt128 -operator* (QofInt128 a, const QofInt128& b) noexcept +GncInt128 +operator* (GncInt128 a, const GncInt128& b) noexcept { a *= b; return a; } -QofInt128 -operator/ (QofInt128 a, const QofInt128& b) noexcept +GncInt128 +operator/ (GncInt128 a, const GncInt128& b) noexcept { a /= b; return a; } -QofInt128 -operator% (QofInt128 a, const QofInt128& b) noexcept +GncInt128 +operator% (GncInt128 a, const GncInt128& b) noexcept { a %= b; return a; } -QofInt128 -operator& (QofInt128 a, const QofInt128& b) noexcept +GncInt128 +operator& (GncInt128 a, const GncInt128& b) noexcept { a &= b; return a; } -QofInt128 -operator| (QofInt128 a, const QofInt128& b) noexcept +GncInt128 +operator| (GncInt128 a, const GncInt128& b) noexcept { a |= b; return a; } -QofInt128 -operator^ (QofInt128 a, const QofInt128& b) noexcept +GncInt128 +operator^ (GncInt128 a, const GncInt128& b) noexcept { a ^= b; return a; } -QofInt128 -operator<< (QofInt128 a, uint b) noexcept +GncInt128 +operator<< (GncInt128 a, uint b) noexcept { a <<= b; return a; } -QofInt128 -operator>> (QofInt128 a, uint b) noexcept +GncInt128 +operator>> (GncInt128 a, uint b) noexcept { a >>= b; return a; diff --git a/src/libqof/qof/qofint128.hpp b/src/libqof/qof/gnc-int128.hpp similarity index 58% rename from src/libqof/qof/qofint128.hpp rename to src/libqof/qof/gnc-int128.hpp index 705ab52427..efbfdba3bd 100644 --- a/src/libqof/qof/qofint128.hpp +++ b/src/libqof/qof/gnc-int128.hpp @@ -22,8 +22,8 @@ * * *******************************************************************/ -#ifndef QOFINT128_H -#define QOFINT128_H +#ifndef GNCINT128_H +#define GNCINT128_H #include @@ -39,12 +39,12 @@ * All the usual operators are provided. Only the explicit integer * conversions throw; all other errors are indicated by the overflow * and NaN ("Not a Number") flags. Note that performing any operation - * on an overflowed or NaN QofInt128 will yield an overflowed or NaN + * on an overflowed or NaN Gncint128 will yield an overflowed or NaN * result, so calling routines need not check until the end of a * chained calculation. - * QofInt128 uses implicit copy and move constructors and implicit destructor. + * GncInt128 uses implicit copy and move constructors and implicit destructor. */ -class QofInt128 +class GncInt128 { unsigned char m_flags; uint64_t m_hi; @@ -63,35 +63,35 @@ enum // Values for m_flags NaN = 4 }; - QofInt128 (); - QofInt128 (int16_t lower) : QofInt128{static_cast(lower)} {}; - QofInt128 (uint16_t lower) : QofInt128{static_cast(lower)} {}; - QofInt128 (int32_t lower) : QofInt128{static_cast(lower)} {}; - QofInt128 (uint32_t lower) : QofInt128{static_cast(lower)} {}; - QofInt128 (int64_t lower); - QofInt128 (uint64_t lower); + GncInt128 (); + GncInt128 (int16_t lower) : GncInt128{static_cast(lower)} {}; + GncInt128 (uint16_t lower) : GncInt128{static_cast(lower)} {}; + GncInt128 (int32_t lower) : GncInt128{static_cast(lower)} {}; + GncInt128 (uint32_t lower) : GncInt128{static_cast(lower)} {}; + GncInt128 (int64_t lower); + GncInt128 (uint64_t lower); /** - * Construct a QofInt128 from two int64_t. + * Construct a GncInt128 from two int64_t. * * N.B.: If the two parameters are of differing sign, it's taken to * mean that the lower magnitude is *reducing* the magnitude of the * upper, so the lower magnitude will be subracted from UINT64_MAX to * obtain the lower limb value. */ - QofInt128 (int16_t upper, int16_t lower, unsigned char flags = '\0') : - QofInt128{static_cast(upper), static_cast(lower), + GncInt128 (int16_t upper, int16_t lower, unsigned char flags = '\0') : + GncInt128{static_cast(upper), static_cast(lower), flags} {}; - QofInt128 (uint16_t upper, uint16_t lower, unsigned char flags = '\0') : - QofInt128{static_cast(upper), static_cast(lower), + GncInt128 (uint16_t upper, uint16_t lower, unsigned char flags = '\0') : + GncInt128{static_cast(upper), static_cast(lower), flags} {}; - QofInt128 (int32_t upper, int32_t lower, unsigned char flags = '\0') : - QofInt128{static_cast(upper), static_cast(lower), + GncInt128 (int32_t upper, int32_t lower, unsigned char flags = '\0') : + GncInt128{static_cast(upper), static_cast(lower), flags} {}; - QofInt128 (uint32_t upper, uint32_t lower, unsigned char flags = '\0') : - QofInt128{static_cast(upper), static_cast(lower), + GncInt128 (uint32_t upper, uint32_t lower, unsigned char flags = '\0') : + GncInt128{static_cast(upper), static_cast(lower), flags} {}; - QofInt128 (int64_t upper, int64_t lower, unsigned char flags = '\0'); - QofInt128 (uint64_t upper, uint64_t lower, unsigned char flags = '\0'); + GncInt128 (int64_t upper, int64_t lower, unsigned char flags = '\0'); + GncInt128 (uint64_t upper, uint64_t lower, unsigned char flags = '\0'); /** * Clear the object. @@ -99,7 +99,7 @@ enum // Values for m_flags * Sets all member variables to zero. * @return A reference to the object for chaining. */ - QofInt128& zero() noexcept; + GncInt128& zero() noexcept; /** * Compare function. @@ -107,29 +107,29 @@ enum // Values for m_flags * @return -1 if the object is less than the parameter, 0 if they're * equal, and 1 if the object is greater. */ - int cmp (const QofInt128& b) const noexcept; + int cmp (const GncInt128& b) const noexcept; /** * Computes the Greatest Common Divisor between the object and paramter * - * @return A QofInt128 having the GCD. + * @return A GncInt128 having the GCD. */ - QofInt128 gcd (QofInt128 b) const noexcept; + GncInt128 gcd (GncInt128 b) const noexcept; /** * Computes the Least Common Multiple between the object and parameter * - * @return A QofInt128 having the LCM. + * @return A GncInt128 having the LCM. */ - QofInt128 lcm (const QofInt128& b) const noexcept; + GncInt128 lcm (const GncInt128& b) const noexcept; /** * Computes the object raised to the parameter's power * - * @param b The power to raise this to. No point in taking a QofInt128, any + * @param 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. - * @return A QofInt128 + * @return A GncInt128 */ - QofInt128 pow (uint n) const noexcept; + GncInt128 pow (uint n) const noexcept; /** * Computes a quotient and a remainder, passed as reference parameters. @@ -140,7 +140,7 @@ enum // Values for m_flags * @param q The quotient; will be NaN if divisor = 0 * @param r The remainder; will be 0 if divisor = 0 */ - void div (const QofInt128& d, QofInt128& q, QofInt128& r) noexcept; + void div (const GncInt128& d, GncInt128& q, GncInt128& r) noexcept; /** * Explicit conversion to int64_t. @@ -188,7 +188,7 @@ enum // Values for m_flags /** * Fills a supplied buffer with a representation of the number in base 10. If - * the QofInt128 is overflowed or NaN it will contain the words "Overflow" or + * the GncInt128 is overflowed or NaN it will contain the words "Overflow" or * "NaN" respectively. * * @param buf char[41], 39 digits plus sign and trailing 0. @@ -196,59 +196,59 @@ enum // Values for m_flags */ char* asCharBufR(char* buf) const noexcept; - QofInt128 abs() const noexcept; + GncInt128 abs() const noexcept; - QofInt128 operator-() const noexcept; + GncInt128 operator-() const noexcept; explicit operator bool() const noexcept; - QofInt128& operator++ () noexcept; - QofInt128& operator++ (int) noexcept; - QofInt128& operator-- () noexcept; - QofInt128& operator-- (int) noexcept; - QofInt128& operator<<= (uint i) noexcept; - QofInt128& operator>>= (uint i) noexcept; - QofInt128& operator+= (const QofInt128& b) noexcept; - QofInt128& operator-= (const QofInt128& b) noexcept; - QofInt128& operator*= (const QofInt128& b) noexcept; - QofInt128& operator/= (const QofInt128& b) noexcept; - QofInt128& operator%= (const QofInt128& b) noexcept; - QofInt128& operator&= (const QofInt128& b) noexcept; - QofInt128& operator|= (const QofInt128& b) noexcept; - QofInt128& operator^= (const QofInt128& b) noexcept; + GncInt128& operator++ () noexcept; + GncInt128& operator++ (int) noexcept; + GncInt128& operator-- () noexcept; + GncInt128& operator-- (int) noexcept; + GncInt128& operator<<= (uint i) noexcept; + GncInt128& operator>>= (uint 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 const QofInt128 k_qofInt128_Max {UINT64_MAX, UINT64_MAX, QofInt128::pos}; -static const QofInt128 k_qofInt128_Min {UINT64_MAX, UINT64_MAX, QofInt128::neg}; +static const GncInt128 k_gncint128_Max {UINT64_MAX, UINT64_MAX, GncInt128::pos}; +static const GncInt128 k_gncint128_Min {UINT64_MAX, UINT64_MAX, GncInt128::neg}; -QofInt128 operator+ (QofInt128 a, const QofInt128& b) noexcept; -QofInt128 operator- (QofInt128 a, const QofInt128& b) noexcept; -QofInt128 operator* (QofInt128 a, const QofInt128& b) noexcept; -QofInt128 operator/ (QofInt128 a, const QofInt128& b) noexcept; -QofInt128 operator% (QofInt128 a, const QofInt128& b) noexcept; -QofInt128 operator& (QofInt128 a, const QofInt128& b) noexcept; -QofInt128 operator| (QofInt128 a, const QofInt128& b) noexcept; -QofInt128 operator^ (QofInt128 a, const QofInt128& b) noexcept; -QofInt128 operator<< (QofInt128 a, uint b) noexcept; -QofInt128 operator>> (QofInt128 a, uint b) noexcept; +GncInt128 operator+ (GncInt128 a, const GncInt128& b) noexcept; +GncInt128 operator- (GncInt128 a, const GncInt128& b) noexcept; +GncInt128 operator* (GncInt128 a, const GncInt128& b) noexcept; +GncInt128 operator/ (GncInt128 a, const GncInt128& b) noexcept; +GncInt128 operator% (GncInt128 a, const GncInt128& b) noexcept; +GncInt128 operator& (GncInt128 a, const GncInt128& b) noexcept; +GncInt128 operator| (GncInt128 a, const GncInt128& b) noexcept; +GncInt128 operator^ (GncInt128 a, const GncInt128& b) noexcept; +GncInt128 operator<< (GncInt128 a, uint b) noexcept; +GncInt128 operator>> (GncInt128 a, uint b) noexcept; -bool operator== (const QofInt128& a, const QofInt128& b) noexcept; -bool operator!= (const QofInt128& a, const QofInt128& b) noexcept; -bool operator<= (const QofInt128& a, const QofInt128& b) noexcept; -bool operator>= (const QofInt128& a, const QofInt128& b) noexcept; -bool operator< (const QofInt128& a, const QofInt128& b) noexcept; -bool operator> (const QofInt128& a, const QofInt128& b) noexcept; +bool operator== (const GncInt128& a, const GncInt128& b) noexcept; +bool operator!= (const GncInt128& a, const GncInt128& b) noexcept; +bool operator<= (const GncInt128& a, const GncInt128& b) noexcept; +bool operator>= (const GncInt128& a, const GncInt128& b) noexcept; +bool operator< (const GncInt128& a, const GncInt128& b) noexcept; +bool operator> (const GncInt128& a, const GncInt128& b) noexcept; -std::ostream& operator<< (std::ostream&, const QofInt128&) noexcept; +std::ostream& operator<< (std::ostream&, const GncInt128&) noexcept; /** Compute the greatest common denominator of two integers */ -QofInt128 gcd (int64_t a, int64_t b); +GncInt128 gcd (int64_t a, int64_t b); /** Compute the least common multiple of two integers */ -QofInt128 lcm (int64_t a, int64_t b); +GncInt128 lcm (int64_t a, int64_t b); -#endif //QOFINT128_H +#endif //GNCINT128_H /** @} */ diff --git a/src/libqof/qof/gnc-numeric.cpp b/src/libqof/qof/gnc-numeric.cpp index 1fbfda8321..94c0bd3604 100644 --- a/src/libqof/qof/gnc-numeric.cpp +++ b/src/libqof/qof/gnc-numeric.cpp @@ -38,7 +38,6 @@ extern "C" #endif #include "gnc-numeric.h" -#include "qofint128.hpp" #include "gnc-rational.hpp" using GncNumeric = GncRational; diff --git a/src/libqof/qof/gnc-rational.cpp b/src/libqof/qof/gnc-rational.cpp index d0d46e22a6..30e5cf49fd 100644 --- a/src/libqof/qof/gnc-rational.cpp +++ b/src/libqof/qof/gnc-rational.cpp @@ -47,7 +47,7 @@ GncRational::GncRational (gnc_numeric n) noexcept : } } -GncRational::GncRational (QofInt128 num, QofInt128 den) noexcept : +GncRational::GncRational (GncInt128 num, GncInt128 den) noexcept : m_num (num), m_den (den), m_error {} { } @@ -121,7 +121,7 @@ GncRational::div (GncRational b, GncDenom& d) noexcept if (m_num.isBig() || m_den.isBig() || b.m_num.isBig() || b.m_den.isBig()) { - QofInt128 gcd = b.m_den.gcd(m_den); + GncInt128 gcd = b.m_den.gcd(m_den); b.m_den /= gcd; m_den /= gcd; } @@ -141,7 +141,7 @@ GncRational::add (const GncRational& b, GncDenom& d) noexcept m_error = b.m_error; return *this; } - QofInt128 lcm = m_den.lcm (b.m_den); + GncInt128 lcm = m_den.lcm (b.m_den); m_num = m_num * lcm / m_den + b.m_num * lcm / b.m_den; m_den = lcm; round (d); @@ -163,7 +163,7 @@ GncRational::round (GncDenom& denom) noexcept m_error = denom.m_error; return; } - QofInt128 new_den = denom.get(); + GncInt128 new_den = denom.get(); if (new_den == 0) new_den = m_den; if (!(m_num.isBig() || new_den.isBig() )) { @@ -176,7 +176,7 @@ GncRational::round (GncDenom& denom) noexcept return; } } - QofInt128 new_num {}, remainder {}; + GncInt128 new_num {}, remainder {}; if (new_den.isNeg()) m_num.div(-new_den * m_den, new_num, remainder); else @@ -198,7 +198,7 @@ GncRational::round (GncDenom& denom) noexcept } /* First, try to reduce it */ - QofInt128 gcd = new_num.gcd(new_den); + GncInt128 gcd = new_num.gcd(new_den); new_num /= gcd; new_den /= gcd; remainder /= gcd; @@ -332,7 +332,7 @@ GncDenom::reduce (const GncRational& a) noexcept break; case DenomType::sigfigs: - QofInt128 val {}; + GncInt128 val {}; if (a.m_num.abs() > a.m_den) val = a.m_num.abs() / a.m_den; else diff --git a/src/libqof/qof/gnc-rational.hpp b/src/libqof/qof/gnc-rational.hpp index 09aeafacf4..0457c213c1 100644 --- a/src/libqof/qof/gnc-rational.hpp +++ b/src/libqof/qof/gnc-rational.hpp @@ -19,7 +19,7 @@ * Boston, MA 02110-1301, USA gnu@gnu.org * * * *******************************************************************/ -#include "qofint128.hpp" +#include "gnc-int128.hpp" #include "gnc-numeric.h" struct GncDenom; @@ -28,7 +28,7 @@ class GncRational { public: GncRational (gnc_numeric n) noexcept; - GncRational (QofInt128 num, QofInt128 den) noexcept; + GncRational (GncInt128 num, GncInt128 den) noexcept; /** Conversion operator; use static_cast(foo). */ operator gnc_numeric() const noexcept; /** Make a new GncRational with the opposite sign. */ @@ -46,8 +46,8 @@ public: GncRational& sub(const GncRational& b, GncDenom& d) noexcept; - QofInt128 m_num; - QofInt128 m_den; + GncInt128 m_num; + GncInt128 m_den; GNCNumericErrorCode m_error; }; @@ -55,7 +55,7 @@ struct GncDenom { GncDenom (GncRational& a, GncRational& b, int64_t spec, uint how) noexcept; void reduce (const GncRational& a) noexcept; - QofInt128 get () const noexcept { return m_value; } + GncInt128 get () const noexcept { return m_value; } enum class RoundType : int { @@ -77,7 +77,7 @@ struct GncDenom sigfigs = GNC_HOW_DENOM_SIGFIG, }; - QofInt128 m_value; + GncInt128 m_value; RoundType m_round; DenomType m_type; bool m_auto; diff --git a/src/libqof/qof/test/Makefile.am b/src/libqof/qof/test/Makefile.am index 0c0210f00e..e331b2e976 100644 --- a/src/libqof/qof/test/Makefile.am +++ b/src/libqof/qof/test/Makefile.am @@ -34,20 +34,20 @@ check_PROGRAMS = \ TESTS = ${check_PROGRAMS} if WITH_GOOGLE_TEST -test_qofint128_SOURCES = \ - $(top_srcdir)/${MODULEPATH}/qofint128.cpp \ +test_gnc_int128_SOURCES = \ + $(top_srcdir)/${MODULEPATH}/gnc-int128.cpp \ ${GTEST_ROOT}/src/gtest_main.cc \ - gtest-qofint128.cpp + gtest-gnc-int128.cpp -test_qofint128_CPPFLAGS = \ +test_gnc_int128_CPPFLAGS = \ -I${GTEST_HEADERS} \ ${GLIB_CFLAGS} -test_qofint128_LDADD = \ +test_gnc_int128_LDADD = \ ${GLIB_LIBS} \ $(top_builddir)/src/test-core/libgtest.a -check_PROGRAMS += test-qofint128 +check_PROGRAMS += test-gnc-int128 endif test_qofdir = ${GNC_LIBEXECDIR}/${MODULEPATH}/test diff --git a/src/libqof/qof/test/gtest-qofint128.cpp b/src/libqof/qof/test/gtest-gnc-int128.cpp similarity index 69% rename from src/libqof/qof/test/gtest-qofint128.cpp rename to src/libqof/qof/test/gtest-gnc-int128.cpp index 46ec5a50cb..b8a121ee0a 100644 --- a/src/libqof/qof/test/gtest-qofint128.cpp +++ b/src/libqof/qof/test/gtest-gnc-int128.cpp @@ -1,5 +1,5 @@ /******************************************************************** - * gtest-qofmath128.cpp -- unit tests for the QofInt128 class * + * Gtest-gnc-int128.cpp -- unit tests for the GncInt128 class * * Copyright (C) 2014 John Ralls * * * * This program is free software; you can redistribute it and/or * @@ -22,11 +22,11 @@ *******************************************************************/ #include -#include "../qofint128.hpp" +#include "../gnc-int128.hpp" TEST(qofint128_constructors, test_default_constructor) { - QofInt128 value {}; + GncInt128 value {}; EXPECT_EQ (true, value.isZero()); EXPECT_EQ (false, value.isNeg()); EXPECT_EQ (false, value.isBig()); @@ -36,28 +36,28 @@ TEST(qofint128_constructors, test_default_constructor) TEST(qofint128_constructors, test_single_arg_constructor) { - QofInt128 value1 (INT64_C(0)); + GncInt128 value1 (INT64_C(0)); EXPECT_EQ (true, value1.isZero()); EXPECT_EQ (false, value1.isNeg()); EXPECT_EQ (false, value1.isBig()); EXPECT_EQ (false, value1.isOverflow()); EXPECT_EQ (false, value1.isNan()); - QofInt128 value2 (INT64_C(567894392130486208)); + GncInt128 value2 (INT64_C(567894392130486208)); EXPECT_EQ (false, value2.isZero()); EXPECT_EQ (false, value2.isNeg()); EXPECT_EQ (false, value2.isBig()); EXPECT_EQ (false, value2.isOverflow()); EXPECT_EQ (false, value2.isNan()); - QofInt128 value3 (INT64_C(-567894392130486208)); + GncInt128 value3 (INT64_C(-567894392130486208)); EXPECT_EQ (false, value3.isZero()); EXPECT_EQ (true, value3.isNeg()); EXPECT_EQ (false, value3.isBig()); EXPECT_EQ (false, value3.isOverflow()); EXPECT_EQ (false, value3.isNan()); - QofInt128 value4 (UINT64_C(13567894392130486208)); + GncInt128 value4 (UINT64_C(13567894392130486208)); EXPECT_EQ (false, value4.isZero()); EXPECT_EQ (false, value4.isNeg()); EXPECT_EQ (true, value4.isBig()); @@ -67,35 +67,35 @@ TEST(qofint128_constructors, test_single_arg_constructor) TEST(qofint128_constructors, test_double_arg_constructor) { - QofInt128 value1 (INT64_C(0), INT64_C(0)); + GncInt128 value1 (INT64_C(0), INT64_C(0)); EXPECT_EQ (true, value1.isZero()); EXPECT_EQ (false, value1.isNeg()); EXPECT_EQ (false, value1.isBig()); EXPECT_EQ (false, value1.isOverflow()); EXPECT_EQ (false, value1.isNan()); - QofInt128 value2 (INT64_C(0), INT64_C(567894392130486208)); + GncInt128 value2 (INT64_C(0), INT64_C(567894392130486208)); EXPECT_EQ (false, value2.isZero()); EXPECT_EQ (false, value2.isNeg()); EXPECT_EQ (false, value2.isBig()); EXPECT_EQ (false, value2.isOverflow()); EXPECT_EQ (false, value2.isNan()); - QofInt128 value3 (INT64_C(567894392130486208), INT64_C(0)); + GncInt128 value3 (INT64_C(567894392130486208), INT64_C(0)); EXPECT_EQ (false, value3.isZero()); EXPECT_EQ (false, value3.isNeg()); EXPECT_EQ (true, value3.isBig()); EXPECT_EQ (false, value3.isOverflow()); EXPECT_EQ (false, value3.isNan()); - QofInt128 value4 (INT64_C(567894392130486208), INT64_C(567894392130486208)); + GncInt128 value4 (INT64_C(567894392130486208), INT64_C(567894392130486208)); EXPECT_EQ (false, value4.isZero()); EXPECT_EQ (false, value4.isNeg()); EXPECT_EQ (true, value4.isBig()); EXPECT_EQ (false, value4.isOverflow()); EXPECT_EQ (false, value4.isNan()); - QofInt128 value5 (INT64_C(567894392130486208), + GncInt128 value5 (INT64_C(567894392130486208), INT64_C(-567894392130486208)); EXPECT_EQ (false, value5.isZero()); EXPECT_EQ (false, value5.isNeg()); @@ -103,7 +103,7 @@ TEST(qofint128_constructors, test_double_arg_constructor) EXPECT_EQ (false, value5.isOverflow()); EXPECT_EQ (false, value5.isNan()); - QofInt128 value6 (INT64_C(-567894392130486208), + GncInt128 value6 (INT64_C(-567894392130486208), INT64_C(567894392130486208)); EXPECT_EQ (false, value6.isZero()); EXPECT_EQ (true, value6.isNeg()); @@ -111,32 +111,32 @@ TEST(qofint128_constructors, test_double_arg_constructor) EXPECT_EQ (false, value6.isOverflow()); EXPECT_EQ (false, value6.isNan()); - QofInt128 value7 (UINT64_C(13567894392130486208), - UINT64_C(13567894392130486208), QofInt128::pos); + GncInt128 value7 (UINT64_C(13567894392130486208), + UINT64_C(13567894392130486208), GncInt128::pos); EXPECT_EQ (false, value7.isZero()); EXPECT_EQ (false, value7.isNeg()); EXPECT_EQ (true, value7.isBig()); EXPECT_EQ (false, value7.isOverflow()); EXPECT_EQ (false, value7.isNan()); - QofInt128 value8 (UINT64_C(13567894392130486208), - UINT64_C(13567894392130486208), QofInt128::neg); + GncInt128 value8 (UINT64_C(13567894392130486208), + UINT64_C(13567894392130486208), GncInt128::neg); EXPECT_EQ (false, value8.isZero()); EXPECT_EQ (true, value8.isNeg()); EXPECT_EQ (true, value8.isBig()); EXPECT_EQ (false, value8.isOverflow()); EXPECT_EQ (false, value8.isNan()); - QofInt128 value9 (UINT64_C(13567894392130486208), - UINT64_C(13567894392130486208), QofInt128::overflow); + GncInt128 value9 (UINT64_C(13567894392130486208), + UINT64_C(13567894392130486208), GncInt128::overflow); EXPECT_EQ (false, value9.isZero()); EXPECT_EQ (false, value9.isNeg()); EXPECT_EQ (true, value9.isBig()); EXPECT_EQ (true, value9.isOverflow()); EXPECT_EQ (false, value9.isNan()); - QofInt128 value10 (UINT64_C(13567894392130486208), - UINT64_C(13567894392130486208), QofInt128::NaN); + GncInt128 value10 (UINT64_C(13567894392130486208), + UINT64_C(13567894392130486208), GncInt128::NaN); EXPECT_EQ (false, value10.isZero()); EXPECT_EQ (false, value10.isNeg()); EXPECT_EQ (true, value10.isBig()); @@ -149,45 +149,45 @@ TEST(qofint128_functions, test_int_functions) int64_t arg {INT64_C(567894392130486208)}; int64_t narg {INT64_C(-567894392130486208)}; uint64_t uarg {UINT64_C(13567894392130486208)}; - QofInt128 value1 (INT64_C(0), arg); + GncInt128 value1 (INT64_C(0), arg); EXPECT_EQ (arg, static_cast(value1)); EXPECT_EQ (static_cast(arg), static_cast(value1)); - QofInt128 value2 (UINT64_C(0), uarg); + GncInt128 value2 (UINT64_C(0), uarg); EXPECT_THROW (static_cast(value2), std::overflow_error); EXPECT_EQ (uarg, static_cast(value2)); - QofInt128 value3 (UINT64_C(0), uarg, QofInt128::neg); + GncInt128 value3 (UINT64_C(0), uarg, GncInt128::neg); EXPECT_THROW (static_cast(value3), std::underflow_error); EXPECT_THROW (static_cast(value3), std::underflow_error); - QofInt128 value4 (UINT64_C(0), uarg, QofInt128::overflow); + GncInt128 value4 (UINT64_C(0), uarg, GncInt128::overflow); EXPECT_THROW (static_cast(value4), std::overflow_error); EXPECT_THROW (static_cast(value4), std::overflow_error); - QofInt128 value5 (UINT64_C(0), uarg, QofInt128::NaN); + GncInt128 value5 (UINT64_C(0), uarg, GncInt128::NaN); EXPECT_THROW (static_cast(value5), std::overflow_error); EXPECT_THROW (static_cast(value5), std::overflow_error); - QofInt128 value6 (INT64_C(1), arg); + GncInt128 value6 (INT64_C(1), arg); EXPECT_THROW (static_cast(value6), std::overflow_error); EXPECT_EQ (arg + (UINT64_C(0x1) << 63), static_cast(value6)); - QofInt128 value7 (INT64_C(-1), arg); + GncInt128 value7 (INT64_C(-1), arg); EXPECT_EQ (-static_cast((UINT64_C(0x1) << 63) - arg), static_cast(value7)); EXPECT_THROW (static_cast(value7), std::underflow_error); - QofInt128 value8 (INT64_C(0), narg); + GncInt128 value8 (INT64_C(0), narg); EXPECT_EQ (narg, static_cast(value8)); EXPECT_THROW (static_cast(value8), std::underflow_error); - QofInt128 value9 (INT64_C(1), narg); + GncInt128 value9 (INT64_C(1), narg); EXPECT_EQ (static_cast((UINT64_C(0x1) << 63) + narg), static_cast(value9)); EXPECT_EQ ((UINT64_C(0x1) << 63) + narg, static_cast(value9)); - QofInt128 value10 (INT64_C(-2), arg); + GncInt128 value10 (INT64_C(-2), arg); EXPECT_THROW (static_cast(value10), std::underflow_error); EXPECT_THROW (static_cast(value10), std::underflow_error); @@ -200,23 +200,23 @@ TEST(qofint128_functions, test_compare) int64_t sarg {INT64_C(567894392130486207)}; int64_t nsarg {INT64_C(-567894392130486207)}; - QofInt128 big (barg); - QofInt128 small (sarg); - QofInt128 neg_big (nbarg); - QofInt128 neg_small (nsarg); + GncInt128 big (barg); + GncInt128 small (sarg); + GncInt128 neg_big (nbarg); + GncInt128 neg_small (nsarg); - QofInt128 really_big (barg, sarg); - QofInt128 slightly_bigger (barg, barg); - QofInt128 not_as_big (sarg, barg); - QofInt128 a_little_smaller (sarg, sarg); + GncInt128 really_big (barg, sarg); + GncInt128 slightly_bigger (barg, barg); + GncInt128 not_as_big (sarg, barg); + GncInt128 a_little_smaller (sarg, sarg); - QofInt128 neg_really_big (barg, sarg, QofInt128::neg); - QofInt128 neg_slightly_bigger (barg, barg, QofInt128::neg); - QofInt128 neg_not_as_big (sarg, barg, QofInt128::neg); - QofInt128 neg_a_little_smaller (sarg, sarg, QofInt128::neg); + GncInt128 neg_really_big (barg, sarg, GncInt128::neg); + GncInt128 neg_slightly_bigger (barg, barg, GncInt128::neg); + GncInt128 neg_not_as_big (sarg, barg, GncInt128::neg); + GncInt128 neg_a_little_smaller (sarg, sarg, GncInt128::neg); - QofInt128 overflowed (INT64_C(0), INT64_C(0), QofInt128::overflow); - QofInt128 not_a_number (INT64_C(0), INT64_C(0), QofInt128::NaN); + GncInt128 overflowed (INT64_C(0), INT64_C(0), GncInt128::overflow); + GncInt128 not_a_number (INT64_C(0), INT64_C(0), GncInt128::NaN); EXPECT_EQ (-1, overflowed.cmp (big)); EXPECT_EQ (-1, not_a_number.cmp (big)); @@ -250,9 +250,9 @@ TEST(qofint128_functions, test_compare) EXPECT_EQ (-1, neg_not_as_big.cmp(neg_a_little_smaller)); EXPECT_EQ (-1, neg_really_big.cmp(neg_a_little_smaller)); - EXPECT_EQ (0, neg_really_big.cmp(QofInt128(barg, sarg, QofInt128::neg))); - EXPECT_EQ (0, really_big.cmp(QofInt128(barg, sarg))); - EXPECT_EQ (0, really_big.cmp(QofInt128(barg, sarg, QofInt128::pos))); + EXPECT_EQ (0, neg_really_big.cmp(GncInt128(barg, sarg, GncInt128::neg))); + EXPECT_EQ (0, really_big.cmp(GncInt128(barg, sarg))); + EXPECT_EQ (0, really_big.cmp(GncInt128(barg, sarg, GncInt128::pos))); EXPECT_EQ (0, really_big.cmp(-neg_really_big)); EXPECT_EQ (0, neg_really_big.cmp(-really_big)); @@ -264,15 +264,15 @@ TEST(qofint128_functions, stream_output) int64_t sarg {INT64_C(567894392130486207)}; int64_t nsarg {INT64_C(-567894392130486207)}; - QofInt128 small (sarg); - QofInt128 neg_small (nsarg); + GncInt128 small (sarg); + GncInt128 neg_small (nsarg); - QofInt128 really_big (barg, sarg); - QofInt128 neg_really_big (barg, sarg, QofInt128::neg); + GncInt128 really_big (barg, sarg); + GncInt128 neg_really_big (barg, sarg, GncInt128::neg); - QofInt128 overflowed (INT64_C(0), INT64_C(0), QofInt128::overflow); - QofInt128 not_a_number (INT64_C(0), INT64_C(0), QofInt128::NaN); - QofInt128 boundary_value (UINT64_C(1), UINT64_MAX); + GncInt128 overflowed (INT64_C(0), INT64_C(0), GncInt128::overflow); + GncInt128 not_a_number (INT64_C(0), INT64_C(0), GncInt128::NaN); + GncInt128 boundary_value (UINT64_C(1), UINT64_MAX); static const uint8_t char_buf_size {41}; char buf[char_buf_size] {}; @@ -297,24 +297,24 @@ TEST(qofint128_functions, add_and_subtract) int64_t sarg {INT64_C(4344522355275710400)}; uint64_t uarg {UINT64_C(13567894392130486208)}; - QofInt128 smallest (sarg + 100); - QofInt128 smaller (barg + 500); - QofInt128 small (uarg); - QofInt128 big (sarg, barg); - QofInt128 bigger (static_cast(barg), uarg); - QofInt128 biggest (uarg, static_cast(barg)); - QofInt128 nsmall (UINT64_C(0), uarg, QofInt128::neg); + GncInt128 smallest (sarg + 100); + GncInt128 smaller (barg + 500); + GncInt128 small (uarg); + GncInt128 big (sarg, barg); + GncInt128 bigger (static_cast(barg), uarg); + GncInt128 biggest (uarg, static_cast(barg)); + GncInt128 nsmall (UINT64_C(0), uarg, GncInt128::neg); - EXPECT_EQ (QofInt128(INT64_C(2), INT64_C(499)), small += smaller); - EXPECT_EQ (QofInt128(INT64_C(2), INT64_C(499), QofInt128::neg), + EXPECT_EQ (GncInt128(INT64_C(2), INT64_C(499)), small += smaller); + EXPECT_EQ (GncInt128(INT64_C(2), INT64_C(499), GncInt128::neg), nsmall -= smaller); - EXPECT_EQ (QofInt128(uarg), small -= smaller); - EXPECT_EQ (QofInt128(static_cast(barg + sarg/2), UINT64_MAX), + EXPECT_EQ (GncInt128(uarg), small -= smaller); + EXPECT_EQ (GncInt128(static_cast(barg + sarg/2), UINT64_MAX), bigger += big); - EXPECT_EQ (QofInt128(static_cast(barg), uarg), bigger -= big); + EXPECT_EQ (GncInt128(static_cast(barg), uarg), bigger -= big); bigger += biggest; - EXPECT_EQ (QofInt128(UINT64_MAX, UINT64_MAX), bigger); + EXPECT_EQ (GncInt128(UINT64_MAX, UINT64_MAX), bigger); bigger += smallest; EXPECT_TRUE (bigger.isOverflow()); bigger -= biggest; @@ -327,17 +327,17 @@ TEST(qofint128_functions, multiply) int64_t sarg {INT64_C(4344522355275710400)}; uint64_t uarg {UINT64_C(13567894392130486208)}; - QofInt128 smallest (sarg); - QofInt128 smaller (barg); - QofInt128 small (uarg); - QofInt128 big (sarg, barg); - QofInt128 bigger (static_cast(barg), uarg); + GncInt128 smallest (sarg); + GncInt128 smaller (barg); + GncInt128 small (uarg); + GncInt128 big (sarg, barg); + GncInt128 bigger (static_cast(barg), uarg); small *= big; EXPECT_TRUE (small.isOverflow()); big *= bigger; EXPECT_TRUE (big.isOverflow()); - EXPECT_EQ (QofInt128(UINT64_C(1149052180967758316), UINT64_C(6323251814974894144)), smallest *= smaller); + EXPECT_EQ (GncInt128(UINT64_C(1149052180967758316), UINT64_C(6323251814974894144)), smallest *= smaller); EXPECT_FALSE (smallest.isOverflow()); } @@ -348,39 +348,39 @@ TEST(qofint128_functions, divide) int64_t sarg {INT64_C(4344522355275710400)}; uint64_t uarg {UINT64_C(13567894392130486208)}; - QofInt128 zero (INT64_C(0)); - QofInt128 one (INT64_C(1)); - QofInt128 two (INT64_C(2)); - QofInt128 smallest (sarg); - QofInt128 smaller (barg); - QofInt128 small (uarg); - QofInt128 big (sarg, barg); - QofInt128 bigger (static_cast(barg), uarg); - QofInt128 nsmall = -small; - QofInt128 nbig = -bigger; + GncInt128 zero (INT64_C(0)); + GncInt128 one (INT64_C(1)); + GncInt128 two (INT64_C(2)); + GncInt128 smallest (sarg); + GncInt128 smaller (barg); + GncInt128 small (uarg); + GncInt128 big (sarg, barg); + GncInt128 bigger (static_cast(barg), uarg); + GncInt128 nsmall = -small; + GncInt128 nbig = -bigger; - EXPECT_EQ (QofInt128(INT64_C(0)), zero /= smallest); - EXPECT_EQ (QofInt128(INT64_C(0)), zero %= smallest); + EXPECT_EQ (GncInt128(INT64_C(0)), zero /= smallest); + EXPECT_EQ (GncInt128(INT64_C(0)), zero %= smallest); smallest /= zero; EXPECT_TRUE (smallest.isNan()); - QofInt128 r {}, q {}; + GncInt128 r {}, q {}; small.div (smaller, q, r); EXPECT_EQ (two, q); - EXPECT_EQ (QofInt128(INT64_C(3810195028972355394)), r); + EXPECT_EQ (GncInt128(INT64_C(3810195028972355394)), r); small.div (-smaller, q, r); EXPECT_EQ (-two, q); - EXPECT_EQ (QofInt128(INT64_C(3810195028972355394)), r); + EXPECT_EQ (GncInt128(INT64_C(3810195028972355394)), r); nsmall.div (smaller, q, r); EXPECT_EQ (-two, q); - EXPECT_EQ (QofInt128(INT64_C(3810195028972355394)), r); + EXPECT_EQ (GncInt128(INT64_C(3810195028972355394)), r); nsmall.div (-smaller, q, r); EXPECT_EQ (two, q); - EXPECT_EQ (QofInt128(INT64_C(3810195028972355394)), r); + EXPECT_EQ (GncInt128(INT64_C(3810195028972355394)), r); bigger.div (bigger, q, r); EXPECT_EQ (one, q); @@ -391,27 +391,27 @@ TEST(qofint128_functions, divide) EXPECT_EQ (zero, r); big.div (smaller, q, r); - EXPECT_EQ (QofInt128(INT64_C(8213236443097627766)), q); - EXPECT_EQ (QofInt128(INT64_C(3162679692459777845)), r); + EXPECT_EQ (GncInt128(INT64_C(8213236443097627766)), q); + EXPECT_EQ (GncInt128(INT64_C(3162679692459777845)), r); bigger.div (big, q, r); EXPECT_EQ (two, q); - EXPECT_EQ (QofInt128(UINT64_C(534327326303355007), + EXPECT_EQ (GncInt128(UINT64_C(534327326303355007), UINT64_C(3810195028972355394)), r); bigger.div (-big, q, r); EXPECT_EQ (-two, q); - EXPECT_EQ (QofInt128(UINT64_C(534327326303355007), + EXPECT_EQ (GncInt128(UINT64_C(534327326303355007), UINT64_C(3810195028972355394)), r); nbig.div (-big, q, r); EXPECT_EQ (two, q); - EXPECT_EQ (QofInt128(UINT64_C(534327326303355007), + EXPECT_EQ (GncInt128(UINT64_C(534327326303355007), UINT64_C(3810195028972355394)), r); nbig.div (-big, q, r); EXPECT_EQ (two, q); - EXPECT_EQ (QofInt128(UINT64_C(534327326303355007), + EXPECT_EQ (GncInt128(UINT64_C(534327326303355007), UINT64_C(3810195028972355394)), r); big.div (bigger, q, r); @@ -428,13 +428,13 @@ TEST(qofint128_functions, GCD) int64_t sarg {INT64_C(4344522355275710401)}; uint64_t uarg {UINT64_C(13567894392130486208)}; - QofInt128 one (INT64_C(1)); - QofInt128 smallest (sarg); - QofInt128 smaller (barg); - QofInt128 small (uarg); + GncInt128 one (INT64_C(1)); + GncInt128 smallest (sarg); + GncInt128 smaller (barg); + GncInt128 small (uarg); - QofInt128 big = smaller * smallest; - QofInt128 bigger = small * smaller; + GncInt128 big = smaller * smallest; + GncInt128 bigger = small * smaller; EXPECT_EQ (smaller, big.gcd(smaller)); EXPECT_EQ (smallest, big.gcd(smallest)); @@ -450,17 +450,17 @@ TEST(qofint128_functions, pow) int64_t sarg {INT64_C(53309)}; int64_t barg {INT64_C(4878849681579065407)}; - QofInt128 little (sarg); - QofInt128 big (barg); + GncInt128 little (sarg); + GncInt128 big (barg); auto minus = -little; - EXPECT_EQ (QofInt128(1), little.pow(0)); - EXPECT_EQ (QofInt128(0), QofInt128(0).pow(123)); + EXPECT_EQ (GncInt128(1), little.pow(0)); + EXPECT_EQ (GncInt128(0), GncInt128(0).pow(123)); EXPECT_EQ (big * big, big.pow(2)); - EXPECT_EQ (QofInt128(UINT64_C(66326033898754), + EXPECT_EQ (GncInt128(UINT64_C(66326033898754), UINT64_C(10251549987585143605)), little.pow(7)); - EXPECT_EQ (QofInt128(UINT64_C(66326033898754), - UINT64_C(10251549987585143605), QofInt128::neg), + EXPECT_EQ (GncInt128(UINT64_C(66326033898754), + UINT64_C(10251549987585143605), GncInt128::neg), minus.pow(7)); auto over = minus.pow(9); EXPECT_TRUE(over.isOverflow());