Restoring authorship annotation for <mcheshkov@yandex-team.ru>. Commit 2 of 2.

1 files changed, 1347 insertions, 1347 deletions

diff --git a/contrib/libs/icu/i18n/number_decimalquantity.cpp b/contrib/libs/icu/i18n/number_decimalquantity.cpp
index 669ec7d556..482e93dc7a 100644
--- a/contrib/libs/icu/i18n/number_decimalquantity.cpp
+++ b/contrib/libs/icu/i18n/number_decimalquantity.cpp
@@ -1,1347 +1,1347 @@
-// © 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; 
-    lReqPos = other.lReqPos; 
-    rReqPos = other.rReqPos; 
-    scale = other.scale; 
-    precision = other.precision; 
-    flags = other.flags; 
-    origDouble = other.origDouble; 
-    origDelta = other.origDelta; 
-    isApproximate = other.isApproximate; 
-    exponent = other.exponent; 
-} 
- 
-void DecimalQuantity::clear() { 
-    lReqPos = 0; 
-    rReqPos = 0; 
-    flags = 0; 
-    setBcdToZero(); // sets scale, precision, hasDouble, origDouble, origDelta, and BCD data 
-} 
- 
-void DecimalQuantity::setMinInteger(int32_t minInt) { 
-    // Validation should happen outside of DecimalQuantity, e.g., in the Precision class. 
-    U_ASSERT(minInt >= 0); 
- 
-    // 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 
-    lReqPos = minInt; 
-} 
- 
-void DecimalQuantity::setMinFraction(int32_t minFrac) { 
-    // Validation should happen outside of DecimalQuantity, e.g., in the Precision class. 
-    U_ASSERT(minFrac >= 0); 
- 
-    // Save values into internal state 
-    // Negation is safe for minFrac/maxFrac because -Integer.MAX_VALUE > Integer.MIN_VALUE 
-    rReqPos = -minFrac; 
-} 
- 
-void DecimalQuantity::applyMaxInteger(int32_t maxInt) { 
-    // Validation should happen outside of DecimalQuantity, e.g., in the Precision class. 
-    U_ASSERT(maxInt >= 0); 
- 
-    if (precision == 0) { 
-        return; 
-    } 
- 
-    if (maxInt <= scale) { 
-        setBcdToZero(); 
-        return; 
-    } 
- 
-    int32_t magnitude = getMagnitude(); 
-    if (maxInt <= magnitude) { 
-        popFromLeft(magnitude - maxInt + 1); 
-        compact(); 
-    } 
-} 
- 
-uint64_t DecimalQuantity::getPositionFingerprint() const { 
-    uint64_t fingerprint = 0; 
-    fingerprint ^= (lReqPos << 16); 
-    fingerprint ^= (static_cast<uint64_t>(rReqPos) << 32); 
-    return fingerprint; 
-} 
- 
-void DecimalQuantity::roundToIncrement(double roundingIncrement, RoundingMode roundingMode, 
-                                       UErrorCode& status) { 
-    // Do not call this method with an increment having only a 1 or a 5 digit! 
-    // Use a more efficient call to either roundToMagnitude() or roundToNickel(). 
-    // Check a few popular rounding increments; a more thorough check is in Java. 
-    U_ASSERT(roundingIncrement != 0.01); 
-    U_ASSERT(roundingIncrement != 0.05); 
-    U_ASSERT(roundingIncrement != 0.1); 
-    U_ASSERT(roundingIncrement != 0.5); 
-    U_ASSERT(roundingIncrement != 1); 
-    U_ASSERT(roundingIncrement != 5); 
- 
-    DecNum incrementDN; 
-    incrementDN.setTo(roundingIncrement, status); 
-    if (U_FAILURE(status)) { return; } 
- 
-    // Divide this DecimalQuantity by the increment, round, then multiply back. 
-    divideBy(incrementDN, status); 
-    if (U_FAILURE(status)) { return; } 
-    roundToMagnitude(0, roundingMode, status); 
-    if (U_FAILURE(status)) { return; } 
-    multiplyBy(incrementDN, status); 
-    if (U_FAILURE(status)) { return; } 
-} 
- 
-void DecimalQuantity::multiplyBy(const DecNum& multiplicand, UErrorCode& status) { 
-    if (isZeroish()) { 
-        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 (isZeroish()) { 
-        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(); 
-        case PLURAL_OPERAND_E: 
-            return static_cast<double>(getExponent()); 
-        default: 
-            return std::abs(toDouble()); 
-    } 
-} 
- 
-int32_t DecimalQuantity::getExponent() const { 
-    return exponent; 
-} 
- 
-void DecimalQuantity::adjustExponent(int delta) { 
-    exponent = exponent + delta; 
-} 
- 
-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 : 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 : 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 { 
-    int32_t fractionCountWithExponent = -getLowerDisplayMagnitude() - exponent; 
-    return fractionCountWithExponent > 0 ? fractionCountWithExponent : 0; 
-} 
- 
-int32_t DecimalQuantity::fractionCountWithoutTrailingZeros() const { 
-    int32_t fractionCountWithExponent = -scale - exponent; 
-    return fractionCountWithExponent > 0 ? fractionCountWithExponent : 0;  // max(-fractionCountWithExponent, 0) 
-} 
- 
-bool DecimalQuantity::isNegative() const { 
-    return (flags & NEGATIVE_FLAG) != 0; 
-} 
- 
-Signum DecimalQuantity::signum() const { 
-    bool isZero = (isZeroish() && !isInfinite()); 
-    bool isNeg = isNegative(); 
-    if (isZero && isNeg) { 
-        return SIGNUM_NEG_ZERO; 
-    } else if (isZero) { 
-        return SIGNUM_POS_ZERO; 
-    } else if (isNeg) { 
-        return SIGNUM_NEG; 
-    } else { 
-        return SIGNUM_POS; 
-    } 
-} 
- 
-bool DecimalQuantity::isInfinite() const { 
-    return (flags & INFINITY_FLAG) != 0; 
-} 
- 
-bool DecimalQuantity::isNaN() const { 
-    return (flags & NAN_FLAG) != 0; 
-} 
- 
-bool DecimalQuantity::isZeroish() 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(); 
-        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; 
-    } 
- 
-    if (exponent == -1023 || exponent == 1024) { 
-        // The extreme values of exponent are special; use slow path. 
-        convertToAccurateDouble(); 
-        return; 
-    } 
- 
-    // 3.3219... is log2(10) 
-    auto fracLength = static_cast<int32_t> ((52 - exponent) / 3.32192809488736234787031942948939017586); 
-    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>(uprv_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 = exponent + scale + precision - 1; 
-    if (truncateIfOverflow) { 
-        upperMagnitude = std::min(upperMagnitude, 17); 
-    } 
-    for (int32_t magnitude = upperMagnitude; magnitude >= 0; magnitude--) { 
-        result = result * 10 + getDigitPos(magnitude - scale - exponent); 
-    } 
-    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 - exponent; 
-    int32_t lowerMagnitude = scale; 
-    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 (isInfinite() || isNaN()) { 
-        return false; 
-    } 
-    if (isZeroish()) { 
-        return true; 
-    } 
-    if (exponent + 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::roundToNickel(int32_t magnitude, RoundingMode roundingMode, UErrorCode& status) { 
-    roundToMagnitude(magnitude, roundingMode, true, status); 
-} 
- 
-void DecimalQuantity::roundToMagnitude(int32_t magnitude, RoundingMode roundingMode, UErrorCode& status) { 
-    roundToMagnitude(magnitude, roundingMode, false, status); 
-} 
- 
-void DecimalQuantity::roundToMagnitude(int32_t magnitude, RoundingMode roundingMode, bool nickel, UErrorCode& status) { 
-    // The position in the BCD at which rounding will be performed; digits to the right of position 
-    // will be rounded away. 
-    int position = safeSubtract(magnitude, scale); 
- 
-    // "trailing" = least significant digit to the left of rounding 
-    int8_t trailingDigit = getDigitPos(position); 
- 
-    if (position <= 0 && !isApproximate && (!nickel || trailingDigit == 0 || trailingDigit == 5)) { 
-        // 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 
-        int8_t leadingDigit = getDigitPos(safeSubtract(position, 1)); 
- 
-        // 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; 
-        if (!isApproximate) { 
-            if (nickel && trailingDigit != 2 && trailingDigit != 7) { 
-                // Nickel rounding, and not at .02x or .07x 
-                if (trailingDigit < 2) { 
-                    // .00, .01 => down to .00 
-                    section = roundingutils::SECTION_LOWER; 
-                } else if (trailingDigit < 5) { 
-                    // .03, .04 => up to .05 
-                    section = roundingutils::SECTION_UPPER; 
-                } else if (trailingDigit < 7) { 
-                    // .05, .06 => down to .05 
-                    section = roundingutils::SECTION_LOWER; 
-                } else { 
-                    // .08, .09 => up to .10 
-                    section = roundingutils::SECTION_UPPER; 
-                } 
-            } else if (leadingDigit < 5) { 
-                // Includes nickel rounding .020-.024 and .070-.074 
-                section = roundingutils::SECTION_LOWER; 
-            } else if (leadingDigit > 5) { 
-                // Includes nickel rounding .026-.029 and .076-.079 
-                section = roundingutils::SECTION_UPPER; 
-            } else { 
-                // Includes nickel rounding .025 and .075 
-                section = roundingutils::SECTION_MIDPOINT; 
-                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 && (!nickel || trailingDigit == 0 || trailingDigit == 5)) { 
-                section = roundingutils::SECTION_LOWER_EDGE; 
-                for (; p >= minP; p--) { 
-                    if (getDigitPos(p) != 0) { 
-                        section = roundingutils::SECTION_LOWER; 
-                        break; 
-                    } 
-                } 
-            } else if (leadingDigit == 4 && (!nickel || trailingDigit == 2 || trailingDigit == 7)) { 
-                section = roundingutils::SECTION_MIDPOINT; 
-                for (; p >= minP; p--) { 
-                    if (getDigitPos(p) != 9) { 
-                        section = roundingutils::SECTION_LOWER; 
-                        break; 
-                    } 
-                } 
-            } else if (leadingDigit == 5 && (!nickel || trailingDigit == 2 || trailingDigit == 7)) { 
-                section = roundingutils::SECTION_MIDPOINT; 
-                for (; p >= minP; p--) { 
-                    if (getDigitPos(p) != 0) { 
-                        section = roundingutils::SECTION_UPPER; 
-                        break; 
-                    } 
-                } 
-            } else if (leadingDigit == 9 && (!nickel || trailingDigit == 4 || trailingDigit == 9)) { 
-                section = roundingutils::SECTION_UPPER_EDGE; 
-                for (; p >= minP; p--) { 
-                    if (getDigitPos(p) != 9) { 
-                        section = roundingutils::SECTION_UPPER; 
-                        break; 
-                    } 
-                } 
-            } else if (nickel && trailingDigit != 2 && trailingDigit != 7) { 
-                // Nickel rounding, and not at .02x or .07x 
-                if (trailingDigit < 2) { 
-                    // .00, .01 => down to .00 
-                    section = roundingutils::SECTION_LOWER; 
-                } else if (trailingDigit < 5) { 
-                    // .03, .04 => up to .05 
-                    section = roundingutils::SECTION_UPPER; 
-                } else if (trailingDigit < 7) { 
-                    // .05, .06 => down to .05 
-                    section = roundingutils::SECTION_LOWER; 
-                } else { 
-                    // .08, .09 => up to .10 
-                    section = roundingutils::SECTION_UPPER; 
-                } 
-            } else if (leadingDigit < 5) { 
-                // Includes nickel rounding .020-.024 and .070-.074 
-                section = roundingutils::SECTION_LOWER; 
-            } else { 
-                // Includes nickel rounding .026-.029 and .076-.079 
-                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, nickel, 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 && (!nickel || trailingDigit == 0 || trailingDigit == 5)) { 
-                // 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; } 
-        } 
- 
-        // Nickel rounding "half even" goes to the nearest whole (away from the 5). 
-        bool isEven = nickel 
-                ? (trailingDigit < 2 || trailingDigit > 7 
-                        || (trailingDigit == 2 && section != roundingutils::SECTION_UPPER) 
-                        || (trailingDigit == 7 && section == roundingutils::SECTION_UPPER)) 
-                : (trailingDigit % 2) == 0; 
- 
-        bool roundDown = roundingutils::getRoundingDirection(isEven, 
-                isNegative(), 
-                section, 
-                roundingMode, 
-                status); 
-        if (U_FAILURE(status)) { 
-            return; 
-        } 
- 
-        // Perform truncation 
-        if (position >= precision) { 
-            setBcdToZero(); 
-            scale = magnitude; 
-        } else { 
-            shiftRight(position); 
-        } 
- 
-        if (nickel) { 
-            if (trailingDigit < 5 && roundDown) { 
-                setDigitPos(0, 0); 
-                compact(); 
-                return; 
-            } else if (trailingDigit >= 5 && !roundDown) { 
-                setDigitPos(0, 9); 
-                trailingDigit = 9; 
-                // do not return: use the bubbling logic below 
-            } else { 
-                setDigitPos(0, 5); 
-                // compact not necessary: digit at position 0 is nonzero 
-                return; 
-            } 
-        } 
- 
-        // 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) { 
-        sb.append(u'0'); 
-        return sb; 
-    } 
-    int32_t upper = scale + precision + exponent - 1; 
-    int32_t lower = scale + exponent; 
-    if (upper < lReqPos - 1) { 
-        upper = lReqPos - 1; 
-    } 
-    if (lower > rReqPos) { 
-        lower = rReqPos; 
-    }     
-    int32_t p = upper; 
-    if (p < 0) { 
-        sb.append(u'0'); 
-    } 
-    for (; p >= 0; p--) { 
-        sb.append(u'0' + getDigitPos(p - scale - exponent)); 
-    } 
-    if (lower < 0) { 
-        sb.append(u'.'); 
-    } 
-    for(; p >= lower; p--) { 
-        sb.append(u'0' + getDigitPos(p - scale - exponent)); 
-    } 
-    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; 
-    } 
-    int32_t upperPos = precision - 1; 
-    int32_t lowerPos = 0; 
-    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 + exponent; 
-    if (_scale == INT32_MIN) { 
-        result.append({u"-2147483648", -1}); 
-        return result; 
-    } else 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::popFromLeft(int32_t numDigits) { 
-    U_ASSERT(numDigits <= precision); 
-    if (usingBytes) { 
-        int i = precision - 1; 
-        for (; i >= precision - numDigits; i--) { 
-            fBCD.bcdBytes.ptr[i] = 0; 
-        } 
-    } else { 
-        fBCD.bcdLong &= (static_cast<uint64_t>(1) << ((precision - numDigits) * 4)) - 1; 
-    } 
-    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; 
-    exponent = 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 
-            && lReqPos == other.lReqPos 
-            && rReqPos == other.rReqPos 
-            && 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 %s %s%s%s%d>", 
-            lReqPos, 
-            rReqPos, 
-            (usingBytes ? "bytes" : "long"), 
-            (isNegative() ? "-" : ""), 
-            (precision == 0 ? "0" : digits.getAlias()), 
-            "E", 
-            scale); 
-    return UnicodeString(buffer8, -1, US_INV); 
-} 
- 
-#endif /* #if !UCONFIG_NO_FORMATTING */ 
+// © 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;
+    lReqPos = other.lReqPos;
+    rReqPos = other.rReqPos;
+    scale = other.scale;
+    precision = other.precision;
+    flags = other.flags;
+    origDouble = other.origDouble;
+    origDelta = other.origDelta;
+    isApproximate = other.isApproximate;
+    exponent = other.exponent;
+}
+
+void DecimalQuantity::clear() {
+    lReqPos = 0;
+    rReqPos = 0;
+    flags = 0;
+    setBcdToZero(); // sets scale, precision, hasDouble, origDouble, origDelta, and BCD data
+}
+
+void DecimalQuantity::setMinInteger(int32_t minInt) {
+    // Validation should happen outside of DecimalQuantity, e.g., in the Precision class.
+    U_ASSERT(minInt >= 0);
+
+    // 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
+    lReqPos = minInt;
+}
+
+void DecimalQuantity::setMinFraction(int32_t minFrac) {
+    // Validation should happen outside of DecimalQuantity, e.g., in the Precision class.
+    U_ASSERT(minFrac >= 0);
+
+    // Save values into internal state
+    // Negation is safe for minFrac/maxFrac because -Integer.MAX_VALUE > Integer.MIN_VALUE
+    rReqPos = -minFrac;
+}
+
+void DecimalQuantity::applyMaxInteger(int32_t maxInt) {
+    // Validation should happen outside of DecimalQuantity, e.g., in the Precision class.
+    U_ASSERT(maxInt >= 0);
+
+    if (precision == 0) {
+        return;
+    }
+
+    if (maxInt <= scale) {
+        setBcdToZero();
+        return;
+    }
+
+    int32_t magnitude = getMagnitude();
+    if (maxInt <= magnitude) {
+        popFromLeft(magnitude - maxInt + 1);
+        compact();
+    }
+}
+
+uint64_t DecimalQuantity::getPositionFingerprint() const {
+    uint64_t fingerprint = 0;
+    fingerprint ^= (lReqPos << 16);
+    fingerprint ^= (static_cast<uint64_t>(rReqPos) << 32);
+    return fingerprint;
+}
+
+void DecimalQuantity::roundToIncrement(double roundingIncrement, RoundingMode roundingMode,
+                                       UErrorCode& status) {
+    // Do not call this method with an increment having only a 1 or a 5 digit!
+    // Use a more efficient call to either roundToMagnitude() or roundToNickel().
+    // Check a few popular rounding increments; a more thorough check is in Java.
+    U_ASSERT(roundingIncrement != 0.01);
+    U_ASSERT(roundingIncrement != 0.05);
+    U_ASSERT(roundingIncrement != 0.1);
+    U_ASSERT(roundingIncrement != 0.5);
+    U_ASSERT(roundingIncrement != 1);
+    U_ASSERT(roundingIncrement != 5);
+
+    DecNum incrementDN;
+    incrementDN.setTo(roundingIncrement, status);
+    if (U_FAILURE(status)) { return; }
+
+    // Divide this DecimalQuantity by the increment, round, then multiply back.
+    divideBy(incrementDN, status);
+    if (U_FAILURE(status)) { return; }
+    roundToMagnitude(0, roundingMode, status);
+    if (U_FAILURE(status)) { return; }
+    multiplyBy(incrementDN, status);
+    if (U_FAILURE(status)) { return; }
+}
+
+void DecimalQuantity::multiplyBy(const DecNum& multiplicand, UErrorCode& status) {
+    if (isZeroish()) {
+        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 (isZeroish()) {
+        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();
+        case PLURAL_OPERAND_E:
+            return static_cast<double>(getExponent());
+        default:
+            return std::abs(toDouble());
+    }
+}
+
+int32_t DecimalQuantity::getExponent() const {
+    return exponent;
+}
+
+void DecimalQuantity::adjustExponent(int delta) {
+    exponent = exponent + delta;
+}
+
+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 : 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 : 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 {
+    int32_t fractionCountWithExponent = -getLowerDisplayMagnitude() - exponent;
+    return fractionCountWithExponent > 0 ? fractionCountWithExponent : 0;
+}
+
+int32_t DecimalQuantity::fractionCountWithoutTrailingZeros() const {
+    int32_t fractionCountWithExponent = -scale - exponent;
+    return fractionCountWithExponent > 0 ? fractionCountWithExponent : 0;  // max(-fractionCountWithExponent, 0)
+}
+
+bool DecimalQuantity::isNegative() const {
+    return (flags & NEGATIVE_FLAG) != 0;
+}
+
+Signum DecimalQuantity::signum() const {
+    bool isZero = (isZeroish() && !isInfinite());
+    bool isNeg = isNegative();
+    if (isZero && isNeg) {
+        return SIGNUM_NEG_ZERO;
+    } else if (isZero) {
+        return SIGNUM_POS_ZERO;
+    } else if (isNeg) {
+        return SIGNUM_NEG;
+    } else {
+        return SIGNUM_POS;
+    }
+}
+
+bool DecimalQuantity::isInfinite() const {
+    return (flags & INFINITY_FLAG) != 0;
+}
+
+bool DecimalQuantity::isNaN() const {
+    return (flags & NAN_FLAG) != 0;
+}
+
+bool DecimalQuantity::isZeroish() 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();
+        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;
+    }
+
+    if (exponent == -1023 || exponent == 1024) {
+        // The extreme values of exponent are special; use slow path.
+        convertToAccurateDouble();
+        return;
+    }
+
+    // 3.3219... is log2(10)
+    auto fracLength = static_cast<int32_t> ((52 - exponent) / 3.32192809488736234787031942948939017586);
+    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>(uprv_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 = exponent + scale + precision - 1;
+    if (truncateIfOverflow) {
+        upperMagnitude = std::min(upperMagnitude, 17);
+    }
+    for (int32_t magnitude = upperMagnitude; magnitude >= 0; magnitude--) {
+        result = result * 10 + getDigitPos(magnitude - scale - exponent);
+    }
+    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 - exponent;
+    int32_t lowerMagnitude = scale;
+    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 (isInfinite() || isNaN()) {
+        return false;
+    }
+    if (isZeroish()) {
+        return true;
+    }
+    if (exponent + 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::roundToNickel(int32_t magnitude, RoundingMode roundingMode, UErrorCode& status) {
+    roundToMagnitude(magnitude, roundingMode, true, status);
+}
+
+void DecimalQuantity::roundToMagnitude(int32_t magnitude, RoundingMode roundingMode, UErrorCode& status) {
+    roundToMagnitude(magnitude, roundingMode, false, status);
+}
+
+void DecimalQuantity::roundToMagnitude(int32_t magnitude, RoundingMode roundingMode, bool nickel, UErrorCode& status) {
+    // The position in the BCD at which rounding will be performed; digits to the right of position
+    // will be rounded away.
+    int position = safeSubtract(magnitude, scale);
+
+    // "trailing" = least significant digit to the left of rounding
+    int8_t trailingDigit = getDigitPos(position);
+
+    if (position <= 0 && !isApproximate && (!nickel || trailingDigit == 0 || trailingDigit == 5)) {
+        // 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
+        int8_t leadingDigit = getDigitPos(safeSubtract(position, 1));
+
+        // 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;
+        if (!isApproximate) {
+            if (nickel && trailingDigit != 2 && trailingDigit != 7) {
+                // Nickel rounding, and not at .02x or .07x
+                if (trailingDigit < 2) {
+                    // .00, .01 => down to .00
+                    section = roundingutils::SECTION_LOWER;
+                } else if (trailingDigit < 5) {
+                    // .03, .04 => up to .05
+                    section = roundingutils::SECTION_UPPER;
+                } else if (trailingDigit < 7) {
+                    // .05, .06 => down to .05
+                    section = roundingutils::SECTION_LOWER;
+                } else {
+                    // .08, .09 => up to .10
+                    section = roundingutils::SECTION_UPPER;
+                }
+            } else if (leadingDigit < 5) {
+                // Includes nickel rounding .020-.024 and .070-.074
+                section = roundingutils::SECTION_LOWER;
+            } else if (leadingDigit > 5) {
+                // Includes nickel rounding .026-.029 and .076-.079
+                section = roundingutils::SECTION_UPPER;
+            } else {
+                // Includes nickel rounding .025 and .075
+                section = roundingutils::SECTION_MIDPOINT;
+                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 && (!nickel || trailingDigit == 0 || trailingDigit == 5)) {
+                section = roundingutils::SECTION_LOWER_EDGE;
+                for (; p >= minP; p--) {
+                    if (getDigitPos(p) != 0) {
+                        section = roundingutils::SECTION_LOWER;
+                        break;
+                    }
+                }
+            } else if (leadingDigit == 4 && (!nickel || trailingDigit == 2 || trailingDigit == 7)) {
+                section = roundingutils::SECTION_MIDPOINT;
+                for (; p >= minP; p--) {
+                    if (getDigitPos(p) != 9) {
+                        section = roundingutils::SECTION_LOWER;
+                        break;
+                    }
+                }
+            } else if (leadingDigit == 5 && (!nickel || trailingDigit == 2 || trailingDigit == 7)) {
+                section = roundingutils::SECTION_MIDPOINT;
+                for (; p >= minP; p--) {
+                    if (getDigitPos(p) != 0) {
+                        section = roundingutils::SECTION_UPPER;
+                        break;
+                    }
+                }
+            } else if (leadingDigit == 9 && (!nickel || trailingDigit == 4 || trailingDigit == 9)) {
+                section = roundingutils::SECTION_UPPER_EDGE;
+                for (; p >= minP; p--) {
+                    if (getDigitPos(p) != 9) {
+                        section = roundingutils::SECTION_UPPER;
+                        break;
+                    }
+                }
+            } else if (nickel && trailingDigit != 2 && trailingDigit != 7) {
+                // Nickel rounding, and not at .02x or .07x
+                if (trailingDigit < 2) {
+                    // .00, .01 => down to .00
+                    section = roundingutils::SECTION_LOWER;
+                } else if (trailingDigit < 5) {
+                    // .03, .04 => up to .05
+                    section = roundingutils::SECTION_UPPER;
+                } else if (trailingDigit < 7) {
+                    // .05, .06 => down to .05
+                    section = roundingutils::SECTION_LOWER;
+                } else {
+                    // .08, .09 => up to .10
+                    section = roundingutils::SECTION_UPPER;
+                }
+            } else if (leadingDigit < 5) {
+                // Includes nickel rounding .020-.024 and .070-.074
+                section = roundingutils::SECTION_LOWER;
+            } else {
+                // Includes nickel rounding .026-.029 and .076-.079
+                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, nickel, 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 && (!nickel || trailingDigit == 0 || trailingDigit == 5)) {
+                // 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; }
+        }
+
+        // Nickel rounding "half even" goes to the nearest whole (away from the 5).
+        bool isEven = nickel
+                ? (trailingDigit < 2 || trailingDigit > 7
+                        || (trailingDigit == 2 && section != roundingutils::SECTION_UPPER)
+                        || (trailingDigit == 7 && section == roundingutils::SECTION_UPPER))
+                : (trailingDigit % 2) == 0;
+
+        bool roundDown = roundingutils::getRoundingDirection(isEven,
+                isNegative(),
+                section,
+                roundingMode,
+                status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+
+        // Perform truncation
+        if (position >= precision) {
+            setBcdToZero();
+            scale = magnitude;
+        } else {
+            shiftRight(position);
+        }
+
+        if (nickel) {
+            if (trailingDigit < 5 && roundDown) {
+                setDigitPos(0, 0);
+                compact();
+                return;
+            } else if (trailingDigit >= 5 && !roundDown) {
+                setDigitPos(0, 9);
+                trailingDigit = 9;
+                // do not return: use the bubbling logic below
+            } else {
+                setDigitPos(0, 5);
+                // compact not necessary: digit at position 0 is nonzero
+                return;
+            }
+        }
+
+        // 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) {
+        sb.append(u'0');
+        return sb;
+    }
+    int32_t upper = scale + precision + exponent - 1;
+    int32_t lower = scale + exponent;
+    if (upper < lReqPos - 1) {
+        upper = lReqPos - 1;
+    }
+    if (lower > rReqPos) {
+        lower = rReqPos;
+    }    
+    int32_t p = upper;
+    if (p < 0) {
+        sb.append(u'0');
+    }
+    for (; p >= 0; p--) {
+        sb.append(u'0' + getDigitPos(p - scale - exponent));
+    }
+    if (lower < 0) {
+        sb.append(u'.');
+    }
+    for(; p >= lower; p--) {
+        sb.append(u'0' + getDigitPos(p - scale - exponent));
+    }
+    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;
+    }
+    int32_t upperPos = precision - 1;
+    int32_t lowerPos = 0;
+    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 + exponent;
+    if (_scale == INT32_MIN) {
+        result.append({u"-2147483648", -1});
+        return result;
+    } else 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::popFromLeft(int32_t numDigits) {
+    U_ASSERT(numDigits <= precision);
+    if (usingBytes) {
+        int i = precision - 1;
+        for (; i >= precision - numDigits; i--) {
+            fBCD.bcdBytes.ptr[i] = 0;
+        }
+    } else {
+        fBCD.bcdLong &= (static_cast<uint64_t>(1) << ((precision - numDigits) * 4)) - 1;
+    }
+    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;
+    exponent = 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
+            && lReqPos == other.lReqPos
+            && rReqPos == other.rReqPos
+            && 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 %s %s%s%s%d>",
+            lReqPos,
+            rReqPos,
+            (usingBytes ? "bytes" : "long"),
+            (isNegative() ? "-" : ""),
+            (precision == 0 ? "0" : digits.getAlias()),
+            "E",
+            scale);
+    return UnicodeString(buffer8, -1, US_INV);
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */