| /* |
| ******************************************************************************* |
| * 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__ |
