ICU 56 update step 1

source/i18n/digitlst.cpp

 /*
 **********************************************************************
-*   Copyright (C) 1997-2014, International Business Machines
+*   Copyright (C) 1997-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 **********************************************************************
 *
 * File DIGITLST.CPP
 *
 * Modification History:
 *
 *   Date        Name        Description
 *   03/21/97    clhuang     Converted from java.
 *   03/21/97    clhuang     Implemented with new APIs.
@@ skipping 13 matching lines @@
 #include "digitlst.h"
 
 #if !UCONFIG_NO_FORMATTING
 #include "unicode/putil.h"
 #include "charstr.h"
 #include "cmemory.h"
 #include "cstring.h"
 #include "mutex.h"
 #include "putilimp.h"
 #include "uassert.h"
+#include "digitinterval.h" 
 #include <stdlib.h>
 #include <limits.h>
 #include <string.h>
 #include <stdio.h>
 #include <limits>
 
 // ***************************************************************************
 // class DigitList
 //    A wrapper onto decNumber.
 //    Used to be standalone.
@@ skipping 342 matching lines @@
             fDecNumber->digits++;
             // DigitList emulation - appending doesn't change the magnitude of existing
             //                       digits.  With decNumber's decimal being after the
             //                       least signficant digit, we need to adjust the exponent.
             fDecNumber->exponent--;
         }
     }
     internalClear();
 }
 
+char DigitList::getStrtodDecimalSeparator() {
+    // TODO: maybe use andy's pthread once.
+    static char gDecimal = 0;
+    char result;
+    {
+        Mutex mutex;
+        result = gDecimal;;
+        if (result == 0) {
+            // We need to know the decimal separator character that will be used with strtod().
+            // Depends on the C runtime global locale.
+            // Most commonly is '.'
+            // TODO: caching could fail if the global locale is changed on the fly.
+            char rep[MAX_DIGITS];
+            sprintf(rep, "%+1.1f", 1.0);
+            result = rep[2];
+            gDecimal = result;;
+        }
+    }
+    return result;
+}
+
 // -------------------------------------
 
 /**
  * Currently, getDouble() depends on strtod() to do its conversion.
  *
  * WARNING!!
  * This is an extremely costly function. ~1/2 of the conversion time
  * can be linked to this function.
  */
 double
