Home | History | Annotate | Download | only in i18n 
      1 /*
      2  * Copyright (C) 2015, International Business Machines
      3  * Corporation and others.  All Rights Reserved.
      4  *
      5  * file name: precisison.cpp
      6  */
      7 
      8 #include <math.h>
      9 
     10 #include "unicode/utypes.h"
     11 
     12 #if !UCONFIG_NO_FORMATTING
     13 
     14 #include "digitlst.h"
     15 #include "fmtableimp.h"
     16 #include "precision.h"
     17 #include "putilimp.h"
     18 #include "visibledigits.h"
     19 
     20 U_NAMESPACE_BEGIN
     21 
     22 static const int32_t gPower10[] = {1, 10, 100, 1000};
     23 
     24 FixedPrecision::FixedPrecision()
     25         : fExactOnly(FALSE), fFailIfOverMax(FALSE), fRoundingMode(DecimalFormat::kRoundHalfEven) {
     26     fMin.setIntDigitCount(1);
     27     fMin.setFracDigitCount(0);
     28 }
     29 
     30 UBool
     31 FixedPrecision::isRoundingRequired(
     32         int32_t upperExponent, int32_t lowerExponent) const {
     33     int32_t leastSigAllowed = fMax.getLeastSignificantInclusive();
     34     int32_t maxSignificantDigits = fSignificant.getMax();
     35     int32_t roundDigit;
     36     if (maxSignificantDigits == INT32_MAX) {
     37         roundDigit = leastSigAllowed;
     38     } else {
     39         int32_t limitDigit = upperExponent - maxSignificantDigits;
     40         roundDigit =
     41                 limitDigit > leastSigAllowed ? limitDigit : leastSigAllowed;
     42     }
     43     return (roundDigit > lowerExponent);
     44 }
     45 
     46 DigitList &
     47 FixedPrecision::round(
     48         DigitList &value, int32_t exponent, UErrorCode &status) const {
     49     if (U_FAILURE(status)) {
     50         return value;
     51     }
     52     value .fContext.status &= ~DEC_Inexact;
     53     if (!fRoundingIncrement.isZero()) {
     54         if (exponent == 0) {
     55             value.quantize(fRoundingIncrement, status);
     56         } else {
     57             DigitList adjustedIncrement(fRoundingIncrement);
     58             adjustedIncrement.shiftDecimalRight(exponent);
     59             value.quantize(adjustedIncrement, status);
     60         }
     61         if (U_FAILURE(status)) {
     62             return value;
     63         }
     64     }
     65     int32_t leastSig = fMax.getLeastSignificantInclusive();
     66     if (leastSig == INT32_MIN) {
     67         value.round(fSignificant.getMax());
     68     } else {
     69         value.roundAtExponent(
     70                 exponent + leastSig,
     71                 fSignificant.getMax());
     72     }
     73     if (fExactOnly && (value.fContext.status & DEC_Inexact)) {
     74         status = U_FORMAT_INEXACT_ERROR;
     75     } else if (fFailIfOverMax) {
     76         // Smallest interval for value stored in interval
     77         DigitInterval interval;
     78         value.getSmallestInterval(interval);
     79         if (fMax.getIntDigitCount() < interval.getIntDigitCount()) {
     80             status = U_ILLEGAL_ARGUMENT_ERROR;
     81         }
     82     }
     83     return value;
     84 }
     85 
     86 DigitInterval &
     87 FixedPrecision::getIntervalForZero(DigitInterval &interval) const {
     88     interval = fMin;
     89     if (fSignificant.getMin() > 0) {
     90         interval.expandToContainDigit(interval.getIntDigitCount() - fSignificant.getMin());
     91     }
     92     interval.shrinkToFitWithin(fMax);
     93     return interval;
     94 }
     95 
     96 DigitInterval &
     97 FixedPrecision::getInterval(
     98         int32_t upperExponent, DigitInterval &interval) const {
     99     if (fSignificant.getMin() > 0) {
    100         interval.expandToContainDigit(
    101                 upperExponent - fSignificant.getMin());
    102     }
    103     interval.expandToContain(fMin);
    104     interval.shrinkToFitWithin(fMax);
    105     return interval;
    106 }
    107 
    108 DigitInterval &
    109 FixedPrecision::getInterval(
    110         const DigitList &value, DigitInterval &interval) const {
    111     if (value.isZero()) {
    112         interval = fMin;
    113         if (fSignificant.getMin() > 0) {
    114             interval.expandToContainDigit(interval.getIntDigitCount() - fSignificant.getMin());
    115         }
    116     } else {
    117         value.getSmallestInterval(interval);
    118         if (fSignificant.getMin() > 0) {
    119             interval.expandToContainDigit(
    120                     value.getUpperExponent() - fSignificant.getMin());
    121         }
    122         interval.expandToContain(fMin);
    123     }
    124     interval.shrinkToFitWithin(fMax);
    125     return interval;
    126 }
    127 
    128 UBool
    129 FixedPrecision::isFastFormattable() const {
    130     return (fMin.getFracDigitCount() == 0 && fSignificant.isNoConstraints() && fRoundingIncrement.isZero() && !fFailIfOverMax);
    131 }
    132 
    133 UBool
    134 FixedPrecision::handleNonNumeric(DigitList &value, VisibleDigits &digits) {
    135     if (value.isNaN()) {
    136         digits.setNaN();
    137         return TRUE;
    138     }
    139     if (value.isInfinite()) {
    140         digits.setInfinite();
    141         if (!value.isPositive()) {
    142             digits.setNegative();
    143         }
    144         return TRUE;
    145     }
    146     return FALSE;
    147 }
    148 
    149 VisibleDigits &
    150 FixedPrecision::initVisibleDigits(
    151         DigitList &value,
    152         VisibleDigits &digits,
    153         UErrorCode &status) const {
    154     if (U_FAILURE(status)) {
    155         return digits;
    156     }
    157     digits.clear();
    158     if (handleNonNumeric(value, digits)) {
    159         return digits;
    160     }
    161     if (!value.isPositive()) {
    162         digits.setNegative();
    163     }
    164     value.setRoundingMode(fRoundingMode);
    165     round(value, 0, status);
    166     getInterval(value, digits.fInterval);
    167     digits.fExponent = value.getLowerExponent();
    168     value.appendDigitsTo(digits.fDigits, status);
    169     return digits;
    170 }
    171 
    172 VisibleDigits &
    173 FixedPrecision::initVisibleDigits(
    174         int64_t value,
    175         VisibleDigits &digits,
    176         UErrorCode &status) const {
    177     if (U_FAILURE(status)) {
    178         return digits;
    179     }
    180     if (!fRoundingIncrement.isZero()) {
    181         // If we have round increment, use digit list.
    182         DigitList digitList;
    183         digitList.set(value);
    184         return initVisibleDigits(digitList, digits, status);
    185     }
    186     // Try fast path
    187     if (initVisibleDigits(value, 0, digits, status)) {
    188         digits.fAbsDoubleValue = fabs((double) value);
    189         digits.fAbsDoubleValueSet = U_SUCCESS(status) && !digits.isOverMaxDigits();
    190         return digits;
    191     }
    192     // Oops have to use digit list
    193     DigitList digitList;
    194     digitList.set(value);
    195     return initVisibleDigits(digitList, digits, status);
    196 }
    197 
    198 VisibleDigits &
    199 FixedPrecision::initVisibleDigits(
    200         double value,
    201         VisibleDigits &digits,
    202         UErrorCode &status) const {
    203     if (U_FAILURE(status)) {
    204         return digits;
    205     }
    206     digits.clear();
    207     if (uprv_isNaN(value)) {
    208         digits.setNaN();
    209         return digits;
    210     }
    211     if (uprv_isPositiveInfinity(value)) {
    212         digits.setInfinite();
    213         return digits;
    214     }
    215     if (uprv_isNegativeInfinity(value)) {
    216         digits.setInfinite();
    217         digits.setNegative();
    218         return digits;
    219     }
    220     if (!fRoundingIncrement.isZero()) {
    221         // If we have round increment, use digit list.
    222         DigitList digitList;
    223         digitList.set(value);
    224         return initVisibleDigits(digitList, digits, status);
    225     }
    226     // Try to find n such that value * 10^n is an integer
    227     int32_t n = -1;
    228     double scaled;
    229     for (int32_t i = 0; i < UPRV_LENGTHOF(gPower10); ++i) {
    230         scaled = value * gPower10[i];
    231         if (scaled > MAX_INT64_IN_DOUBLE || scaled < -MAX_INT64_IN_DOUBLE) {
    232             break;
    233         }
    234         if (scaled == floor(scaled)) {
    235             n = i;
    236             break;
    237         }
    238     }
    239     // Try fast path
    240     if (n >= 0 && initVisibleDigits(scaled, -n, digits, status)) {
    241         digits.fAbsDoubleValue = fabs(value);
    242         digits.fAbsDoubleValueSet = U_SUCCESS(status) && !digits.isOverMaxDigits();
    243         // Adjust for negative 0 becuase when we cast to an int64,
    244         // negative 0 becomes positive 0.
    245         if (scaled == 0.0 && uprv_isNegative(scaled)) {
    246             digits.setNegative();
    247         }
    248         return digits;
    249     }
    250 
    251     // Oops have to use digit list
    252     DigitList digitList;
    253     digitList.set(value);
    254     return initVisibleDigits(digitList, digits, status);
    255 }
    256 
    257 UBool
    258 FixedPrecision::initVisibleDigits(
    259         int64_t mantissa,
    260         int32_t exponent,
    261         VisibleDigits &digits,
    262         UErrorCode &status) const {
    263     if (U_FAILURE(status)) {
    264         return TRUE;
    265     }
    266     digits.clear();
    267 
    268     // Precompute fAbsIntValue if it is small enough, but we don't know yet
    269     // if it will be valid.
    270     UBool absIntValueComputed = FALSE;
    271     if (mantissa > -1000000000000000000LL /* -1e18 */
    272             && mantissa < 1000000000000000000LL /* 1e18 */) {
    273         digits.fAbsIntValue = mantissa;
    274         if (digits.fAbsIntValue < 0) {
    275             digits.fAbsIntValue = -digits.fAbsIntValue;
    276         }
    277         int32_t i = 0;
    278         int32_t maxPower10Exp = UPRV_LENGTHOF(gPower10) - 1;
    279         for (; i > exponent + maxPower10Exp; i -= maxPower10Exp) {
    280             digits.fAbsIntValue /= gPower10[maxPower10Exp];
    281         }
    282         digits.fAbsIntValue /= gPower10[i - exponent];
    283         absIntValueComputed = TRUE;
    284     }
    285     if (mantissa == 0) {
    286         getIntervalForZero(digits.fInterval);
    287         digits.fAbsIntValueSet = absIntValueComputed;
    288         return TRUE;
    289     }
    290     // be sure least significant digit is non zero
    291     while (mantissa % 10 == 0) {
    292         mantissa /= 10;
    293         ++exponent;
    294     }
    295     if (mantissa < 0) {
    296         digits.fDigits.append((char) -(mantissa % -10), status);
    297         mantissa /= -10;
    298         digits.setNegative();
    299     }
    300     while (mantissa) {
    301         digits.fDigits.append((char) (mantissa % 10), status);
    302         mantissa /= 10;
    303     }
    304     if (U_FAILURE(status)) {
    305         return TRUE;
    306     }
    307     digits.fExponent = exponent;
    308     int32_t upperExponent = exponent + digits.fDigits.length();
    309     if (fFailIfOverMax && upperExponent > fMax.getIntDigitCount()) {
    310         status = U_ILLEGAL_ARGUMENT_ERROR;
    311         return TRUE;
    312     }
    313     UBool roundingRequired =
    314             isRoundingRequired(upperExponent, exponent);
    315     if (roundingRequired) {
    316         if (fExactOnly) {
    317             status = U_FORMAT_INEXACT_ERROR;
    318             return TRUE;
    319         }
    320         return FALSE;
    321     }
    322     digits.fInterval.setLeastSignificantInclusive(exponent);
    323     digits.fInterval.setMostSignificantExclusive(upperExponent);
    324     getInterval(upperExponent, digits.fInterval);
    325 
    326     // The intValue we computed above is only valid if our visible digits
    327     // doesn't exceed the maximum integer digits allowed.
    328     digits.fAbsIntValueSet = absIntValueComputed && !digits.isOverMaxDigits();
    329     return TRUE;
    330 }
    331 
    332 VisibleDigitsWithExponent &
    333 FixedPrecision::initVisibleDigitsWithExponent(
    334         DigitList &value,
    335         VisibleDigitsWithExponent &digits,
    336         UErrorCode &status) const {
    337     digits.clear();
    338     initVisibleDigits(value, digits.fMantissa, status);
    339     return digits;
    340 }
    341 
    342 VisibleDigitsWithExponent &
    343 FixedPrecision::initVisibleDigitsWithExponent(
    344         double value,
    345         VisibleDigitsWithExponent &digits,
    346         UErrorCode &status) const {
    347     digits.clear();
    348     initVisibleDigits(value, digits.fMantissa, status);
    349     return digits;
    350 }
    351 
    352 VisibleDigitsWithExponent &
    353 FixedPrecision::initVisibleDigitsWithExponent(
    354         int64_t value,
    355         VisibleDigitsWithExponent &digits,
    356         UErrorCode &status) const {
    357     digits.clear();
    358     initVisibleDigits(value, digits.fMantissa, status);
    359     return digits;
    360 }
    361 
    362 ScientificPrecision::ScientificPrecision() : fMinExponentDigits(1) {
    363 }
    364 
    365 DigitList &
    366 ScientificPrecision::round(DigitList &value, UErrorCode &status) const {
    367     if (U_FAILURE(status)) {
    368         return value;
    369     }
    370     int32_t exponent = value.getScientificExponent(
    371             fMantissa.fMin.getIntDigitCount(), getMultiplier());
    372     return fMantissa.round(value, exponent, status);
    373 }
    374 
    375 int32_t
    376 ScientificPrecision::toScientific(DigitList &value) const {
    377     return value.toScientific(
    378             fMantissa.fMin.getIntDigitCount(), getMultiplier());
    379 }
    380 
    381 int32_t
    382 ScientificPrecision::getMultiplier() const {
    383     int32_t maxIntDigitCount = fMantissa.fMax.getIntDigitCount();
    384     if (maxIntDigitCount == INT32_MAX) {
    385         return 1;
    386     }
    387     int32_t multiplier =
    388         maxIntDigitCount - fMantissa.fMin.getIntDigitCount() + 1;
    389     return (multiplier < 1 ? 1 : multiplier);
    390 }
    391 
    392 VisibleDigitsWithExponent &
    393 ScientificPrecision::initVisibleDigitsWithExponent(
    394         DigitList &value,
    395         VisibleDigitsWithExponent &digits,
    396         UErrorCode &status) const {
    397     if (U_FAILURE(status)) {
    398         return digits;
    399     }
    400     digits.clear();
    401     if (FixedPrecision::handleNonNumeric(value, digits.fMantissa)) {
    402         return digits;
    403     }
    404     value.setRoundingMode(fMantissa.fRoundingMode);
    405     int64_t exponent = toScientific(round(value, status));
    406     fMantissa.initVisibleDigits(value, digits.fMantissa, status);
    407     FixedPrecision exponentPrecision;
    408     exponentPrecision.fMin.setIntDigitCount(fMinExponentDigits);
    409     exponentPrecision.initVisibleDigits(exponent, digits.fExponent, status);
    410     digits.fHasExponent = TRUE;
    411     return digits;
    412 }
    413 
    414 VisibleDigitsWithExponent &
    415 ScientificPrecision::initVisibleDigitsWithExponent(
    416         double value,
    417         VisibleDigitsWithExponent &digits,
    418         UErrorCode &status) const {
    419     if (U_FAILURE(status)) {
    420         return digits;
    421     }
    422     DigitList digitList;
    423     digitList.set(value);
    424     return initVisibleDigitsWithExponent(digitList, digits, status);
    425 }
    426 
    427 VisibleDigitsWithExponent &
    428 ScientificPrecision::initVisibleDigitsWithExponent(
    429         int64_t value,
    430         VisibleDigitsWithExponent &digits,
    431         UErrorCode &status) const {
    432     if (U_FAILURE(status)) {
    433         return digits;
    434     }
    435     DigitList digitList;
    436     digitList.set(value);
    437     return initVisibleDigitsWithExponent(digitList, digits, status);
    438 }
    439 
    440 
    441 U_NAMESPACE_END
    442 #endif /* #if !UCONFIG_NO_FORMATTING */
    443