diff options
Diffstat (limited to 'deps/icu-small/source/i18n/precision.h')
| -rw-r--r-- | deps/icu-small/source/i18n/precision.h | 321 |
1 files changed, 321 insertions, 0 deletions
diff --git a/deps/icu-small/source/i18n/precision.h b/deps/icu-small/source/i18n/precision.h new file mode 100644 index 0000000000..4543108cef --- /dev/null +++ b/deps/icu-small/source/i18n/precision.h @@ -0,0 +1,321 @@ +/* +******************************************************************************* +* 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__ |