322 lines
10 KiB
C++
322 lines
10 KiB
C++
/*
|
|
*******************************************************************************
|
|
* 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__
|