summaryrefslogtreecommitdiff
path: root/deps/node/deps/icu-small/source/i18n/number_decimalquantity.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'deps/node/deps/icu-small/source/i18n/number_decimalquantity.cpp')
-rw-r--r--deps/node/deps/icu-small/source/i18n/number_decimalquantity.cpp1207
1 files changed, 1207 insertions, 0 deletions
diff --git a/deps/node/deps/icu-small/source/i18n/number_decimalquantity.cpp b/deps/node/deps/icu-small/source/i18n/number_decimalquantity.cpp
new file mode 100644
index 00000000..2c4182b1
--- /dev/null
+++ b/deps/node/deps/icu-small/source/i18n/number_decimalquantity.cpp
@@ -0,0 +1,1207 @@
+// © 2017 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include <cstdlib>
+#include <cmath>
+#include <limits>
+#include <stdlib.h>
+
+#include "unicode/plurrule.h"
+#include "cmemory.h"
+#include "number_decnum.h"
+#include "putilimp.h"
+#include "number_decimalquantity.h"
+#include "number_roundingutils.h"
+#include "double-conversion.h"
+#include "charstr.h"
+#include "number_utils.h"
+#include "uassert.h"
+
+using namespace icu;
+using namespace icu::number;
+using namespace icu::number::impl;
+
+using icu::double_conversion::DoubleToStringConverter;
+using icu::double_conversion::StringToDoubleConverter;
+
+namespace {
+
+int8_t NEGATIVE_FLAG = 1;
+int8_t INFINITY_FLAG = 2;
+int8_t NAN_FLAG = 4;
+
+/** Helper function for safe subtraction (no overflow). */
+inline int32_t safeSubtract(int32_t a, int32_t b) {
+ // Note: In C++, signed integer subtraction is undefined behavior.
+ int32_t diff = static_cast<int32_t>(static_cast<uint32_t>(a) - static_cast<uint32_t>(b));
+ if (b < 0 && diff < a) { return INT32_MAX; }
+ if (b > 0 && diff > a) { return INT32_MIN; }
+ return diff;
+}
+
+static double DOUBLE_MULTIPLIERS[] = {
+ 1e0,
+ 1e1,
+ 1e2,
+ 1e3,
+ 1e4,
+ 1e5,
+ 1e6,
+ 1e7,
+ 1e8,
+ 1e9,
+ 1e10,
+ 1e11,
+ 1e12,
+ 1e13,
+ 1e14,
+ 1e15,
+ 1e16,
+ 1e17,
+ 1e18,
+ 1e19,
+ 1e20,
+ 1e21};
+
+} // namespace
+
+icu::IFixedDecimal::~IFixedDecimal() = default;
+
+DecimalQuantity::DecimalQuantity() {
+ setBcdToZero();
+ flags = 0;
+}
+
+DecimalQuantity::~DecimalQuantity() {
+ if (usingBytes) {
+ uprv_free(fBCD.bcdBytes.ptr);
+ fBCD.bcdBytes.ptr = nullptr;
+ usingBytes = false;
+ }
+}
+
+DecimalQuantity::DecimalQuantity(const DecimalQuantity &other) {
+ *this = other;
+}
+
+DecimalQuantity::DecimalQuantity(DecimalQuantity&& src) U_NOEXCEPT {
+ *this = std::move(src);
+}
+
+DecimalQuantity &DecimalQuantity::operator=(const DecimalQuantity &other) {
+ if (this == &other) {
+ return *this;
+ }
+ copyBcdFrom(other);
+ copyFieldsFrom(other);
+ return *this;
+}
+
+DecimalQuantity& DecimalQuantity::operator=(DecimalQuantity&& src) U_NOEXCEPT {
+ if (this == &src) {
+ return *this;
+ }
+ moveBcdFrom(src);
+ copyFieldsFrom(src);
+ return *this;
+}
+
+void DecimalQuantity::copyFieldsFrom(const DecimalQuantity& other) {
+ bogus = other.bogus;
+ lOptPos = other.lOptPos;
+ lReqPos = other.lReqPos;
+ rReqPos = other.rReqPos;
+ rOptPos = other.rOptPos;
+ scale = other.scale;
+ precision = other.precision;
+ flags = other.flags;
+ origDouble = other.origDouble;
+ origDelta = other.origDelta;
+ isApproximate = other.isApproximate;
+}
+
+void DecimalQuantity::clear() {
+ lOptPos = INT32_MAX;
+ lReqPos = 0;
+ rReqPos = 0;
+ rOptPos = INT32_MIN;
+ flags = 0;
+ setBcdToZero(); // sets scale, precision, hasDouble, origDouble, origDelta, and BCD data
+}
+
+void DecimalQuantity::setIntegerLength(int32_t minInt, int32_t maxInt) {
+ // Validation should happen outside of DecimalQuantity, e.g., in the Precision class.
+ U_ASSERT(minInt >= 0);
+ U_ASSERT(maxInt >= minInt);
+
+ // Special behavior: do not set minInt to be less than what is already set.
+ // This is so significant digits rounding can set the integer length.
+ if (minInt < lReqPos) {
+ minInt = lReqPos;
+ }
+
+ // Save values into internal state
+ // Negation is safe for minFrac/maxFrac because -Integer.MAX_VALUE > Integer.MIN_VALUE
+ lOptPos = maxInt;
+ lReqPos = minInt;
+}
+
+void DecimalQuantity::setFractionLength(int32_t minFrac, int32_t maxFrac) {
+ // Validation should happen outside of DecimalQuantity, e.g., in the Precision class.
+ U_ASSERT(minFrac >= 0);
+ U_ASSERT(maxFrac >= minFrac);
+
+ // Save values into internal state
+ // Negation is safe for minFrac/maxFrac because -Integer.MAX_VALUE > Integer.MIN_VALUE
+ rReqPos = -minFrac;
+ rOptPos = -maxFrac;
+}
+
+uint64_t DecimalQuantity::getPositionFingerprint() const {
+ uint64_t fingerprint = 0;
+ fingerprint ^= lOptPos;
+ fingerprint ^= (lReqPos << 16);
+ fingerprint ^= (static_cast<uint64_t>(rReqPos) << 32);
+ fingerprint ^= (static_cast<uint64_t>(rOptPos) << 48);
+ return fingerprint;
+}
+
+void DecimalQuantity::roundToIncrement(double roundingIncrement, RoundingMode roundingMode,
+ int32_t maxFrac, UErrorCode& status) {
+ // TODO(13701): This is innefficient. Improve?
+ // TODO(13701): Should we convert to decNumber instead?
+ roundToInfinity();
+ double temp = toDouble();
+ temp /= roundingIncrement;
+ // Use another DecimalQuantity to perform the actual rounding...
+ DecimalQuantity dq;
+ dq.setToDouble(temp);
+ dq.roundToMagnitude(0, roundingMode, status);
+ temp = dq.toDouble();
+ temp *= roundingIncrement;
+ setToDouble(temp);
+ // Since we reset the value to a double, we need to specify the rounding boundary
+ // in order to get the DecimalQuantity out of approximation mode.
+ // NOTE: In Java, we have minMaxFrac, but in C++, the two are differentiated.
+ roundToMagnitude(-maxFrac, roundingMode, status);
+}
+
+void DecimalQuantity::multiplyBy(const DecNum& multiplicand, UErrorCode& status) {
+ if (isInfinite() || isZero() || isNaN()) {
+ return;
+ }
+ // Convert to DecNum, multiply, and convert back.
+ DecNum decnum;
+ toDecNum(decnum, status);
+ if (U_FAILURE(status)) { return; }
+ decnum.multiplyBy(multiplicand, status);
+ if (U_FAILURE(status)) { return; }
+ setToDecNum(decnum, status);
+}
+
+void DecimalQuantity::divideBy(const DecNum& divisor, UErrorCode& status) {
+ if (isInfinite() || isZero() || isNaN()) {
+ return;
+ }
+ // Convert to DecNum, multiply, and convert back.
+ DecNum decnum;
+ toDecNum(decnum, status);
+ if (U_FAILURE(status)) { return; }
+ decnum.divideBy(divisor, status);
+ if (U_FAILURE(status)) { return; }
+ setToDecNum(decnum, status);
+}
+
+void DecimalQuantity::negate() {
+ flags ^= NEGATIVE_FLAG;
+}
+
+int32_t DecimalQuantity::getMagnitude() const {
+ U_ASSERT(precision != 0);
+ return scale + precision - 1;
+}
+
+bool DecimalQuantity::adjustMagnitude(int32_t delta) {
+ if (precision != 0) {
+ // i.e., scale += delta; origDelta += delta
+ bool overflow = uprv_add32_overflow(scale, delta, &scale);
+ overflow = uprv_add32_overflow(origDelta, delta, &origDelta) || overflow;
+ // Make sure that precision + scale won't overflow, either
+ int32_t dummy;
+ overflow = overflow || uprv_add32_overflow(scale, precision, &dummy);
+ return overflow;
+ }
+ return false;
+}
+
+double DecimalQuantity::getPluralOperand(PluralOperand operand) const {
+ // If this assertion fails, you need to call roundToInfinity() or some other rounding method.
+ // See the comment at the top of this file explaining the "isApproximate" field.
+ U_ASSERT(!isApproximate);
+
+ switch (operand) {
+ case PLURAL_OPERAND_I:
+ // Invert the negative sign if necessary
+ return static_cast<double>(isNegative() ? -toLong(true) : toLong(true));
+ case PLURAL_OPERAND_F:
+ return static_cast<double>(toFractionLong(true));
+ case PLURAL_OPERAND_T:
+ return static_cast<double>(toFractionLong(false));
+ case PLURAL_OPERAND_V:
+ return fractionCount();
+ case PLURAL_OPERAND_W:
+ return fractionCountWithoutTrailingZeros();
+ default:
+ return std::abs(toDouble());
+ }
+}
+
+bool DecimalQuantity::hasIntegerValue() const {
+ return scale >= 0;
+}
+
+int32_t DecimalQuantity::getUpperDisplayMagnitude() const {
+ // If this assertion fails, you need to call roundToInfinity() or some other rounding method.
+ // See the comment in the header file explaining the "isApproximate" field.
+ U_ASSERT(!isApproximate);
+
+ int32_t magnitude = scale + precision;
+ int32_t result = (lReqPos > magnitude) ? lReqPos : (lOptPos < magnitude) ? lOptPos : magnitude;
+ return result - 1;
+}
+
+int32_t DecimalQuantity::getLowerDisplayMagnitude() const {
+ // If this assertion fails, you need to call roundToInfinity() or some other rounding method.
+ // See the comment in the header file explaining the "isApproximate" field.
+ U_ASSERT(!isApproximate);
+
+ int32_t magnitude = scale;
+ int32_t result = (rReqPos < magnitude) ? rReqPos : (rOptPos > magnitude) ? rOptPos : magnitude;
+ return result;
+}
+
+int8_t DecimalQuantity::getDigit(int32_t magnitude) const {
+ // If this assertion fails, you need to call roundToInfinity() or some other rounding method.
+ // See the comment at the top of this file explaining the "isApproximate" field.
+ U_ASSERT(!isApproximate);
+
+ return getDigitPos(magnitude - scale);
+}
+
+int32_t DecimalQuantity::fractionCount() const {
+ return -getLowerDisplayMagnitude();
+}
+
+int32_t DecimalQuantity::fractionCountWithoutTrailingZeros() const {
+ return -scale > 0 ? -scale : 0; // max(-scale, 0)
+}
+
+bool DecimalQuantity::isNegative() const {
+ return (flags & NEGATIVE_FLAG) != 0;
+}
+
+int8_t DecimalQuantity::signum() const {
+ return isNegative() ? -1 : isZero() ? 0 : 1;
+}
+
+bool DecimalQuantity::isInfinite() const {
+ return (flags & INFINITY_FLAG) != 0;
+}
+
+bool DecimalQuantity::isNaN() const {
+ return (flags & NAN_FLAG) != 0;
+}
+
+bool DecimalQuantity::isZero() const {
+ return precision == 0;
+}
+
+DecimalQuantity &DecimalQuantity::setToInt(int32_t n) {
+ setBcdToZero();
+ flags = 0;
+ if (n == INT32_MIN) {
+ flags |= NEGATIVE_FLAG;
+ // leave as INT32_MIN; handled below in _setToInt()
+ } else if (n < 0) {
+ flags |= NEGATIVE_FLAG;
+ n = -n;
+ }
+ if (n != 0) {
+ _setToInt(n);
+ compact();
+ }
+ return *this;
+}
+
+void DecimalQuantity::_setToInt(int32_t n) {
+ if (n == INT32_MIN) {
+ readLongToBcd(-static_cast<int64_t>(n));
+ } else {
+ readIntToBcd(n);
+ }
+}
+
+DecimalQuantity &DecimalQuantity::setToLong(int64_t n) {
+ setBcdToZero();
+ flags = 0;
+ if (n < 0 && n > INT64_MIN) {
+ flags |= NEGATIVE_FLAG;
+ n = -n;
+ }
+ if (n != 0) {
+ _setToLong(n);
+ compact();
+ }
+ return *this;
+}
+
+void DecimalQuantity::_setToLong(int64_t n) {
+ if (n == INT64_MIN) {
+ DecNum decnum;
+ UErrorCode localStatus = U_ZERO_ERROR;
+ decnum.setTo("9.223372036854775808E+18", localStatus);
+ if (U_FAILURE(localStatus)) { return; } // unexpected
+ flags |= NEGATIVE_FLAG;
+ readDecNumberToBcd(decnum);
+ } else if (n <= INT32_MAX) {
+ readIntToBcd(static_cast<int32_t>(n));
+ } else {
+ readLongToBcd(n);
+ }
+}
+
+DecimalQuantity &DecimalQuantity::setToDouble(double n) {
+ setBcdToZero();
+ flags = 0;
+ // signbit() from <math.h> handles +0.0 vs -0.0
+ if (std::signbit(n)) {
+ flags |= NEGATIVE_FLAG;
+ n = -n;
+ }
+ if (std::isnan(n) != 0) {
+ flags |= NAN_FLAG;
+ } else if (std::isfinite(n) == 0) {
+ flags |= INFINITY_FLAG;
+ } else if (n != 0) {
+ _setToDoubleFast(n);
+ compact();
+ }
+ return *this;
+}
+
+void DecimalQuantity::_setToDoubleFast(double n) {
+ isApproximate = true;
+ origDouble = n;
+ origDelta = 0;
+
+ // Make sure the double is an IEEE 754 double. If not, fall back to the slow path right now.
+ // TODO: Make a fast path for other types of doubles.
+ if (!std::numeric_limits<double>::is_iec559) {
+ convertToAccurateDouble();
+ // Turn off the approximate double flag, since the value is now exact.
+ isApproximate = false;
+ origDouble = 0.0;
+ return;
+ }
+
+ // To get the bits from the double, use memcpy, which takes care of endianness.
+ uint64_t ieeeBits;
+ uprv_memcpy(&ieeeBits, &n, sizeof(n));
+ int32_t exponent = static_cast<int32_t>((ieeeBits & 0x7ff0000000000000L) >> 52) - 0x3ff;
+
+ // Not all integers can be represented exactly for exponent > 52
+ if (exponent <= 52 && static_cast<int64_t>(n) == n) {
+ _setToLong(static_cast<int64_t>(n));
+ return;
+ }
+
+ // 3.3219... is log2(10)
+ auto fracLength = static_cast<int32_t> ((52 - exponent) / 3.32192809489);
+ if (fracLength >= 0) {
+ int32_t i = fracLength;
+ // 1e22 is the largest exact double.
+ for (; i >= 22; i -= 22) n *= 1e22;
+ n *= DOUBLE_MULTIPLIERS[i];
+ } else {
+ int32_t i = fracLength;
+ // 1e22 is the largest exact double.
+ for (; i <= -22; i += 22) n /= 1e22;
+ n /= DOUBLE_MULTIPLIERS[-i];
+ }
+ auto result = static_cast<int64_t>(std::round(n));
+ if (result != 0) {
+ _setToLong(result);
+ scale -= fracLength;
+ }
+}
+
+void DecimalQuantity::convertToAccurateDouble() {
+ U_ASSERT(origDouble != 0);
+ int32_t delta = origDelta;
+
+ // Call the slow oracle function (Double.toString in Java, DoubleToAscii in C++).
+ char buffer[DoubleToStringConverter::kBase10MaximalLength + 1];
+ bool sign; // unused; always positive
+ int32_t length;
+ int32_t point;
+ DoubleToStringConverter::DoubleToAscii(
+ origDouble,
+ DoubleToStringConverter::DtoaMode::SHORTEST,
+ 0,
+ buffer,
+ sizeof(buffer),
+ &sign,
+ &length,
+ &point
+ );
+
+ setBcdToZero();
+ readDoubleConversionToBcd(buffer, length, point);
+ scale += delta;
+ explicitExactDouble = true;
+}
+
+DecimalQuantity &DecimalQuantity::setToDecNumber(StringPiece n, UErrorCode& status) {
+ setBcdToZero();
+ flags = 0;
+
+ // Compute the decNumber representation
+ DecNum decnum;
+ decnum.setTo(n, status);
+
+ _setToDecNum(decnum, status);
+ return *this;
+}
+
+DecimalQuantity& DecimalQuantity::setToDecNum(const DecNum& decnum, UErrorCode& status) {
+ setBcdToZero();
+ flags = 0;
+
+ _setToDecNum(decnum, status);
+ return *this;
+}
+
+void DecimalQuantity::_setToDecNum(const DecNum& decnum, UErrorCode& status) {
+ if (U_FAILURE(status)) { return; }
+ if (decnum.isNegative()) {
+ flags |= NEGATIVE_FLAG;
+ }
+ if (!decnum.isZero()) {
+ readDecNumberToBcd(decnum);
+ compact();
+ }
+}
+
+int64_t DecimalQuantity::toLong(bool truncateIfOverflow) const {
+ // NOTE: Call sites should be guarded by fitsInLong(), like this:
+ // if (dq.fitsInLong()) { /* use dq.toLong() */ } else { /* use some fallback */ }
+ // Fallback behavior upon truncateIfOverflow is to truncate at 17 digits.
+ uint64_t result = 0L;
+ int32_t upperMagnitude = std::min(scale + precision, lOptPos) - 1;
+ if (truncateIfOverflow) {
+ upperMagnitude = std::min(upperMagnitude, 17);
+ }
+ for (int32_t magnitude = upperMagnitude; magnitude >= 0; magnitude--) {
+ result = result * 10 + getDigitPos(magnitude - scale);
+ }
+ if (isNegative()) {
+ return static_cast<int64_t>(0LL - result); // i.e., -result
+ }
+ return static_cast<int64_t>(result);
+}
+
+uint64_t DecimalQuantity::toFractionLong(bool includeTrailingZeros) const {
+ uint64_t result = 0L;
+ int32_t magnitude = -1;
+ int32_t lowerMagnitude = std::max(scale, rOptPos);
+ if (includeTrailingZeros) {
+ lowerMagnitude = std::min(lowerMagnitude, rReqPos);
+ }
+ for (; magnitude >= lowerMagnitude && result <= 1e18L; magnitude--) {
+ result = result * 10 + getDigitPos(magnitude - scale);
+ }
+ // Remove trailing zeros; this can happen during integer overflow cases.
+ if (!includeTrailingZeros) {
+ while (result > 0 && (result % 10) == 0) {
+ result /= 10;
+ }
+ }
+ return result;
+}
+
+bool DecimalQuantity::fitsInLong(bool ignoreFraction) const {
+ if (isZero()) {
+ return true;
+ }
+ if (scale < 0 && !ignoreFraction) {
+ return false;
+ }
+ int magnitude = getMagnitude();
+ if (magnitude < 18) {
+ return true;
+ }
+ if (magnitude > 18) {
+ return false;
+ }
+ // Hard case: the magnitude is 10^18.
+ // The largest int64 is: 9,223,372,036,854,775,807
+ for (int p = 0; p < precision; p++) {
+ int8_t digit = getDigit(18 - p);
+ static int8_t INT64_BCD[] = { 9, 2, 2, 3, 3, 7, 2, 0, 3, 6, 8, 5, 4, 7, 7, 5, 8, 0, 8 };
+ if (digit < INT64_BCD[p]) {
+ return true;
+ } else if (digit > INT64_BCD[p]) {
+ return false;
+ }
+ }
+ // Exactly equal to max long plus one.
+ return isNegative();
+}
+
+double DecimalQuantity::toDouble() const {
+ // If this assertion fails, you need to call roundToInfinity() or some other rounding method.
+ // See the comment in the header file explaining the "isApproximate" field.
+ U_ASSERT(!isApproximate);
+
+ if (isNaN()) {
+ return NAN;
+ } else if (isInfinite()) {
+ return isNegative() ? -INFINITY : INFINITY;
+ }
+
+ // We are processing well-formed input, so we don't need any special options to StringToDoubleConverter.
+ StringToDoubleConverter converter(0, 0, 0, "", "");
+ UnicodeString numberString = this->toScientificString();
+ int32_t count;
+ return converter.StringToDouble(
+ reinterpret_cast<const uint16_t*>(numberString.getBuffer()),
+ numberString.length(),
+ &count);
+}
+
+void DecimalQuantity::toDecNum(DecNum& output, UErrorCode& status) const {
+ // Special handling for zero
+ if (precision == 0) {
+ output.setTo("0", status);
+ }
+
+ // Use the BCD constructor. We need to do a little bit of work to convert, though.
+ // The decNumber constructor expects most-significant first, but we store least-significant first.
+ MaybeStackArray<uint8_t, 20> ubcd(precision);
+ for (int32_t m = 0; m < precision; m++) {
+ ubcd[precision - m - 1] = static_cast<uint8_t>(getDigitPos(m));
+ }
+ output.setTo(ubcd.getAlias(), precision, scale, isNegative(), status);
+}
+
+void DecimalQuantity::truncate() {
+ if (scale < 0) {
+ shiftRight(-scale);
+ scale = 0;
+ compact();
+ }
+}
+
+void DecimalQuantity::roundToMagnitude(int32_t magnitude, RoundingMode roundingMode, UErrorCode& status) {
+ // The position in the BCD at which rounding will be performed; digits to the right of position
+ // will be rounded away.
+ // TODO: Andy: There was a test failure because of integer overflow here. Should I do
+ // "safe subtraction" everywhere in the code? What's the nicest way to do it?
+ int position = safeSubtract(magnitude, scale);
+
+ if (position <= 0 && !isApproximate) {
+ // All digits are to the left of the rounding magnitude.
+ } else if (precision == 0) {
+ // No rounding for zero.
+ } else {
+ // Perform rounding logic.
+ // "leading" = most significant digit to the right of rounding
+ // "trailing" = least significant digit to the left of rounding
+ int8_t leadingDigit = getDigitPos(safeSubtract(position, 1));
+ int8_t trailingDigit = getDigitPos(position);
+
+ // Compute which section of the number we are in.
+ // EDGE means we are at the bottom or top edge, like 1.000 or 1.999 (used by doubles)
+ // LOWER means we are between the bottom edge and the midpoint, like 1.391
+ // MIDPOINT means we are exactly in the middle, like 1.500
+ // UPPER means we are between the midpoint and the top edge, like 1.916
+ roundingutils::Section section = roundingutils::SECTION_MIDPOINT;
+ if (!isApproximate) {
+ if (leadingDigit < 5) {
+ section = roundingutils::SECTION_LOWER;
+ } else if (leadingDigit > 5) {
+ section = roundingutils::SECTION_UPPER;
+ } else {
+ for (int p = safeSubtract(position, 2); p >= 0; p--) {
+ if (getDigitPos(p) != 0) {
+ section = roundingutils::SECTION_UPPER;
+ break;
+ }
+ }
+ }
+ } else {
+ int32_t p = safeSubtract(position, 2);
+ int32_t minP = uprv_max(0, precision - 14);
+ if (leadingDigit == 0) {
+ section = roundingutils::SECTION_LOWER_EDGE;
+ for (; p >= minP; p--) {
+ if (getDigitPos(p) != 0) {
+ section = roundingutils::SECTION_LOWER;
+ break;
+ }
+ }
+ } else if (leadingDigit == 4) {
+ for (; p >= minP; p--) {
+ if (getDigitPos(p) != 9) {
+ section = roundingutils::SECTION_LOWER;
+ break;
+ }
+ }
+ } else if (leadingDigit == 5) {
+ for (; p >= minP; p--) {
+ if (getDigitPos(p) != 0) {
+ section = roundingutils::SECTION_UPPER;
+ break;
+ }
+ }
+ } else if (leadingDigit == 9) {
+ section = roundingutils::SECTION_UPPER_EDGE;
+ for (; p >= minP; p--) {
+ if (getDigitPos(p) != 9) {
+ section = roundingutils::SECTION_UPPER;
+ break;
+ }
+ }
+ } else if (leadingDigit < 5) {
+ section = roundingutils::SECTION_LOWER;
+ } else {
+ section = roundingutils::SECTION_UPPER;
+ }
+
+ bool roundsAtMidpoint = roundingutils::roundsAtMidpoint(roundingMode);
+ if (safeSubtract(position, 1) < precision - 14 ||
+ (roundsAtMidpoint && section == roundingutils::SECTION_MIDPOINT) ||
+ (!roundsAtMidpoint && section < 0 /* i.e. at upper or lower edge */)) {
+ // Oops! This means that we have to get the exact representation of the double, because
+ // the zone of uncertainty is along the rounding boundary.
+ convertToAccurateDouble();
+ roundToMagnitude(magnitude, roundingMode, status); // start over
+ return;
+ }
+
+ // Turn off the approximate double flag, since the value is now confirmed to be exact.
+ isApproximate = false;
+ origDouble = 0.0;
+ origDelta = 0;
+
+ if (position <= 0) {
+ // All digits are to the left of the rounding magnitude.
+ return;
+ }
+
+ // Good to continue rounding.
+ if (section == -1) { section = roundingutils::SECTION_LOWER; }
+ if (section == -2) { section = roundingutils::SECTION_UPPER; }
+ }
+
+ bool roundDown = roundingutils::getRoundingDirection((trailingDigit % 2) == 0,
+ isNegative(),
+ section,
+ roundingMode,
+ status);
+ if (U_FAILURE(status)) {
+ return;
+ }
+
+ // Perform truncation
+ if (position >= precision) {
+ setBcdToZero();
+ scale = magnitude;
+ } else {
+ shiftRight(position);
+ }
+
+ // Bubble the result to the higher digits
+ if (!roundDown) {
+ if (trailingDigit == 9) {
+ int bubblePos = 0;
+ // Note: in the long implementation, the most digits BCD can have at this point is 15,
+ // so bubblePos <= 15 and getDigitPos(bubblePos) is safe.
+ for (; getDigitPos(bubblePos) == 9; bubblePos++) {}
+ shiftRight(bubblePos); // shift off the trailing 9s
+ }
+ int8_t digit0 = getDigitPos(0);
+ U_ASSERT(digit0 != 9);
+ setDigitPos(0, static_cast<int8_t>(digit0 + 1));
+ precision += 1; // in case an extra digit got added
+ }
+
+ compact();
+ }
+}
+
+void DecimalQuantity::roundToInfinity() {
+ if (isApproximate) {
+ convertToAccurateDouble();
+ }
+}
+
+void DecimalQuantity::appendDigit(int8_t value, int32_t leadingZeros, bool appendAsInteger) {
+ U_ASSERT(leadingZeros >= 0);
+
+ // Zero requires special handling to maintain the invariant that the least-significant digit
+ // in the BCD is nonzero.
+ if (value == 0) {
+ if (appendAsInteger && precision != 0) {
+ scale += leadingZeros + 1;
+ }
+ return;
+ }
+
+ // Deal with trailing zeros
+ if (scale > 0) {
+ leadingZeros += scale;
+ if (appendAsInteger) {
+ scale = 0;
+ }
+ }
+
+ // Append digit
+ shiftLeft(leadingZeros + 1);
+ setDigitPos(0, value);
+
+ // Fix scale if in integer mode
+ if (appendAsInteger) {
+ scale += leadingZeros + 1;
+ }
+}
+
+UnicodeString DecimalQuantity::toPlainString() const {
+ U_ASSERT(!isApproximate);
+ UnicodeString sb;
+ if (isNegative()) {
+ sb.append(u'-');
+ }
+ if (precision == 0 || getMagnitude() < 0) {
+ sb.append(u'0');
+ }
+ for (int m = getUpperDisplayMagnitude(); m >= getLowerDisplayMagnitude(); m--) {
+ if (m == -1) { sb.append(u'.'); }
+ sb.append(getDigit(m) + u'0');
+ }
+ return sb;
+}
+
+UnicodeString DecimalQuantity::toScientificString() const {
+ U_ASSERT(!isApproximate);
+ UnicodeString result;
+ if (isNegative()) {
+ result.append(u'-');
+ }
+ if (precision == 0) {
+ result.append(u"0E+0", -1);
+ return result;
+ }
+ // NOTE: It is not safe to add to lOptPos (aka maxInt) or subtract from
+ // rOptPos (aka -maxFrac) due to overflow.
+ int32_t upperPos = std::min(precision + scale, lOptPos) - scale - 1;
+ int32_t lowerPos = std::max(scale, rOptPos) - scale;
+ int32_t p = upperPos;
+ result.append(u'0' + getDigitPos(p));
+ if ((--p) >= lowerPos) {
+ result.append(u'.');
+ for (; p >= lowerPos; p--) {
+ result.append(u'0' + getDigitPos(p));
+ }
+ }
+ result.append(u'E');
+ int32_t _scale = upperPos + scale;
+ if (_scale < 0) {
+ _scale *= -1;
+ result.append(u'-');
+ } else {
+ result.append(u'+');
+ }
+ if (_scale == 0) {
+ result.append(u'0');
+ }
+ int32_t insertIndex = result.length();
+ while (_scale > 0) {
+ std::div_t res = std::div(_scale, 10);
+ result.insert(insertIndex, u'0' + res.rem);
+ _scale = res.quot;
+ }
+ return result;
+}
+
+////////////////////////////////////////////////////
+/// End of DecimalQuantity_AbstractBCD.java ///
+/// Start of DecimalQuantity_DualStorageBCD.java ///
+////////////////////////////////////////////////////
+
+int8_t DecimalQuantity::getDigitPos(int32_t position) const {
+ if (usingBytes) {
+ if (position < 0 || position >= precision) { return 0; }
+ return fBCD.bcdBytes.ptr[position];
+ } else {
+ if (position < 0 || position >= 16) { return 0; }
+ return (int8_t) ((fBCD.bcdLong >> (position * 4)) & 0xf);
+ }
+}
+
+void DecimalQuantity::setDigitPos(int32_t position, int8_t value) {
+ U_ASSERT(position >= 0);
+ if (usingBytes) {
+ ensureCapacity(position + 1);
+ fBCD.bcdBytes.ptr[position] = value;
+ } else if (position >= 16) {
+ switchStorage();
+ ensureCapacity(position + 1);
+ fBCD.bcdBytes.ptr[position] = value;
+ } else {
+ int shift = position * 4;
+ fBCD.bcdLong = (fBCD.bcdLong & ~(0xfL << shift)) | ((long) value << shift);
+ }
+}
+
+void DecimalQuantity::shiftLeft(int32_t numDigits) {
+ if (!usingBytes && precision + numDigits > 16) {
+ switchStorage();
+ }
+ if (usingBytes) {
+ ensureCapacity(precision + numDigits);
+ int i = precision + numDigits - 1;
+ for (; i >= numDigits; i--) {
+ fBCD.bcdBytes.ptr[i] = fBCD.bcdBytes.ptr[i - numDigits];
+ }
+ for (; i >= 0; i--) {
+ fBCD.bcdBytes.ptr[i] = 0;
+ }
+ } else {
+ fBCD.bcdLong <<= (numDigits * 4);
+ }
+ scale -= numDigits;
+ precision += numDigits;
+}
+
+void DecimalQuantity::shiftRight(int32_t numDigits) {
+ if (usingBytes) {
+ int i = 0;
+ for (; i < precision - numDigits; i++) {
+ fBCD.bcdBytes.ptr[i] = fBCD.bcdBytes.ptr[i + numDigits];
+ }
+ for (; i < precision; i++) {
+ fBCD.bcdBytes.ptr[i] = 0;
+ }
+ } else {
+ fBCD.bcdLong >>= (numDigits * 4);
+ }
+ scale += numDigits;
+ precision -= numDigits;
+}
+
+void DecimalQuantity::setBcdToZero() {
+ if (usingBytes) {
+ uprv_free(fBCD.bcdBytes.ptr);
+ fBCD.bcdBytes.ptr = nullptr;
+ usingBytes = false;
+ }
+ fBCD.bcdLong = 0L;
+ scale = 0;
+ precision = 0;
+ isApproximate = false;
+ origDouble = 0;
+ origDelta = 0;
+}
+
+void DecimalQuantity::readIntToBcd(int32_t n) {
+ U_ASSERT(n != 0);
+ // ints always fit inside the long implementation.
+ uint64_t result = 0L;
+ int i = 16;
+ for (; n != 0; n /= 10, i--) {
+ result = (result >> 4) + ((static_cast<uint64_t>(n) % 10) << 60);
+ }
+ U_ASSERT(!usingBytes);
+ fBCD.bcdLong = result >> (i * 4);
+ scale = 0;
+ precision = 16 - i;
+}
+
+void DecimalQuantity::readLongToBcd(int64_t n) {
+ U_ASSERT(n != 0);
+ if (n >= 10000000000000000L) {
+ ensureCapacity();
+ int i = 0;
+ for (; n != 0L; n /= 10L, i++) {
+ fBCD.bcdBytes.ptr[i] = static_cast<int8_t>(n % 10);
+ }
+ U_ASSERT(usingBytes);
+ scale = 0;
+ precision = i;
+ } else {
+ uint64_t result = 0L;
+ int i = 16;
+ for (; n != 0L; n /= 10L, i--) {
+ result = (result >> 4) + ((n % 10) << 60);
+ }
+ U_ASSERT(i >= 0);
+ U_ASSERT(!usingBytes);
+ fBCD.bcdLong = result >> (i * 4);
+ scale = 0;
+ precision = 16 - i;
+ }
+}
+
+void DecimalQuantity::readDecNumberToBcd(const DecNum& decnum) {
+ const decNumber* dn = decnum.getRawDecNumber();
+ if (dn->digits > 16) {
+ ensureCapacity(dn->digits);
+ for (int32_t i = 0; i < dn->digits; i++) {
+ fBCD.bcdBytes.ptr[i] = dn->lsu[i];
+ }
+ } else {
+ uint64_t result = 0L;
+ for (int32_t i = 0; i < dn->digits; i++) {
+ result |= static_cast<uint64_t>(dn->lsu[i]) << (4 * i);
+ }
+ fBCD.bcdLong = result;
+ }
+ scale = dn->exponent;
+ precision = dn->digits;
+}
+
+void DecimalQuantity::readDoubleConversionToBcd(
+ const char* buffer, int32_t length, int32_t point) {
+ // NOTE: Despite the fact that double-conversion's API is called
+ // "DoubleToAscii", they actually use '0' (as opposed to u8'0').
+ if (length > 16) {
+ ensureCapacity(length);
+ for (int32_t i = 0; i < length; i++) {
+ fBCD.bcdBytes.ptr[i] = buffer[length-i-1] - '0';
+ }
+ } else {
+ uint64_t result = 0L;
+ for (int32_t i = 0; i < length; i++) {
+ result |= static_cast<uint64_t>(buffer[length-i-1] - '0') << (4 * i);
+ }
+ fBCD.bcdLong = result;
+ }
+ scale = point - length;
+ precision = length;
+}
+
+void DecimalQuantity::compact() {
+ if (usingBytes) {
+ int32_t delta = 0;
+ for (; delta < precision && fBCD.bcdBytes.ptr[delta] == 0; delta++);
+ if (delta == precision) {
+ // Number is zero
+ setBcdToZero();
+ return;
+ } else {
+ // Remove trailing zeros
+ shiftRight(delta);
+ }
+
+ // Compute precision
+ int32_t leading = precision - 1;
+ for (; leading >= 0 && fBCD.bcdBytes.ptr[leading] == 0; leading--);
+ precision = leading + 1;
+
+ // Switch storage mechanism if possible
+ if (precision <= 16) {
+ switchStorage();
+ }
+
+ } else {
+ if (fBCD.bcdLong == 0L) {
+ // Number is zero
+ setBcdToZero();
+ return;
+ }
+
+ // Compact the number (remove trailing zeros)
+ // TODO: Use a more efficient algorithm here and below. There is a logarithmic one.
+ int32_t delta = 0;
+ for (; delta < precision && getDigitPos(delta) == 0; delta++);
+ fBCD.bcdLong >>= delta * 4;
+ scale += delta;
+
+ // Compute precision
+ int32_t leading = precision - 1;
+ for (; leading >= 0 && getDigitPos(leading) == 0; leading--);
+ precision = leading + 1;
+ }
+}
+
+void DecimalQuantity::ensureCapacity() {
+ ensureCapacity(40);
+}
+
+void DecimalQuantity::ensureCapacity(int32_t capacity) {
+ if (capacity == 0) { return; }
+ int32_t oldCapacity = usingBytes ? fBCD.bcdBytes.len : 0;
+ if (!usingBytes) {
+ // TODO: There is nothing being done to check for memory allocation failures.
+ // TODO: Consider indexing by nybbles instead of bytes in C++, so that we can
+ // make these arrays half the size.
+ fBCD.bcdBytes.ptr = static_cast<int8_t*>(uprv_malloc(capacity * sizeof(int8_t)));
+ fBCD.bcdBytes.len = capacity;
+ // Initialize the byte array to zeros (this is done automatically in Java)
+ uprv_memset(fBCD.bcdBytes.ptr, 0, capacity * sizeof(int8_t));
+ } else if (oldCapacity < capacity) {
+ auto bcd1 = static_cast<int8_t*>(uprv_malloc(capacity * 2 * sizeof(int8_t)));
+ uprv_memcpy(bcd1, fBCD.bcdBytes.ptr, oldCapacity * sizeof(int8_t));
+ // Initialize the rest of the byte array to zeros (this is done automatically in Java)
+ uprv_memset(bcd1 + oldCapacity, 0, (capacity - oldCapacity) * sizeof(int8_t));
+ uprv_free(fBCD.bcdBytes.ptr);
+ fBCD.bcdBytes.ptr = bcd1;
+ fBCD.bcdBytes.len = capacity * 2;
+ }
+ usingBytes = true;
+}
+
+void DecimalQuantity::switchStorage() {
+ if (usingBytes) {
+ // Change from bytes to long
+ uint64_t bcdLong = 0L;
+ for (int i = precision - 1; i >= 0; i--) {
+ bcdLong <<= 4;
+ bcdLong |= fBCD.bcdBytes.ptr[i];
+ }
+ uprv_free(fBCD.bcdBytes.ptr);
+ fBCD.bcdBytes.ptr = nullptr;
+ fBCD.bcdLong = bcdLong;
+ usingBytes = false;
+ } else {
+ // Change from long to bytes
+ // Copy the long into a local variable since it will get munged when we allocate the bytes
+ uint64_t bcdLong = fBCD.bcdLong;
+ ensureCapacity();
+ for (int i = 0; i < precision; i++) {
+ fBCD.bcdBytes.ptr[i] = static_cast<int8_t>(bcdLong & 0xf);
+ bcdLong >>= 4;
+ }
+ U_ASSERT(usingBytes);
+ }
+}
+
+void DecimalQuantity::copyBcdFrom(const DecimalQuantity &other) {
+ setBcdToZero();
+ if (other.usingBytes) {
+ ensureCapacity(other.precision);
+ uprv_memcpy(fBCD.bcdBytes.ptr, other.fBCD.bcdBytes.ptr, other.precision * sizeof(int8_t));
+ } else {
+ fBCD.bcdLong = other.fBCD.bcdLong;
+ }
+}
+
+void DecimalQuantity::moveBcdFrom(DecimalQuantity &other) {
+ setBcdToZero();
+ if (other.usingBytes) {
+ usingBytes = true;
+ fBCD.bcdBytes.ptr = other.fBCD.bcdBytes.ptr;
+ fBCD.bcdBytes.len = other.fBCD.bcdBytes.len;
+ // Take ownership away from the old instance:
+ other.fBCD.bcdBytes.ptr = nullptr;
+ other.usingBytes = false;
+ } else {
+ fBCD.bcdLong = other.fBCD.bcdLong;
+ }
+}
+
+const char16_t* DecimalQuantity::checkHealth() const {
+ if (usingBytes) {
+ if (precision == 0) { return u"Zero precision but we are in byte mode"; }
+ int32_t capacity = fBCD.bcdBytes.len;
+ if (precision > capacity) { return u"Precision exceeds length of byte array"; }
+ if (getDigitPos(precision - 1) == 0) { return u"Most significant digit is zero in byte mode"; }
+ if (getDigitPos(0) == 0) { return u"Least significant digit is zero in long mode"; }
+ for (int i = 0; i < precision; i++) {
+ if (getDigitPos(i) >= 10) { return u"Digit exceeding 10 in byte array"; }
+ if (getDigitPos(i) < 0) { return u"Digit below 0 in byte array"; }
+ }
+ for (int i = precision; i < capacity; i++) {
+ if (getDigitPos(i) != 0) { return u"Nonzero digits outside of range in byte array"; }
+ }
+ } else {
+ if (precision == 0 && fBCD.bcdLong != 0) {
+ return u"Value in bcdLong even though precision is zero";
+ }
+ if (precision > 16) { return u"Precision exceeds length of long"; }
+ if (precision != 0 && getDigitPos(precision - 1) == 0) {
+ return u"Most significant digit is zero in long mode";
+ }
+ if (precision != 0 && getDigitPos(0) == 0) {
+ return u"Least significant digit is zero in long mode";
+ }
+ for (int i = 0; i < precision; i++) {
+ if (getDigitPos(i) >= 10) { return u"Digit exceeding 10 in long"; }
+ if (getDigitPos(i) < 0) { return u"Digit below 0 in long (?!)"; }
+ }
+ for (int i = precision; i < 16; i++) {
+ if (getDigitPos(i) != 0) { return u"Nonzero digits outside of range in long"; }
+ }
+ }
+
+ // No error
+ return nullptr;
+}
+
+bool DecimalQuantity::operator==(const DecimalQuantity& other) const {
+ bool basicEquals =
+ scale == other.scale
+ && precision == other.precision
+ && flags == other.flags
+ && lOptPos == other.lOptPos
+ && lReqPos == other.lReqPos
+ && rReqPos == other.rReqPos
+ && rOptPos == other.rOptPos
+ && isApproximate == other.isApproximate;
+ if (!basicEquals) {
+ return false;
+ }
+
+ if (precision == 0) {
+ return true;
+ } else if (isApproximate) {
+ return origDouble == other.origDouble && origDelta == other.origDelta;
+ } else {
+ for (int m = getUpperDisplayMagnitude(); m >= getLowerDisplayMagnitude(); m--) {
+ if (getDigit(m) != other.getDigit(m)) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
+
+UnicodeString DecimalQuantity::toString() const {
+ MaybeStackArray<char, 30> digits(precision + 1);
+ for (int32_t i = 0; i < precision; i++) {
+ digits[i] = getDigitPos(precision - i - 1) + '0';
+ }
+ digits[precision] = 0; // terminate buffer
+ char buffer8[100];
+ snprintf(
+ buffer8,
+ sizeof(buffer8),
+ "<DecimalQuantity %d:%d:%d:%d %s %s%s%s%d>",
+ (lOptPos > 999 ? 999 : lOptPos),
+ lReqPos,
+ rReqPos,
+ (rOptPos < -999 ? -999 : rOptPos),
+ (usingBytes ? "bytes" : "long"),
+ (isNegative() ? "-" : ""),
+ (precision == 0 ? "0" : digits.getAlias()),
+ "E",
+ scale);
+ return UnicodeString(buffer8, -1, US_INV);
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-02 17:51:58 +0000