| /* |
| * Copyright (C) 2015, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| * file name: precisison.cpp |
| */ |
| |
| #if !defined(STARBOARD) |
| #include <math.h> |
| #endif |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| #include "starboard/client_porting/poem/string_poem.h" |
| #include "starboard/client_porting/poem/math_poem.h" |
| #include "digitlst.h" |
| #include "fmtableimp.h" |
| #include "precision.h" |
| #include "putilimp.h" |
| #include "visibledigits.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| static const int32_t gPower10[] = {1, 10, 100, 1000}; |
| |
| FixedPrecision::FixedPrecision() |
| : fExactOnly(FALSE), fFailIfOverMax(FALSE), fRoundingMode(DecimalFormat::kRoundHalfEven) { |
| fMin.setIntDigitCount(1); |
| fMin.setFracDigitCount(0); |
| } |
| |
| UBool |
| FixedPrecision::isRoundingRequired( |
| int32_t upperExponent, int32_t lowerExponent) const { |
| int32_t leastSigAllowed = fMax.getLeastSignificantInclusive(); |
| int32_t maxSignificantDigits = fSignificant.getMax(); |
| int32_t roundDigit; |
| if (maxSignificantDigits == INT32_MAX) { |
| roundDigit = leastSigAllowed; |
| } else { |
| int32_t limitDigit = upperExponent - maxSignificantDigits; |
| roundDigit = |
| limitDigit > leastSigAllowed ? limitDigit : leastSigAllowed; |
| } |
| return (roundDigit > lowerExponent); |
| } |
| |
| DigitList & |
| FixedPrecision::round( |
| DigitList &value, int32_t exponent, UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return value; |
| } |
| value .fContext.status &= ~DEC_Inexact; |
| if (!fRoundingIncrement.isZero()) { |
| if (exponent == 0) { |
| value.quantize(fRoundingIncrement, status); |
| } else { |
| DigitList adjustedIncrement(fRoundingIncrement); |
| adjustedIncrement.shiftDecimalRight(exponent); |
| value.quantize(adjustedIncrement, status); |
| } |
| if (U_FAILURE(status)) { |
| return value; |
| } |
| } |
| int32_t leastSig = fMax.getLeastSignificantInclusive(); |
| if (leastSig == INT32_MIN) { |
| value.round(fSignificant.getMax()); |
| } else { |
| value.roundAtExponent( |
| exponent + leastSig, |
| fSignificant.getMax()); |
| } |
| if (fExactOnly && (value.fContext.status & DEC_Inexact)) { |
| status = U_FORMAT_INEXACT_ERROR; |
| } else if (fFailIfOverMax) { |
| // Smallest interval for value stored in interval |
| DigitInterval interval; |
| value.getSmallestInterval(interval); |
| if (fMax.getIntDigitCount() < interval.getIntDigitCount()) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| } |
| return value; |
| } |
| |
| DigitInterval & |
| FixedPrecision::getIntervalForZero(DigitInterval &interval) const { |
| interval = fMin; |
| if (fSignificant.getMin() > 0) { |
| interval.expandToContainDigit(interval.getIntDigitCount() - fSignificant.getMin()); |
| } |
| interval.shrinkToFitWithin(fMax); |
| return interval; |
| } |
| |
| DigitInterval & |
| FixedPrecision::getInterval( |
| int32_t upperExponent, DigitInterval &interval) const { |
| if (fSignificant.getMin() > 0) { |
| interval.expandToContainDigit( |
| upperExponent - fSignificant.getMin()); |
| } |
| interval.expandToContain(fMin); |
| interval.shrinkToFitWithin(fMax); |
| return interval; |
| } |
| |
| DigitInterval & |
| FixedPrecision::getInterval( |
| const DigitList &value, DigitInterval &interval) const { |
| if (value.isZero()) { |
| interval = fMin; |
| if (fSignificant.getMin() > 0) { |
| interval.expandToContainDigit(interval.getIntDigitCount() - fSignificant.getMin()); |
| } |
| } else { |
| value.getSmallestInterval(interval); |
| if (fSignificant.getMin() > 0) { |
| interval.expandToContainDigit( |
| value.getUpperExponent() - fSignificant.getMin()); |
| } |
| interval.expandToContain(fMin); |
| } |
| interval.shrinkToFitWithin(fMax); |
| return interval; |
| } |
| |
| UBool |
| FixedPrecision::isFastFormattable() const { |
| return (fMin.getFracDigitCount() == 0 && fSignificant.isNoConstraints() && fRoundingIncrement.isZero() && !fFailIfOverMax); |
| } |
| |
| UBool |
| FixedPrecision::handleNonNumeric(DigitList &value, VisibleDigits &digits) { |
| if (value.isNaN()) { |
| digits.setNaN(); |
| return TRUE; |
| } |
| if (value.isInfinite()) { |
| digits.setInfinite(); |
| if (!value.isPositive()) { |
| digits.setNegative(); |
| } |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| VisibleDigits & |
| FixedPrecision::initVisibleDigits( |
| DigitList &value, |
| VisibleDigits &digits, |
| UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return digits; |
| } |
| digits.clear(); |
| if (handleNonNumeric(value, digits)) { |
| return digits; |
| } |
| if (!value.isPositive()) { |
| digits.setNegative(); |
| } |
| value.setRoundingMode(fRoundingMode); |
| round(value, 0, status); |
| getInterval(value, digits.fInterval); |
| digits.fExponent = value.getLowerExponent(); |
| value.appendDigitsTo(digits.fDigits, status); |
| return digits; |
| } |
| |
| VisibleDigits & |
| FixedPrecision::initVisibleDigits( |
| int64_t value, |
| VisibleDigits &digits, |
| UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return digits; |
| } |
| if (!fRoundingIncrement.isZero()) { |
| // If we have round increment, use digit list. |
| DigitList digitList; |
| digitList.set(value); |
| return initVisibleDigits(digitList, digits, status); |
| } |
| // Try fast path |
| if (initVisibleDigits(value, 0, digits, status)) { |
| digits.fAbsDoubleValue = fabs(static_cast<float>(value)); |
| digits.fAbsDoubleValueSet = U_SUCCESS(status) && !digits.isOverMaxDigits(); |
| return digits; |
| } |
| // Oops have to use digit list |
| DigitList digitList; |
| digitList.set(value); |
| return initVisibleDigits(digitList, digits, status); |
| } |
| |
| VisibleDigits & |
| FixedPrecision::initVisibleDigits( |
| double value, |
| VisibleDigits &digits, |
| UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return digits; |
| } |
| digits.clear(); |
| if (uprv_isNaN(value)) { |
| digits.setNaN(); |
| return digits; |
| } |
| if (uprv_isPositiveInfinity(value)) { |
| digits.setInfinite(); |
| return digits; |
| } |
| if (uprv_isNegativeInfinity(value)) { |
| digits.setInfinite(); |
| digits.setNegative(); |
| return digits; |
| } |
| if (!fRoundingIncrement.isZero()) { |
| // If we have round increment, use digit list. |
| DigitList digitList; |
| digitList.set(value); |
| return initVisibleDigits(digitList, digits, status); |
| } |
| // Try to find n such that value * 10^n is an integer |
| int32_t n = -1; |
| double scaled; |
| for (int32_t i = 0; i < UPRV_LENGTHOF(gPower10); ++i) { |
| scaled = value * gPower10[i]; |
| if (scaled > MAX_INT64_IN_DOUBLE || scaled < -MAX_INT64_IN_DOUBLE) { |
| break; |
| } |
| if (scaled == floor(scaled)) { |
| n = i; |
| break; |
| } |
| } |
| // Try fast path |
| if (n >= 0 && initVisibleDigits(scaled, -n, digits, status)) { |
| digits.fAbsDoubleValue = fabs(static_cast<float>(value)); |
| digits.fAbsDoubleValueSet = U_SUCCESS(status) && !digits.isOverMaxDigits(); |
| // Adjust for negative 0 becuase when we cast to an int64, |
| // negative 0 becomes positive 0. |
| if (scaled == 0.0 && uprv_isNegative(scaled)) { |
| digits.setNegative(); |
| } |
| return digits; |
| } |
| |
| // Oops have to use digit list |
| DigitList digitList; |
| digitList.set(value); |
| return initVisibleDigits(digitList, digits, status); |
| } |
| |
| UBool |
| FixedPrecision::initVisibleDigits( |
| int64_t mantissa, |
| int32_t exponent, |
| VisibleDigits &digits, |
| UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return TRUE; |
| } |
| digits.clear(); |
| |
| // Precompute fAbsIntValue if it is small enough, but we don't know yet |
| // if it will be valid. |
| UBool absIntValueComputed = FALSE; |
| if (mantissa > -1000000000000000000LL /* -1e18 */ |
| && mantissa < 1000000000000000000LL /* 1e18 */) { |
| digits.fAbsIntValue = mantissa; |
| if (digits.fAbsIntValue < 0) { |
| digits.fAbsIntValue = -digits.fAbsIntValue; |
| } |
| int32_t i = 0; |
| int32_t maxPower10Exp = UPRV_LENGTHOF(gPower10) - 1; |
| for (; i > exponent + maxPower10Exp; i -= maxPower10Exp) { |
| digits.fAbsIntValue /= gPower10[maxPower10Exp]; |
| } |
| digits.fAbsIntValue /= gPower10[i - exponent]; |
| absIntValueComputed = TRUE; |
| } |
| if (mantissa == 0) { |
| getIntervalForZero(digits.fInterval); |
| digits.fAbsIntValueSet = absIntValueComputed; |
| return TRUE; |
| } |
| // be sure least significant digit is non zero |
| while (mantissa % 10 == 0) { |
| mantissa /= 10; |
| ++exponent; |
| } |
| if (mantissa < 0) { |
| digits.fDigits.append((char) -(mantissa % -10), status); |
| mantissa /= -10; |
| digits.setNegative(); |
| } |
| while (mantissa) { |
| digits.fDigits.append((char) (mantissa % 10), status); |
| mantissa /= 10; |
| } |
| if (U_FAILURE(status)) { |
| return TRUE; |
| } |
| digits.fExponent = exponent; |
| int32_t upperExponent = exponent + digits.fDigits.length(); |
| if (fFailIfOverMax && upperExponent > fMax.getIntDigitCount()) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| return TRUE; |
| } |
| UBool roundingRequired = |
| isRoundingRequired(upperExponent, exponent); |
| if (roundingRequired) { |
| if (fExactOnly) { |
| status = U_FORMAT_INEXACT_ERROR; |
| return TRUE; |
| } |
| return FALSE; |
| } |
| digits.fInterval.setLeastSignificantInclusive(exponent); |
| digits.fInterval.setMostSignificantExclusive(upperExponent); |
| getInterval(upperExponent, digits.fInterval); |
| |
| // The intValue we computed above is only valid if our visible digits |
| // doesn't exceed the maximum integer digits allowed. |
| digits.fAbsIntValueSet = absIntValueComputed && !digits.isOverMaxDigits(); |
| return TRUE; |
| } |
| |
| VisibleDigitsWithExponent & |
| FixedPrecision::initVisibleDigitsWithExponent( |
| DigitList &value, |
| VisibleDigitsWithExponent &digits, |
| UErrorCode &status) const { |
| digits.clear(); |
| initVisibleDigits(value, digits.fMantissa, status); |
| return digits; |
| } |
| |
| VisibleDigitsWithExponent & |
| FixedPrecision::initVisibleDigitsWithExponent( |
| double value, |
| VisibleDigitsWithExponent &digits, |
| UErrorCode &status) const { |
| digits.clear(); |
| initVisibleDigits(value, digits.fMantissa, status); |
| return digits; |
| } |
| |
| VisibleDigitsWithExponent & |
| FixedPrecision::initVisibleDigitsWithExponent( |
| int64_t value, |
| VisibleDigitsWithExponent &digits, |
| UErrorCode &status) const { |
| digits.clear(); |
| initVisibleDigits(value, digits.fMantissa, status); |
| return digits; |
| } |
| |
| ScientificPrecision::ScientificPrecision() : fMinExponentDigits(1) { |
| } |
| |
| DigitList & |
| ScientificPrecision::round(DigitList &value, UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return value; |
| } |
| int32_t exponent = value.getScientificExponent( |
| fMantissa.fMin.getIntDigitCount(), getMultiplier()); |
| return fMantissa.round(value, exponent, status); |
| } |
| |
| int32_t |
| ScientificPrecision::toScientific(DigitList &value) const { |
| return value.toScientific( |
| fMantissa.fMin.getIntDigitCount(), getMultiplier()); |
| } |
| |
| int32_t |
| ScientificPrecision::getMultiplier() const { |
| int32_t maxIntDigitCount = fMantissa.fMax.getIntDigitCount(); |
| if (maxIntDigitCount == INT32_MAX) { |
| return 1; |
| } |
| int32_t multiplier = |
| maxIntDigitCount - fMantissa.fMin.getIntDigitCount() + 1; |
| return (multiplier < 1 ? 1 : multiplier); |
| } |
| |
| VisibleDigitsWithExponent & |
| ScientificPrecision::initVisibleDigitsWithExponent( |
| DigitList &value, |
| VisibleDigitsWithExponent &digits, |
| UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return digits; |
| } |
| digits.clear(); |
| if (FixedPrecision::handleNonNumeric(value, digits.fMantissa)) { |
| return digits; |
| } |
| value.setRoundingMode(fMantissa.fRoundingMode); |
| int64_t exponent = toScientific(round(value, status)); |
| fMantissa.initVisibleDigits(value, digits.fMantissa, status); |
| FixedPrecision exponentPrecision; |
| exponentPrecision.fMin.setIntDigitCount(fMinExponentDigits); |
| exponentPrecision.initVisibleDigits(exponent, digits.fExponent, status); |
| digits.fHasExponent = TRUE; |
| return digits; |
| } |
| |
| VisibleDigitsWithExponent & |
| ScientificPrecision::initVisibleDigitsWithExponent( |
| double value, |
| VisibleDigitsWithExponent &digits, |
| UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return digits; |
| } |
| DigitList digitList; |
| digitList.set(value); |
| return initVisibleDigitsWithExponent(digitList, digits, status); |
| } |
| |
| VisibleDigitsWithExponent & |
| ScientificPrecision::initVisibleDigitsWithExponent( |
| int64_t value, |
| VisibleDigitsWithExponent &digits, |
| UErrorCode &status) const { |
| if (U_FAILURE(status)) { |
| return digits; |
| } |
| DigitList digitList; |
| digitList.set(value); |
| return initVisibleDigitsWithExponent(digitList, digits, status); |
| } |
| |
| |
| U_NAMESPACE_END |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |
