445 lines
13 KiB
C++
445 lines
13 KiB
C++
// Copyright (C) 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/*
|
|
* Copyright (C) 2015, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*
|
|
* file name: precisison.cpp
|
|
*/
|
|
|
|
#include <math.h>
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
#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((double) 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(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 */
|