AuroraMiddleware/scuffed-code
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
e3180662e2
scuffed-code/icu4c/source/i18n/number_decimalquantity.cpp
Shane Carr 2edb4ec82a ICU-13634 Formatting section of data-driven test file is passing. 
X-SVN-Rev: 41120
2018-03-17 07:23:08 +00:00

1074 lines
34 KiB
C++
Raw Blame History

// © 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 && !UPRV_INCOMPLETE_CPP11_SUPPORT
#include "uassert.h"
#include <cmath>
#include "cmemory.h"
#include "decNumber.h"
#include <limits>
#include "number_decimalquantity.h"
#include "decContext.h"
#include "decNumber.h"
#include "number_roundingutils.h"
#include "double-conversion.h"
#include "unicode/plurrule.h"
using namespace icu;
using namespace icu::number;
using namespace icu::number::impl;
using double_conversion::DoubleToStringConverter;
namespace {
int8_t NEGATIVE_FLAG = 1;
int8_t INFINITY_FLAG = 2;
int8_t NAN_FLAG = 4;
static constexpr int32_t DEFAULT_DIGITS = 34;
typedef MaybeStackHeaderAndArray<decNumber, char, DEFAULT_DIGITS> DecNumberWithStorage;
/** Helper function to convert a decNumber-compatible string into a decNumber. */
void stringToDecNumber(StringPiece n, DecNumberWithStorage &dn) {
decContext set;
uprv_decContextDefault(&set, DEC_INIT_BASE);
uprv_decContextSetRounding(&set, DEC_ROUND_HALF_EVEN);
set.traps = 0; // no traps, thank you
if (n.length() > DEFAULT_DIGITS) {
dn.resize(n.length(), 0);
set.digits = n.length();
} else {
set.digits = DEFAULT_DIGITS;
}
uprv_decNumberFromString(dn.getAlias(), n.data(), &set);
U_ASSERT(DECDPUN == 1);
}
/** 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
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::operator=(const DecimalQuantity &other) {
if (this == &other) {
return *this;
}
copyBcdFrom(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;
return *this;
}
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 Rounder class.
U_ASSERT(minInt >= 0);
U_ASSERT(maxInt >= minInt);
// 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 Rounder 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: This is innefficient. Improve?
// TODO: Should we convert to decNumber instead?
double temp = toDouble();
temp /= roundingIncrement;
setToDouble(temp);
roundToMagnitude(0, roundingMode, status);
temp = 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(int32_t multiplicand) {
if (isInfinite() || isZero() || isNaN()) {
return;
}
// TODO: Should we convert to decNumber instead?
double temp = toDouble();
temp *= multiplicand;
setToDouble(temp);
}
int32_t DecimalQuantity::getMagnitude() const {
U_ASSERT(precision != 0);
return scale + precision - 1;
}
void DecimalQuantity::adjustMagnitude(int32_t delta) {
if (precision != 0) {
// TODO: How to handle overflow cases?
scale += delta;
origDelta += delta;
}
}
StandardPlural::Form DecimalQuantity::getStandardPlural(const PluralRules *rules) const {
if (rules == nullptr) {
// Fail gracefully if the user didn't provide a PluralRules
return StandardPlural::Form::OTHER;
} else {
UnicodeString ruleString = rules->select(*this);
return StandardPlural::orOtherFromString(ruleString);
}
}
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:
return static_cast<double>(toLong());
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());
}
}
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 < 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) {
flags |= NEGATIVE_FLAG;
n = -n;
}
if (n != 0) {
_setToLong(n);
compact();
}
return *this;
}
void DecimalQuantity::_setToLong(int64_t n) {
if (n == INT64_MIN) {
static const char *int64minStr = "9.223372036854775808E+18";
DecNumberWithStorage dn;
stringToDecNumber(int64minStr, dn);
readDecNumberToBcd(dn.getAlias());
} 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) != 0) {
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) {
setBcdToZero();
flags = 0;
DecNumberWithStorage dn;
stringToDecNumber(n, dn);
// The code path for decNumber is modeled after BigDecimal in Java.
if (decNumberIsNegative(dn.getAlias())) {
flags |= NEGATIVE_FLAG;
}
if (!decNumberIsZero(dn.getAlias())) {
_setToDecNumber(dn.getAlias());
}
return *this;
}
void DecimalQuantity::_setToDecNumber(decNumber *n) {
// Java fastpaths for ints here. In C++, just always read directly from the decNumber.
readDecNumberToBcd(n);
compact();
}
int64_t DecimalQuantity::toLong() const {
int64_t result = 0L;
for (int32_t magnitude = scale + precision - 1; magnitude >= 0; magnitude--) {
result = result * 10 + getDigitPos(magnitude - scale);
}
if (isNegative()) { result = -result; }
return result;
}
int64_t DecimalQuantity::toFractionLong(bool includeTrailingZeros) const {
int64_t result = 0L;
int32_t magnitude = -1;
for (; (magnitude >= scale || (includeTrailingZeros && magnitude >= rReqPos)) &&
magnitude >= rOptPos; magnitude--) {
result = result * 10 + getDigitPos(magnitude - scale);
}
return result;
}
bool DecimalQuantity::fitsInLong() const {
if (isZero()) {
return true;
}
if (scale < 0) {
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 (isApproximate) {
return toDoubleFromOriginal();
}
if (isNaN()) {
return NAN;
} else if (isInfinite()) {
return isNegative() ? -INFINITY : INFINITY;
}
int64_t tempLong = 0L;
int32_t lostDigits = precision - (precision < 17 ? precision : 17);
for (int shift = precision - 1; shift >= lostDigits; shift--) {
tempLong = tempLong * 10 + getDigitPos(shift);
}
double result = static_cast<double>(tempLong);
int32_t _scale = scale + lostDigits;
if (_scale >= 0) {
// 1e22 is the largest exact double.
int32_t i = _scale;
for (; i >= 22; i -= 22) result *= 1e22;
result *= DOUBLE_MULTIPLIERS[i];
} else {
// 1e22 is the largest exact double.
int32_t i = _scale;
for (; i <= -22; i += 22) result /= 1e22;
result /= DOUBLE_MULTIPLIERS[-i];
}
if (isNegative()) { result = -result; }
return result;
}
double DecimalQuantity::toDoubleFromOriginal() const {
double result = origDouble;
int32_t delta = origDelta;
if (delta >= 0) {
// 1e22 is the largest exact double.
for (; delta >= 22; delta -= 22) result *= 1e22;
result *= DOUBLE_MULTIPLIERS[delta];
} else {
// 1e22 is the largest exact double.
for (; delta <= -22; delta += 22) result /= 1e22;
result /= DOUBLE_MULTIPLIERS[-delta];
}
if (isNegative()) { result *= -1; }
return result;
}
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 {
UnicodeString sb;
if (isNegative()) {
sb.append(u'-');
}
for (int m = getUpperDisplayMagnitude(); m >= getLowerDisplayMagnitude(); m--) {
if (m == -1) { sb.append(u'.'); }
sb.append(getDigit(m) + u'0');
}
return sb;
}
////////////////////////////////////////////////////
/// 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(decNumber *dn) {
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(fBCD.bcdBytes.ptr + 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;
}
}
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 {
// FIXME: Make a faster implementation.
return toString() == other.toString();
}
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);
}
UnicodeString DecimalQuantity::toNumberString() const {
MaybeStackArray<char, 30> digits(precision + 11);
for (int32_t i = 0; i < precision; i++) {
digits[i] = getDigitPos(precision - i - 1) + '0';
}
snprintf(digits.getAlias() + precision, 11, "E%d", scale);
return UnicodeString(digits.getAlias(), -1, US_INV);
}
#endif /* #if !UCONFIG_NO_FORMATTING */
Reference in New Issue View Git Blame Copy Permalink