mirror of
https://github.com/Gnucash/gnucash.git
synced 2025-02-25 18:55:30 -06:00
Rename QofInt128 to GncInt128.
It has nothing to do with QOF.
This commit is contained in:
John Ralls
parent
d35bcdb877
commit
8a3e368791
@ -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
|
||||
|
||||
@ -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 \
|
||||
|
||||
@ -27,7 +27,7 @@ extern "C"
|
||||
#include <inttypes.h>
|
||||
}
|
||||
|
||||
#include "qofint128.hpp"
|
||||
#include "gnc-int128.hpp"
|
||||
|
||||
#include <iomanip>
|
||||
#include <utility>
|
||||
@ -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<unsigned char>(lower < 0 ? neg : pos)},
|
||||
m_hi {0},
|
||||
m_lo {static_cast<uint64_t>(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<unsigned char>(flags ^ (upper < 0 ? neg :
|
||||
upper == 0 && lower < 0 ? neg : pos))},
|
||||
m_hi {static_cast<uint64_t>(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<uint>(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;
|
||||
@ -22,8 +22,8 @@
|
||||
* *
|
||||
*******************************************************************/
|
||||
|
||||
#ifndef QOFINT128_H
|
||||
#define QOFINT128_H
|
||||
#ifndef GNCINT128_H
|
||||
#define GNCINT128_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
@ -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<int64_t>(lower)} {};
|
||||
QofInt128 (uint16_t lower) : QofInt128{static_cast<uint64_t>(lower)} {};
|
||||
QofInt128 (int32_t lower) : QofInt128{static_cast<int64_t>(lower)} {};
|
||||
QofInt128 (uint32_t lower) : QofInt128{static_cast<uint64_t>(lower)} {};
|
||||
QofInt128 (int64_t lower);
|
||||
QofInt128 (uint64_t lower);
|
||||
GncInt128 ();
|
||||
GncInt128 (int16_t lower) : GncInt128{static_cast<int64_t>(lower)} {};
|
||||
GncInt128 (uint16_t lower) : GncInt128{static_cast<uint64_t>(lower)} {};
|
||||
GncInt128 (int32_t lower) : GncInt128{static_cast<int64_t>(lower)} {};
|
||||
GncInt128 (uint32_t lower) : GncInt128{static_cast<uint64_t>(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<int64_t>(upper), static_cast<int64_t>(lower),
|
||||
GncInt128 (int16_t upper, int16_t lower, unsigned char flags = '\0') :
|
||||
GncInt128{static_cast<int64_t>(upper), static_cast<int64_t>(lower),
|
||||
flags} {};
|
||||
QofInt128 (uint16_t upper, uint16_t lower, unsigned char flags = '\0') :
|
||||
QofInt128{static_cast<int64_t>(upper), static_cast<int64_t>(lower),
|
||||
GncInt128 (uint16_t upper, uint16_t lower, unsigned char flags = '\0') :
|
||||
GncInt128{static_cast<int64_t>(upper), static_cast<int64_t>(lower),
|
||||
flags} {};
|
||||
QofInt128 (int32_t upper, int32_t lower, unsigned char flags = '\0') :
|
||||
QofInt128{static_cast<int64_t>(upper), static_cast<int64_t>(lower),
|
||||
GncInt128 (int32_t upper, int32_t lower, unsigned char flags = '\0') :
|
||||
GncInt128{static_cast<int64_t>(upper), static_cast<int64_t>(lower),
|
||||
flags} {};
|
||||
QofInt128 (uint32_t upper, uint32_t lower, unsigned char flags = '\0') :
|
||||
QofInt128{static_cast<int64_t>(upper), static_cast<int64_t>(lower),
|
||||
GncInt128 (uint32_t upper, uint32_t lower, unsigned char flags = '\0') :
|
||||
GncInt128{static_cast<int64_t>(upper), static_cast<int64_t>(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
|
||||
|
||||
/** @} */
|
||||
@ -38,7 +38,6 @@ extern "C"
|
||||
#endif
|
||||
|
||||
#include "gnc-numeric.h"
|
||||
#include "qofint128.hpp"
|
||||
#include "gnc-rational.hpp"
|
||||
|
||||
using GncNumeric = GncRational;
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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<gnc_numeric>(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;
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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 <jralls@ceridwen.us> *
|
||||
* *
|
||||
* This program is free software; you can redistribute it and/or *
|
||||
@ -22,11 +22,11 @@
|
||||
*******************************************************************/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#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<int64_t>(value1));
|
||||
EXPECT_EQ (static_cast<uint64_t>(arg), static_cast<uint64_t>(value1));
|
||||
|
||||
QofInt128 value2 (UINT64_C(0), uarg);
|
||||
GncInt128 value2 (UINT64_C(0), uarg);
|
||||
EXPECT_THROW (static_cast<int64_t>(value2), std::overflow_error);
|
||||
EXPECT_EQ (uarg, static_cast<uint64_t>(value2));
|
||||
|
||||
QofInt128 value3 (UINT64_C(0), uarg, QofInt128::neg);
|
||||
GncInt128 value3 (UINT64_C(0), uarg, GncInt128::neg);
|
||||
EXPECT_THROW (static_cast<int64_t>(value3), std::underflow_error);
|
||||
EXPECT_THROW (static_cast<uint64_t>(value3), std::underflow_error);
|
||||
|
||||
QofInt128 value4 (UINT64_C(0), uarg, QofInt128::overflow);
|
||||
GncInt128 value4 (UINT64_C(0), uarg, GncInt128::overflow);
|
||||
EXPECT_THROW (static_cast<int64_t>(value4), std::overflow_error);
|
||||
EXPECT_THROW (static_cast<uint64_t>(value4), std::overflow_error);
|
||||
|
||||
QofInt128 value5 (UINT64_C(0), uarg, QofInt128::NaN);
|
||||
GncInt128 value5 (UINT64_C(0), uarg, GncInt128::NaN);
|
||||
EXPECT_THROW (static_cast<int64_t>(value5), std::overflow_error);
|
||||
EXPECT_THROW (static_cast<uint64_t>(value5), std::overflow_error);
|
||||
|
||||
QofInt128 value6 (INT64_C(1), arg);
|
||||
GncInt128 value6 (INT64_C(1), arg);
|
||||
EXPECT_THROW (static_cast<int64_t>(value6), std::overflow_error);
|
||||
EXPECT_EQ (arg + (UINT64_C(0x1) << 63), static_cast<uint64_t>(value6));
|
||||
|
||||
QofInt128 value7 (INT64_C(-1), arg);
|
||||
GncInt128 value7 (INT64_C(-1), arg);
|
||||
EXPECT_EQ (-static_cast<int64_t>((UINT64_C(0x1) << 63) - arg),
|
||||
static_cast<int64_t>(value7));
|
||||
EXPECT_THROW (static_cast<uint64_t>(value7), std::underflow_error);
|
||||
|
||||
QofInt128 value8 (INT64_C(0), narg);
|
||||
GncInt128 value8 (INT64_C(0), narg);
|
||||
EXPECT_EQ (narg, static_cast<int64_t>(value8));
|
||||
EXPECT_THROW (static_cast<uint64_t>(value8), std::underflow_error);
|
||||
|
||||
QofInt128 value9 (INT64_C(1), narg);
|
||||
GncInt128 value9 (INT64_C(1), narg);
|
||||
EXPECT_EQ (static_cast<int64_t>((UINT64_C(0x1) << 63) + narg),
|
||||
static_cast<int64_t>(value9));
|
||||
EXPECT_EQ ((UINT64_C(0x1) << 63) + narg, static_cast<uint64_t>(value9));
|
||||
|
||||
QofInt128 value10 (INT64_C(-2), arg);
|
||||
GncInt128 value10 (INT64_C(-2), arg);
|
||||
EXPECT_THROW (static_cast<int64_t>(value10), std::underflow_error);
|
||||
EXPECT_THROW (static_cast<uint64_t>(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<uint64_t>(barg), uarg);
|
||||
QofInt128 biggest (uarg, static_cast<uint64_t>(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<uint64_t>(barg), uarg);
|
||||
GncInt128 biggest (uarg, static_cast<uint64_t>(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<uint64_t>(barg + sarg/2), UINT64_MAX),
|
||||
EXPECT_EQ (GncInt128(uarg), small -= smaller);
|
||||
EXPECT_EQ (GncInt128(static_cast<uint64_t>(barg + sarg/2), UINT64_MAX),
|
||||
bigger += big);
|
||||
EXPECT_EQ (QofInt128(static_cast<uint64_t>(barg), uarg), bigger -= big);
|
||||
EXPECT_EQ (GncInt128(static_cast<uint64_t>(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<uint64_t>(barg), uarg);
|
||||
GncInt128 smallest (sarg);
|
||||
GncInt128 smaller (barg);
|
||||
GncInt128 small (uarg);
|
||||
GncInt128 big (sarg, barg);
|
||||
GncInt128 bigger (static_cast<uint64_t>(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<uint64_t>(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<uint64_t>(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());
|
||||
Loading…
Reference in New Issue
Block a user