mirror of
https://github.com/Xahau/xahaud.git
synced 2026-07-27 17:10:15 +00:00
64ee0d07d0
* Zero lets classes efficiently compare with 0, so you can use constructors like x < zero or y != zero. * New BEAST_CONSTEXPR to handle Windows/C++11 differences regarding the constexpr specifier.
317 lines
8.9 KiB
C++
317 lines
8.9 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
This file is part of rippled: https://github.com/ripple/rippled
|
|
Copyright (c) 2012, 2013 Ripple Labs Inc.
|
|
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
|
purpose with or without fee is hereby granted, provided that the above
|
|
copyright notice and this permission notice appear in all copies.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
//==============================================================================
|
|
|
|
namespace ripple {
|
|
|
|
void STAmount::canonicalizeRound (bool isNative, std::uint64_t& value, int& offset, bool roundUp)
|
|
{
|
|
if (!roundUp) // canonicalize already rounds down
|
|
return;
|
|
|
|
WriteLog (lsTRACE, STAmount) << "canonicalize< " << value << ":" << offset << (roundUp ? " up" : " down");
|
|
|
|
if (isNative)
|
|
{
|
|
if (offset < 0)
|
|
{
|
|
int loops = 0;
|
|
|
|
while (offset < -1)
|
|
{
|
|
value /= 10;
|
|
++offset;
|
|
++loops;
|
|
}
|
|
|
|
value += (loops >= 2) ? 9 : 10; // add before last divide
|
|
value /= 10;
|
|
++offset;
|
|
}
|
|
}
|
|
else if (value > STAmount::cMaxValue)
|
|
{
|
|
while (value > (10 * STAmount::cMaxValue))
|
|
{
|
|
value /= 10;
|
|
++offset;
|
|
}
|
|
|
|
value += 9; // add before last divide
|
|
value /= 10;
|
|
++offset;
|
|
}
|
|
|
|
WriteLog (lsTRACE, STAmount) << "canonicalize> " << value << ":" << offset << (roundUp ? " up" : " down");
|
|
}
|
|
|
|
STAmount STAmount::addRound (const STAmount& v1, const STAmount& v2, bool roundUp)
|
|
{
|
|
v1.throwComparable (v2);
|
|
|
|
if (v2.mValue == 0)
|
|
return v1;
|
|
|
|
if (v1.mValue == 0)
|
|
return STAmount (v1.getFName (), v1.mCurrency, v1.mIssuer, v2.mValue, v2.mOffset, v2.mIsNegative);
|
|
|
|
if (v1.mIsNative)
|
|
return STAmount (v1.getFName (), v1.getSNValue () + v2.getSNValue ());
|
|
|
|
int ov1 = v1.mOffset, ov2 = v2.mOffset;
|
|
std::int64_t vv1 = static_cast<std::int64_t> (v1.mValue), vv2 = static_cast<std::uint64_t> (v2.mValue);
|
|
|
|
if (v1.mIsNegative)
|
|
vv1 = -vv1;
|
|
|
|
if (v2.mIsNegative)
|
|
vv2 = -vv2;
|
|
|
|
if (ov1 < ov2)
|
|
{
|
|
while (ov1 < (ov2 - 1))
|
|
{
|
|
vv1 /= 10;
|
|
++ov1;
|
|
}
|
|
|
|
if (roundUp)
|
|
vv1 += 9;
|
|
|
|
vv1 /= 10;
|
|
++ov1;
|
|
}
|
|
|
|
if (ov2 < ov1)
|
|
{
|
|
while (ov2 < (ov1 - 1))
|
|
{
|
|
vv2 /= 10;
|
|
++ov2;
|
|
}
|
|
|
|
if (roundUp)
|
|
vv2 += 9;
|
|
|
|
vv2 /= 10;
|
|
++ov2;
|
|
}
|
|
|
|
std::int64_t fv = vv1 + vv2;
|
|
|
|
if ((fv >= -10) && (fv <= 10))
|
|
return STAmount (v1.getFName (), v1.mCurrency, v1.mIssuer);
|
|
else if (fv >= 0)
|
|
{
|
|
std::uint64_t v = static_cast<std::uint64_t> (fv);
|
|
canonicalizeRound (false, v, ov1, roundUp);
|
|
return STAmount (v1.getFName (), v1.mCurrency, v1.mIssuer, v, ov1, false);
|
|
}
|
|
else
|
|
{
|
|
std::uint64_t v = static_cast<std::uint64_t> (-fv);
|
|
canonicalizeRound (false, v, ov1, !roundUp);
|
|
return STAmount (v1.getFName (), v1.mCurrency, v1.mIssuer, v, ov1, true);
|
|
}
|
|
}
|
|
|
|
STAmount STAmount::subRound (const STAmount& v1, const STAmount& v2, bool roundUp)
|
|
{
|
|
v1.throwComparable (v2);
|
|
|
|
if (v2.mValue == 0)
|
|
return v1;
|
|
|
|
if (v1.mValue == 0)
|
|
return STAmount (v1.getFName (), v1.mCurrency, v1.mIssuer, v2.mValue, v2.mOffset, !v2.mIsNegative);
|
|
|
|
if (v1.mIsNative)
|
|
return STAmount (v1.getFName (), v1.getSNValue () - v2.getSNValue ());
|
|
|
|
int ov1 = v1.mOffset, ov2 = v2.mOffset;
|
|
std::int64_t vv1 = static_cast<std::int64_t> (v1.mValue), vv2 = static_cast<std::uint64_t> (v2.mValue);
|
|
|
|
if (v1.mIsNegative)
|
|
vv1 = -vv1;
|
|
|
|
if (!v2.mIsNegative)
|
|
vv2 = -vv2;
|
|
|
|
if (ov1 < ov2)
|
|
{
|
|
while (ov1 < (ov2 - 1))
|
|
{
|
|
vv1 /= 10;
|
|
++ov1;
|
|
}
|
|
|
|
if (roundUp)
|
|
vv1 += 9;
|
|
|
|
vv1 /= 10;
|
|
++ov1;
|
|
}
|
|
|
|
if (ov2 < ov1)
|
|
{
|
|
while (ov2 < (ov1 - 1))
|
|
{
|
|
vv2 /= 10;
|
|
++ov2;
|
|
}
|
|
|
|
if (roundUp)
|
|
vv2 += 9;
|
|
|
|
vv2 /= 10;
|
|
++ov2;
|
|
}
|
|
|
|
std::int64_t fv = vv1 + vv2;
|
|
|
|
if ((fv >= -10) && (fv <= 10))
|
|
return STAmount (v1.getFName (), v1.mCurrency, v1.mIssuer);
|
|
else if (fv >= 0)
|
|
{
|
|
std::uint64_t v = static_cast<std::uint64_t> (fv);
|
|
canonicalizeRound (false, v, ov1, roundUp);
|
|
return STAmount (v1.getFName (), v1.mCurrency, v1.mIssuer, v, ov1, false);
|
|
}
|
|
else
|
|
{
|
|
std::uint64_t v = static_cast<std::uint64_t> (-fv);
|
|
canonicalizeRound (false, v, ov1, !roundUp);
|
|
return STAmount (v1.getFName (), v1.mCurrency, v1.mIssuer, v, ov1, true);
|
|
}
|
|
}
|
|
|
|
STAmount STAmount::mulRound (const STAmount& v1, const STAmount& v2,
|
|
const uint160& uCurrencyID, const uint160& uIssuerID, bool roundUp)
|
|
{
|
|
if (v1 == zero || v2 == zero)
|
|
return STAmount (uCurrencyID, uIssuerID);
|
|
|
|
if (v1.mIsNative && v2.mIsNative && uCurrencyID.isZero ())
|
|
{
|
|
std::uint64_t minV = (v1.getSNValue () < v2.getSNValue ()) ? v1.getSNValue () : v2.getSNValue ();
|
|
std::uint64_t maxV = (v1.getSNValue () < v2.getSNValue ()) ? v2.getSNValue () : v1.getSNValue ();
|
|
|
|
if (minV > 3000000000ull) // sqrt(cMaxNative)
|
|
throw std::runtime_error ("Native value overflow");
|
|
|
|
if (((maxV >> 32) * minV) > 2095475792ull) // cMaxNative / 2^32
|
|
throw std::runtime_error ("Native value overflow");
|
|
|
|
return STAmount (v1.getFName (), minV * maxV);
|
|
}
|
|
|
|
std::uint64_t value1 = v1.mValue, value2 = v2.mValue;
|
|
int offset1 = v1.mOffset, offset2 = v2.mOffset;
|
|
|
|
if (v1.mIsNative)
|
|
{
|
|
while (value1 < STAmount::cMinValue)
|
|
{
|
|
value1 *= 10;
|
|
--offset1;
|
|
}
|
|
}
|
|
|
|
if (v2.mIsNative)
|
|
{
|
|
while (value2 < STAmount::cMinValue)
|
|
{
|
|
value2 *= 10;
|
|
--offset2;
|
|
}
|
|
}
|
|
|
|
bool resultNegative = v1.mIsNegative != v2.mIsNegative;
|
|
// Compute (numerator * denominator) / 10^14 with rounding
|
|
// 10^16 <= result <= 10^18
|
|
CBigNum v;
|
|
|
|
if ((BN_add_word64 (&v, value1) != 1) || (BN_mul_word64 (&v, value2) != 1))
|
|
throw std::runtime_error ("internal bn error");
|
|
|
|
if (resultNegative != roundUp) // rounding down is automatic when we divide
|
|
BN_add_word64 (&v, tenTo14m1);
|
|
|
|
if (BN_div_word64 (&v, tenTo14) == ((std::uint64_t) - 1))
|
|
throw std::runtime_error ("internal bn error");
|
|
|
|
// 10^16 <= product <= 10^18
|
|
assert (BN_num_bytes (&v) <= 64);
|
|
|
|
std::uint64_t amount = v.getuint64 ();
|
|
int offset = offset1 + offset2 + 14;
|
|
canonicalizeRound (uCurrencyID.isZero (), amount, offset, resultNegative != roundUp);
|
|
return STAmount (uCurrencyID, uIssuerID, amount, offset, resultNegative);
|
|
}
|
|
|
|
STAmount STAmount::divRound (const STAmount& num, const STAmount& den,
|
|
const uint160& uCurrencyID, const uint160& uIssuerID, bool roundUp)
|
|
{
|
|
if (den == zero)
|
|
throw std::runtime_error ("division by zero");
|
|
|
|
if (num == zero)
|
|
return STAmount (uCurrencyID, uIssuerID);
|
|
|
|
std::uint64_t numVal = num.mValue, denVal = den.mValue;
|
|
int numOffset = num.mOffset, denOffset = den.mOffset;
|
|
|
|
if (num.mIsNative)
|
|
while (numVal < STAmount::cMinValue)
|
|
{
|
|
// Need to bring into range
|
|
numVal *= 10;
|
|
--numOffset;
|
|
}
|
|
|
|
if (den.mIsNative)
|
|
while (denVal < STAmount::cMinValue)
|
|
{
|
|
denVal *= 10;
|
|
--denOffset;
|
|
}
|
|
|
|
bool resultNegative = num.mIsNegative != den.mIsNegative;
|
|
// Compute (numerator * 10^17) / denominator
|
|
CBigNum v;
|
|
|
|
if ((BN_add_word64 (&v, numVal) != 1) || (BN_mul_word64 (&v, tenTo17) != 1))
|
|
throw std::runtime_error ("internal bn error");
|
|
|
|
if (resultNegative != roundUp) // Rounding down is automatic when we divide
|
|
BN_add_word64 (&v, denVal - 1);
|
|
|
|
if (BN_div_word64 (&v, denVal) == ((std::uint64_t) - 1))
|
|
throw std::runtime_error ("internal bn error");
|
|
|
|
// 10^16 <= quotient <= 10^18
|
|
assert (BN_num_bytes (&v) <= 64);
|
|
|
|
std::uint64_t amount = v.getuint64 ();
|
|
int offset = numOffset - denOffset - 17;
|
|
canonicalizeRound (uCurrencyID.isZero (), amount, offset, resultNegative != roundUp);
|
|
return STAmount (uCurrencyID, uIssuerID, amount, offset, resultNegative);
|
|
}
|
|
|
|
} // ripple
|