ICU 56 update step 1

source/i18n/precision.h

+/*
+*******************************************************************************
+* Copyright (C) 2015, International Business Machines
+* Corporation and others.  All Rights Reserved.
+*******************************************************************************
+* precision.h
+*
+* created on: 2015jan06
+* created by: Travis Keep
+*/
+
+#ifndef __PRECISION_H__
+#define __PRECISION_H__
+
+#include "unicode/uobject.h"
+
+#if !UCONFIG_NO_FORMATTING
+#include "unicode/utypes.h"
+
+#include "digitinterval.h"
+#include "digitlst.h"
+#include "significantdigitinterval.h"
+
+U_NAMESPACE_BEGIN
+
+class VisibleDigits;
+class VisibleDigitsWithExponent;
+
+
+/**
+ * A precision manager for values to be formatted as fixed point.
+ * Handles rounding of number to prepare it for formatting.
+ */
+class U_I18N_API FixedPrecision : public UMemory {
+public:
+
+    /**
+     * The smallest format interval allowed. Default is 1 integer digit and no
+     * fraction digits.
+     */
+    DigitInterval fMin;
+
+    /**
+     * The largest format interval allowed. Must contain fMin.
+     *  Default is all digits.
+     */
+    DigitInterval fMax;
+
+    /**
+     * Min and max significant digits allowed. The default is no constraints.
+     */
+    SignificantDigitInterval fSignificant;
+
+    /**
+     * The rounding increment or zero if there is no rounding increment.
+     * Default is zero.
+     */
+    DigitList fRoundingIncrement;
+    
+    /**
+     * If set, causes round() to set status to U_FORMAT_INEXACT_ERROR if
+     * any rounding is done. Default is FALSE.
+     */
+    UBool fExactOnly;
+    
+    /**
+     * If set, causes round() to set status to U_ILLEGAL_ARGUMENT_ERROR if
+     * rounded number has more than maximum integer digits. Default is FALSE.
+     */
+    UBool fFailIfOverMax;
+    
+    /**
+     * Controls the rounding mode that initVisibleDigits uses.
+     * Default is DecimalFormat::kRoundHalfEven
+     */
+    DecimalFormat::ERoundingMode fRoundingMode;
+    
+    FixedPrecision();
+    
+    /**
+     * Returns TRUE if this object equals rhs.
+     */
+    UBool equals(const FixedPrecision &rhs) const {
+        return (fMin.equals(rhs.fMin) &&
+                fMax.equals(rhs.fMax) &&
+                fSignificant.equals(rhs.fSignificant) &&
+                (fRoundingIncrement == rhs.fRoundingIncrement) &&
+                fExactOnly == rhs.fExactOnly &&
+                fFailIfOverMax == rhs.fFailIfOverMax &&
+                fRoundingMode == rhs.fRoundingMode);
+    }
+    
+    /**
+     * Rounds value in place to prepare it for formatting.
+     * @param value The value to be rounded. It is rounded in place.
+     * @param exponent Always pass 0 for fixed decimal formatting. scientific
+     *  precision passes the exponent value.  Essentially, it divides value by
+     *  10^exponent, rounds and then multiplies by 10^exponent.
+     * @param status error returned here.
+     * @return reference to value.
+     */
+    DigitList &round(DigitList &value, int32_t exponent, UErrorCode &status) const;
+    
+    /**
+     * Returns the interval to use to format the rounded value.
+     * @param roundedValue the already rounded value to format.
+     * @param interval modified in place to be the interval to use to format
+     *   the rounded value.
+     * @return a reference to interval.
+     */
+    DigitInterval &getInterval(
+            const DigitList &roundedValue, DigitInterval &interval) const;
+    
+    /**
+     * Returns TRUE if this instance allows for fast formatting of integers.
+     */
+    UBool isFastFormattable() const;
+    
+    /**
+     * Initializes a VisibleDigits.
+     * @param value value for VisibleDigits
+     *    Caller must not assume that the value of this parameter will remain
+     *    unchanged.
+     * @param digits This is the value that is initialized.
+     * @param status any error returned here.
+     * @return digits
+     */
+    VisibleDigits &initVisibleDigits(
+            DigitList &value,
+            VisibleDigits &digits,
+            UErrorCode &status) const;
+    
+    /**
+     * Initializes a VisibleDigits.
+     * @param value value for VisibleDigits
+     * @param digits This is the value that is initialized.
+     * @param status any error returned here.
+     * @return digits
+     */
+    VisibleDigits &initVisibleDigits(
+            double value,
+            VisibleDigits &digits,
+            UErrorCode &status) const;
+    
+    /**
+     * Initializes a VisibleDigits.
+     * @param value value for VisibleDigits
+     * @param digits This is the value that is initialized.
+     * @param status any error returned here.
+     * @return digits
+     */
+    VisibleDigits &initVisibleDigits(
+            int64_t value,
+            VisibleDigits &digits,
+            UErrorCode &status) const;
+    
+    /**
+     * Initializes a VisibleDigitsWithExponent.
+     * @param value value for VisibleDigits
+     *    Caller must not assume that the value of this parameter will remain
+     *    unchanged.
+     * @param digits This is the value that is initialized.
+     * @param status any error returned here.
+     * @return digits
+     */
+    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
+            DigitList &value,
+            VisibleDigitsWithExponent &digits,
+            UErrorCode &status) const;
+    
+    /**
+     * Initializes a VisibleDigitsWithExponent.
+     * @param value value for VisibleDigits
+     * @param digits This is the value that is initialized.
+     * @param status any error returned here.
+     * @return digits
+     */
+    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
+            double value,
+            VisibleDigitsWithExponent &digits,
+            UErrorCode &status) const;
+    
+    /**
+     * Initializes a VisibleDigitsWithExponent.
+     * @param value value for VisibleDigits
+     * @param digits This is the value that is initialized.
+     * @param status any error returned here.
+     * @return digits
+     */
+    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
+            int64_t value,
+            VisibleDigitsWithExponent &digits,
+            UErrorCode &status) const;
+    
+private:
+    /**
+     * Attempts to initialize 'digits' using simple mod 10 arithmetic.
+     * Returns FALSE if this is not possible such as when rounding
+     * would change the value. Otherwise returns TRUE.
+     *
+     * If the method returns FALSE, caller should create a DigitList
+     * and use it to initialize 'digits'. If this method returns TRUE,
+     * caller should accept the value stored in 'digits'. If this
+     * method returns TRUE along with a non zero error, caller must accept
+     * the error and not try again with a DigitList.
+     *
+     * Before calling this method, caller must verify that this object
+     * has no rounding increment set.
+     *
+     * The value that 'digits' is initialized to is mantissa * 10^exponent.
+     * For example mantissa = 54700 and exponent = -3 means 54.7. The
+     * properties of this object (such as min and max fraction digits),
+     * not the number of trailing zeros in the mantissa, determine whether or
+     * not the result contains any trailing 0's after the decimal point.
+     *
+     * @param mantissa the digits. May be positive or negative. May contain
+     *  trailing zeros.
+     * @param exponent must always be zero or negative. An exponent > 0
+     *  yields undefined results! 
+     * @param digits result stored here.
+     * @param status any error returned here.
+     */
+    UBool
+    initVisibleDigits(
+            int64_t mantissa,
+            int32_t exponent,
+            VisibleDigits &digits,
+            UErrorCode &status) const;
+    UBool isRoundingRequired(
+            int32_t upperExponent, int32_t lowerExponent) const;
+    DigitInterval &getIntervalForZero(DigitInterval &interval) const;
+    DigitInterval &getInterval(
+            int32_t upperExponent, DigitInterval &interval) const;
+    static UBool handleNonNumeric(DigitList &value, VisibleDigits &digits);
+    
+    friend class ScientificPrecision;
+};
+
+/**
+ * A precision manager for values to be expressed as scientific notation.
+ */
+class U_I18N_API ScientificPrecision : public UMemory {
+public:
+    FixedPrecision fMantissa;
+    int32_t fMinExponentDigits;
+
+    ScientificPrecision();
+
+    /**
+     * rounds value in place to prepare it for formatting.
+     * @param value The value to be rounded. It is rounded in place.
+     * @param status error returned here.
+     * @return reference to value.
+     */
+    DigitList &round(DigitList &value, UErrorCode &status) const;
+
+    /**
+     * Converts value to a mantissa and exponent.
+     *
+     * @param value modified in place to be the mantissa. Depending on
+     *   the precision settings, the resulting mantissa may not fall
+     *   between 1.0 and 10.0.
+     * @return the exponent of value.
+     */
+    int32_t toScientific(DigitList &value) const;
+
+    /**
+     * Returns TRUE if this object equals rhs.
+     */
+    UBool equals(const ScientificPrecision &rhs) const {
+        return fMantissa.equals(rhs.fMantissa) && fMinExponentDigits == rhs.fMinExponentDigits;
+    }
+
+    /**
+     * Initializes a VisibleDigitsWithExponent.
+     * @param value the value
+     *    Caller must not assume that the value of this parameter will remain
+     *    unchanged.
+     * @param digits This is the value that is initialized.
+     * @param status any error returned here.
+     * @return digits
+     */
+    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
+            DigitList &value,
+            VisibleDigitsWithExponent &digits,
+            UErrorCode &status) const;
+    
+    /**
+     * Initializes a VisibleDigitsWithExponent.
+     * @param value the value
+     * @param digits This is the value that is initialized.
+     * @param status any error returned here.
+     * @return digits
+     */
+    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
+            double value,
+            VisibleDigitsWithExponent &digits,
+            UErrorCode &status) const;
+    
+    /**
+     * Initializes a VisibleDigitsWithExponent.
+     * @param value the value
+     * @param digits This is the value that is initialized.
+     * @param status any error returned here.
+     * @return digits
+     */
+    VisibleDigitsWithExponent &initVisibleDigitsWithExponent(
+            int64_t value,
+            VisibleDigitsWithExponent &digits,
+            UErrorCode &status) const;
+    
+private:
+    int32_t getMultiplier() const;
+
+};
+
+
+
+U_NAMESPACE_END
+#endif // #if !UCONFIG_NO_FORMATTING
+#endif  // __PRECISION_H__