@@ skipping 76 matching lines @@
 
 // -------------------------------------
 
 /**
  *  convert this number to an int32_t.   Round if there is a fractional part.
  *  Return zero if the number cannot be represented.
  */
 int32_t DigitList::getLong() /*const*/
 {
     int32_t result = 0;
-    if (fDecNumber->digits + fDecNumber->exponent > 10) {
+    if (getUpperExponent() > 10) { 
         // Overflow, absolute value too big.
         return result;
     }
     if (fDecNumber->exponent != 0) {
         // Force to an integer, with zero exponent, rounding if necessary.
         //   (decNumberToInt32 will only work if the exponent is exactly zero.)
         DigitList copy(*this);
         DigitList zero;
         uprv_decNumberQuantize(copy.fDecNumber, copy.fDecNumber, zero.fDecNumber, &fContext);
         result = uprv_decNumberToInt32(copy.fDecNumber, &fContext);
     } else {
         result = uprv_decNumberToInt32(fDecNumber, &fContext);
     }
     return result;
 }
 
 
 /**
  *  convert this number to an int64_t.   Truncate if there is a fractional part.
  *  Return zero if the number cannot be represented.
  */
 int64_t DigitList::getInt64() /*const*/ {
     if(fHave==kInt64) {
       return fUnion.fInt64;
     } 
     // Truncate if non-integer.
     // Return 0 if out of range.
     // Range of in64_t is -9223372036854775808 to 9223372036854775807  (19 digits)
     //
-    if (fDecNumber->digits + fDecNumber->exponent > 19) {
+    if (getUpperExponent() > 19) { 
         // Overflow, absolute value too big.
         return 0;
     }
 
     // The number of integer digits may differ from the number of digits stored
     //   in the decimal number.
     //     for 12.345  numIntDigits = 2, number->digits = 5
     //     for 12E4    numIntDigits = 6, number->digits = 2
     // The conversion ignores the fraction digits in the first case,
     // and fakes up extra zero digits in the second.
     // TODO:  It would be faster to store a table of powers of ten to multiply by
     //        instead of looping over zero digits, multiplying each time.
 
-    int32_t numIntDigits = fDecNumber->digits + fDecNumber->exponent;
+    int32_t numIntDigits = getUpperExponent(); 
     uint64_t value = 0;
     for (int32_t i = 0; i < numIntDigits; i++) {
         // Loop is iterating over digits starting with the most significant.
         // Numbers are stored with the least significant digit at index zero.
         int32_t digitIndex = fDecNumber->digits - i - 1;
         int32_t v = (digitIndex >= 0) ? fDecNumber->lsu[digitIndex] : 0;
         value = value * (uint64_t)10 + (uint64_t)v;
     }
 
     if (decNumberIsNegative(fDecNumber)) {
@@ skipping 54 matching lines @@
     uprv_decNumberTrim(this->fDecNumber);
     if (fDecNumber->exponent < 0) {
         // Number contains fraction digits.
         return FALSE;
     }
     if (decNumberIsZero(this->fDecNumber) && !ignoreNegativeZero &&
         (fDecNumber->bits & DECNEG) != 0) {
         // Negative Zero, not ingored.  Cannot represent as a long.
         return FALSE;
     }
-    if (fDecNumber->digits + fDecNumber->exponent < 10) {
+    if (getUpperExponent() < 10) { 
         // The number is 9 or fewer digits.
         // The max and min int32 are 10 digts, so this number fits.
         // This is the common case.
         return TRUE;
     }
 
     // TODO:  Should cache these constants; construction is relatively costly.
     //        But not of huge consequence; they're only needed for 10 digit ints.
     UErrorCode status = U_ZERO_ERROR;
     DigitList min32; min32.set("-2147483648", status);
@@ skipping 26 matching lines @@
     uprv_decNumberTrim(this->fDecNumber);
     if (fDecNumber->exponent < 0) {
         // Number contains fraction digits.
         return FALSE;
     }
     if (decNumberIsZero(this->fDecNumber) && !ignoreNegativeZero &&
         (fDecNumber->bits & DECNEG) != 0) {
         // Negative Zero, not ingored.  Cannot represent as a long.
         return FALSE;
     }
-    if (fDecNumber->digits + fDecNumber->exponent < 19) {
+    if (getUpperExponent() < 19) { 
         // The number is 18 or fewer digits.
         // The max and min int64 are 19 digts, so this number fits.
         // This is the common case.
         return TRUE;
     }
 
     // TODO:  Should cache these constants; construction is relatively costly.
     //        But not of huge consequence; they're only needed for 19 digit ints.
     UErrorCode status = U_ZERO_ERROR;
     DigitList min64; min64.set("-9223372036854775808", status);
@@ skipping 153 matching lines @@
 // -------------------------------------
 
 /*
  * Multiply
  *      The number will be expanded if need be to retain full precision.
  *      In practice, for formatting, multiply is by 10, 100 or 1000, so more digits
  *      will not be required for this use.
  */
 void
 DigitList::mult(const DigitList &other, UErrorCode &status) {
+    if (U_FAILURE(status)) { 
+        return; 
+    } 
     fContext.status = 0;
     int32_t requiredDigits = this->digits() + other.digits();
     if (requiredDigits > fContext.digits) {
         reduce();    // Remove any trailing zeros
         int32_t requiredDigits = this->digits() + other.digits();
         ensureCapacity(requiredDigits, status);
     }
     uprv_decNumberMultiply(fDecNumber, fDecNumber, other.fDecNumber, &fContext);
     internalClear();
 }
@@ skipping 50 matching lines @@
 // -------------------------------------
 
 /**
  * Round the representation to the given number of digits.
  * @param maximumDigits The maximum number of digits to be shown.
  * Upon return, count will be less than or equal to maximumDigits.
  */
 void
 DigitList::round(int32_t maximumDigits)
 {
+    reduce(); 
+    if (maximumDigits >= fDecNumber->digits) { 
+        return; 
+    } 
     int32_t savedDigits  = fContext.digits;
     fContext.digits = maximumDigits;
     uprv_decNumberPlus(fDecNumber, fDecNumber, &fContext);
     fContext.digits = savedDigits;
     uprv_decNumberTrim(fDecNumber);
+    reduce(); 
     internalClear();
 }
 
 
 void
 DigitList::roundFixedPoint(int32_t maximumFractionDigits) {
-    trim();        // Remove trailing zeros.
+    reduce();        // Remove trailing zeros. 
     if (fDecNumber->exponent >= -maximumFractionDigits) {
         return;
     }
     decNumber scale;   // Dummy decimal number, but with the desired number of
     uprv_decNumberZero(&scale);    //    fraction digits.
     scale.exponent = -maximumFractionDigits;
     scale.lsu[0] = 1;
     
     uprv_decNumberQuantize(fDecNumber, fDecNumber, &scale, &fContext);
-    trim();
+    reduce(); 
     internalClear();
 }
 
 // -------------------------------------
 
 void
 DigitList::toIntegralValue() {
     uprv_decNumberToIntegralValue(fDecNumber, fDecNumber, &fContext);
 }
 
 
 // -------------------------------------
 UBool
 DigitList::isZero() const
 {
     return decNumberIsZero(fDecNumber);
 }
 
+// -------------------------------------
+int32_t
+DigitList::getUpperExponent() const {
+    return fDecNumber->digits + fDecNumber->exponent;
+}
+
+DigitInterval &
+DigitList::getSmallestInterval(DigitInterval &result) const {
+    result.setLeastSignificantInclusive(fDecNumber->exponent);
+    result.setMostSignificantExclusive(getUpperExponent());
+    return result;
+}
+
+uint8_t
+DigitList::getDigitByExponent(int32_t exponent) const {
+    int32_t idx = exponent - fDecNumber->exponent;
+    if (idx < 0 || idx >= fDecNumber->digits) {
+        return 0;
+    }
+    return fDecNumber->lsu[idx];
+}
+
+void
+DigitList::appendDigitsTo(CharString &str, UErrorCode &status) const {
+    str.append((const char *) fDecNumber->lsu, fDecNumber->digits, status);
+}
+
+void
+DigitList::roundAtExponent(int32_t exponent, int32_t maxSigDigits) {
+    reduce();
+    if (maxSigDigits < fDecNumber->digits) {
+        int32_t minExponent = getUpperExponent() - maxSigDigits;
+        if (exponent < minExponent) {
+            exponent = minExponent;
+        }
+    }
+    if (exponent <= fDecNumber->exponent) {
+        return;
+    }
+    int32_t digits = getUpperExponent() - exponent;
+    if (digits > 0) {
+        round(digits);
+    } else {
+        roundFixedPoint(-exponent);
+    }
+}
+
+void
+DigitList::quantize(const DigitList &quantity, UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+    div(quantity, status);
+    roundAtExponent(0);
+    mult(quantity, status);
+    reduce();
+}
+
+int32_t
+DigitList::getScientificExponent(
+        int32_t minIntDigitCount, int32_t exponentMultiplier) const {
+    // The exponent for zero is always zero.
+    if (isZero()) {
+        return 0;
+    }
+    int32_t intDigitCount = getUpperExponent();
+    int32_t exponent;
+    if (intDigitCount >= minIntDigitCount) {
+        int32_t maxAdjustment = intDigitCount - minIntDigitCount;
+        exponent = (maxAdjustment / exponentMultiplier) * exponentMultiplier;
+    } else {
+        int32_t minAdjustment = minIntDigitCount - intDigitCount;
+        exponent = ((minAdjustment + exponentMultiplier - 1) / exponentMultiplier) * -exponentMultiplier;
+    }
+    return exponent;
+}
+
+int32_t
+DigitList::toScientific(
+        int32_t minIntDigitCount, int32_t exponentMultiplier) {
+    int32_t exponent = getScientificExponent(
+            minIntDigitCount, exponentMultiplier);
+    shiftDecimalRight(-exponent);
+    return exponent;
+}
+
+void
+DigitList::shiftDecimalRight(int32_t n) {
+    fDecNumber->exponent += n;
+    internalClear();
+}
+
 U_NAMESPACE_END
 #endif // #if !UCONFIG_NO_FORMATTING
 
 //eof