You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
533 lines
19 KiB
533 lines
19 KiB
// © 2017 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
#ifndef __NUMBER_DECIMALQUANTITY_H__
|
|
#define __NUMBER_DECIMALQUANTITY_H__
|
|
|
|
#include <cstdint>
|
|
#include "unicode/umachine.h"
|
|
#include "standardplural.h"
|
|
#include "plurrule_impl.h"
|
|
#include "number_types.h"
|
|
|
|
U_NAMESPACE_BEGIN namespace number {
|
|
namespace impl {
|
|
|
|
// Forward-declare (maybe don't want number_utils.h included here):
|
|
class DecNum;
|
|
|
|
/**
|
|
* A class for representing a number to be processed by the decimal formatting pipeline. Includes
|
|
* methods for rounding, plural rules, and decimal digit extraction.
|
|
*
|
|
* <p>By design, this is NOT IMMUTABLE and NOT THREAD SAFE. It is intended to be an intermediate
|
|
* object holding state during a pass through the decimal formatting pipeline.
|
|
*
|
|
* <p>Represents numbers and digit display properties using Binary Coded Decimal (BCD).
|
|
*
|
|
* <p>Java has multiple implementations for testing, but C++ has only one implementation.
|
|
*/
|
|
class U_I18N_API DecimalQuantity : public IFixedDecimal, public UMemory {
|
|
public:
|
|
/** Copy constructor. */
|
|
DecimalQuantity(const DecimalQuantity &other);
|
|
|
|
/** Move constructor. */
|
|
DecimalQuantity(DecimalQuantity &&src) U_NOEXCEPT;
|
|
|
|
DecimalQuantity();
|
|
|
|
~DecimalQuantity() override;
|
|
|
|
/**
|
|
* Sets this instance to be equal to another instance.
|
|
*
|
|
* @param other The instance to copy from.
|
|
*/
|
|
DecimalQuantity &operator=(const DecimalQuantity &other);
|
|
|
|
/** Move assignment */
|
|
DecimalQuantity &operator=(DecimalQuantity&& src) U_NOEXCEPT;
|
|
|
|
/**
|
|
* Sets the minimum integer digits that this {@link DecimalQuantity} should generate.
|
|
* This method does not perform rounding.
|
|
*
|
|
* @param minInt The minimum number of integer digits.
|
|
*/
|
|
void setMinInteger(int32_t minInt);
|
|
|
|
/**
|
|
* Sets the minimum fraction digits that this {@link DecimalQuantity} should generate.
|
|
* This method does not perform rounding.
|
|
*
|
|
* @param minFrac The minimum number of fraction digits.
|
|
*/
|
|
void setMinFraction(int32_t minFrac);
|
|
|
|
/**
|
|
* Truncates digits from the upper magnitude of the number in order to satisfy the
|
|
* specified maximum number of integer digits.
|
|
*
|
|
* @param maxInt The maximum number of integer digits.
|
|
*/
|
|
void applyMaxInteger(int32_t maxInt);
|
|
|
|
/**
|
|
* Rounds the number to a specified interval, such as 0.05.
|
|
*
|
|
* <p>If rounding to a power of ten, use the more efficient {@link #roundToMagnitude} instead.
|
|
*
|
|
* @param roundingIncrement The increment to which to round.
|
|
* @param roundingMode The {@link RoundingMode} to use if rounding is necessary.
|
|
*/
|
|
void roundToIncrement(double roundingIncrement, RoundingMode roundingMode,
|
|
UErrorCode& status);
|
|
|
|
/** Removes all fraction digits. */
|
|
void truncate();
|
|
|
|
/**
|
|
* Rounds the number to the nearest multiple of 5 at the specified magnitude.
|
|
* For example, when magnitude == -2, this performs rounding to the nearest 0.05.
|
|
*
|
|
* @param magnitude The magnitude at which the digit should become either 0 or 5.
|
|
* @param roundingMode Rounding strategy.
|
|
*/
|
|
void roundToNickel(int32_t magnitude, RoundingMode roundingMode, UErrorCode& status);
|
|
|
|
/**
|
|
* Rounds the number to a specified magnitude (power of ten).
|
|
*
|
|
* @param roundingMagnitude The power of ten to which to round. For example, a value of -2 will
|
|
* round to 2 decimal places.
|
|
* @param roundingMode The {@link RoundingMode} to use if rounding is necessary.
|
|
*/
|
|
void roundToMagnitude(int32_t magnitude, RoundingMode roundingMode, UErrorCode& status);
|
|
|
|
/**
|
|
* Rounds the number to an infinite number of decimal points. This has no effect except for
|
|
* forcing the double in {@link DecimalQuantity_AbstractBCD} to adopt its exact representation.
|
|
*/
|
|
void roundToInfinity();
|
|
|
|
/**
|
|
* Multiply the internal value. Uses decNumber.
|
|
*
|
|
* @param multiplicand The value by which to multiply.
|
|
*/
|
|
void multiplyBy(const DecNum& multiplicand, UErrorCode& status);
|
|
|
|
/**
|
|
* Divide the internal value. Uses decNumber.
|
|
*
|
|
* @param multiplicand The value by which to multiply.
|
|
*/
|
|
void divideBy(const DecNum& divisor, UErrorCode& status);
|
|
|
|
/** Flips the sign from positive to negative and back. */
|
|
void negate();
|
|
|
|
/**
|
|
* Scales the number by a power of ten. For example, if the value is currently "1234.56", calling
|
|
* this method with delta=-3 will change the value to "1.23456".
|
|
*
|
|
* @param delta The number of magnitudes of ten to change by.
|
|
* @return true if integer overflow occured; false otherwise.
|
|
*/
|
|
bool adjustMagnitude(int32_t delta);
|
|
|
|
/**
|
|
* @return The power of ten corresponding to the most significant nonzero digit.
|
|
* The number must not be zero.
|
|
*/
|
|
int32_t getMagnitude() const;
|
|
|
|
/**
|
|
* @return The value of the (suppressed) exponent after the number has been
|
|
* put into a notation with exponents (ex: compact, scientific). Ex: given
|
|
* the number 1000 as "1K" / "1E3", the return value will be 3 (positive).
|
|
*/
|
|
int32_t getExponent() const;
|
|
|
|
/**
|
|
* Adjusts the value for the (suppressed) exponent stored when using
|
|
* notation with exponents (ex: compact, scientific).
|
|
*
|
|
* <p>Adjusting the exponent is decoupled from {@link #adjustMagnitude} in
|
|
* order to allow flexibility for {@link StandardPlural} to be selected in
|
|
* formatting (ex: for compact notation) either with or without the exponent
|
|
* applied in the value of the number.
|
|
* @param delta
|
|
* The value to adjust the exponent by.
|
|
*/
|
|
void adjustExponent(int32_t delta);
|
|
|
|
/**
|
|
* @return Whether the value represented by this {@link DecimalQuantity} is
|
|
* zero, infinity, or NaN.
|
|
*/
|
|
bool isZeroish() const;
|
|
|
|
/** @return Whether the value represented by this {@link DecimalQuantity} is less than zero. */
|
|
bool isNegative() const;
|
|
|
|
/** @return The appropriate value from the Signum enum. */
|
|
Signum signum() const;
|
|
|
|
/** @return Whether the value represented by this {@link DecimalQuantity} is infinite. */
|
|
bool isInfinite() const U_OVERRIDE;
|
|
|
|
/** @return Whether the value represented by this {@link DecimalQuantity} is not a number. */
|
|
bool isNaN() const U_OVERRIDE;
|
|
|
|
/**
|
|
* Note: this method incorporates the value of {@code exponent}
|
|
* (for cases such as compact notation) to return the proper long value
|
|
* represented by the result.
|
|
* @param truncateIfOverflow if false and the number does NOT fit, fails with an assertion error.
|
|
*/
|
|
int64_t toLong(bool truncateIfOverflow = false) const;
|
|
|
|
/**
|
|
* Note: this method incorporates the value of {@code exponent}
|
|
* (for cases such as compact notation) to return the proper long value
|
|
* represented by the result.
|
|
*/
|
|
uint64_t toFractionLong(bool includeTrailingZeros) const;
|
|
|
|
/**
|
|
* Returns whether or not a Long can fully represent the value stored in this DecimalQuantity.
|
|
* @param ignoreFraction if true, silently ignore digits after the decimal place.
|
|
*/
|
|
bool fitsInLong(bool ignoreFraction = false) const;
|
|
|
|
/** @return The value contained in this {@link DecimalQuantity} approximated as a double. */
|
|
double toDouble() const;
|
|
|
|
/** Computes a DecNum representation of this DecimalQuantity, saving it to the output parameter. */
|
|
DecNum& toDecNum(DecNum& output, UErrorCode& status) const;
|
|
|
|
DecimalQuantity &setToInt(int32_t n);
|
|
|
|
DecimalQuantity &setToLong(int64_t n);
|
|
|
|
DecimalQuantity &setToDouble(double n);
|
|
|
|
/**
|
|
* Produces a DecimalQuantity that was parsed from a string by the decNumber
|
|
* C Library.
|
|
*
|
|
* decNumber is similar to BigDecimal in Java, and supports parsing strings
|
|
* such as "123.456621E+40".
|
|
*/
|
|
DecimalQuantity &setToDecNumber(StringPiece n, UErrorCode& status);
|
|
|
|
/** Internal method if the caller already has a DecNum. */
|
|
DecimalQuantity &setToDecNum(const DecNum& n, UErrorCode& status);
|
|
|
|
/**
|
|
* Appends a digit, optionally with one or more leading zeros, to the end of the value represented
|
|
* by this DecimalQuantity.
|
|
*
|
|
* <p>The primary use of this method is to construct numbers during a parsing loop. It allows
|
|
* parsing to take advantage of the digit list infrastructure primarily designed for formatting.
|
|
*
|
|
* @param value The digit to append.
|
|
* @param leadingZeros The number of zeros to append before the digit. For example, if the value
|
|
* in this instance starts as 12.3, and you append a 4 with 1 leading zero, the value becomes
|
|
* 12.304.
|
|
* @param appendAsInteger If true, increase the magnitude of existing digits to make room for the
|
|
* new digit. If false, append to the end like a fraction digit. If true, there must not be
|
|
* any fraction digits already in the number.
|
|
* @internal
|
|
* @deprecated This API is ICU internal only.
|
|
*/
|
|
void appendDigit(int8_t value, int32_t leadingZeros, bool appendAsInteger);
|
|
|
|
double getPluralOperand(PluralOperand operand) const U_OVERRIDE;
|
|
|
|
bool hasIntegerValue() const U_OVERRIDE;
|
|
|
|
/**
|
|
* Gets the digit at the specified magnitude. For example, if the represented number is 12.3,
|
|
* getDigit(-1) returns 3, since 3 is the digit corresponding to 10^-1.
|
|
*
|
|
* @param magnitude The magnitude of the digit.
|
|
* @return The digit at the specified magnitude.
|
|
*/
|
|
int8_t getDigit(int32_t magnitude) const;
|
|
|
|
/**
|
|
* Gets the largest power of ten that needs to be displayed. The value returned by this function
|
|
* will be bounded between minInt and maxInt.
|
|
*
|
|
* @return The highest-magnitude digit to be displayed.
|
|
*/
|
|
int32_t getUpperDisplayMagnitude() const;
|
|
|
|
/**
|
|
* Gets the smallest power of ten that needs to be displayed. The value returned by this function
|
|
* will be bounded between -minFrac and -maxFrac.
|
|
*
|
|
* @return The lowest-magnitude digit to be displayed.
|
|
*/
|
|
int32_t getLowerDisplayMagnitude() const;
|
|
|
|
int32_t fractionCount() const;
|
|
|
|
int32_t fractionCountWithoutTrailingZeros() const;
|
|
|
|
void clear();
|
|
|
|
/** This method is for internal testing only. */
|
|
uint64_t getPositionFingerprint() const;
|
|
|
|
// /**
|
|
// * If the given {@link FieldPosition} is a {@link UFieldPosition}, populates it with the fraction
|
|
// * length and fraction long value. If the argument is not a {@link UFieldPosition}, nothing
|
|
// * happens.
|
|
// *
|
|
// * @param fp The {@link UFieldPosition} to populate.
|
|
// */
|
|
// void populateUFieldPosition(FieldPosition fp);
|
|
|
|
/**
|
|
* Checks whether the bytes stored in this instance are all valid. For internal unit testing only.
|
|
*
|
|
* @return An error message if this instance is invalid, or null if this instance is healthy.
|
|
*/
|
|
const char16_t* checkHealth() const;
|
|
|
|
UnicodeString toString() const;
|
|
|
|
/** Returns the string in standard exponential notation. */
|
|
UnicodeString toScientificString() const;
|
|
|
|
/** Returns the string without exponential notation. Slightly slower than toScientificString(). */
|
|
UnicodeString toPlainString() const;
|
|
|
|
/** Visible for testing */
|
|
inline bool isUsingBytes() { return usingBytes; }
|
|
|
|
/** Visible for testing */
|
|
inline bool isExplicitExactDouble() { return explicitExactDouble; }
|
|
|
|
bool operator==(const DecimalQuantity& other) const;
|
|
|
|
inline bool operator!=(const DecimalQuantity& other) const {
|
|
return !(*this == other);
|
|
}
|
|
|
|
/**
|
|
* Bogus flag for when a DecimalQuantity is stored on the stack.
|
|
*/
|
|
bool bogus = false;
|
|
|
|
private:
|
|
/**
|
|
* The power of ten corresponding to the least significant digit in the BCD. For example, if this
|
|
* object represents the number "3.14", the BCD will be "0x314" and the scale will be -2.
|
|
*
|
|
* <p>Note that in {@link java.math.BigDecimal}, the scale is defined differently: the number of
|
|
* digits after the decimal place, which is the negative of our definition of scale.
|
|
*/
|
|
int32_t scale;
|
|
|
|
/**
|
|
* The number of digits in the BCD. For example, "1007" has BCD "0x1007" and precision 4. The
|
|
* maximum precision is 16 since a long can hold only 16 digits.
|
|
*
|
|
* <p>This value must be re-calculated whenever the value in bcd changes by using {@link
|
|
* #computePrecisionAndCompact()}.
|
|
*/
|
|
int32_t precision;
|
|
|
|
/**
|
|
* A bitmask of properties relating to the number represented by this object.
|
|
*
|
|
* @see #NEGATIVE_FLAG
|
|
* @see #INFINITY_FLAG
|
|
* @see #NAN_FLAG
|
|
*/
|
|
int8_t flags;
|
|
|
|
// The following three fields relate to the double-to-ascii fast path algorithm.
|
|
// When a double is given to DecimalQuantityBCD, it is converted to using a fast algorithm. The
|
|
// fast algorithm guarantees correctness to only the first ~12 digits of the double. The process
|
|
// of rounding the number ensures that the converted digits are correct, falling back to a slow-
|
|
// path algorithm if required. Therefore, if a DecimalQuantity is constructed from a double, it
|
|
// is *required* that roundToMagnitude(), roundToIncrement(), or roundToInfinity() is called. If
|
|
// you don't round, assertions will fail in certain other methods if you try calling them.
|
|
|
|
/**
|
|
* Whether the value in the BCD comes from the double fast path without having been rounded to
|
|
* ensure correctness
|
|
*/
|
|
UBool isApproximate;
|
|
|
|
/**
|
|
* The original number provided by the user and which is represented in BCD. Used when we need to
|
|
* re-compute the BCD for an exact double representation.
|
|
*/
|
|
double origDouble;
|
|
|
|
/**
|
|
* The change in magnitude relative to the original double. Used when we need to re-compute the
|
|
* BCD for an exact double representation.
|
|
*/
|
|
int32_t origDelta;
|
|
|
|
// Positions to keep track of leading and trailing zeros.
|
|
// lReqPos is the magnitude of the first required leading zero.
|
|
// rReqPos is the magnitude of the last required trailing zero.
|
|
int32_t lReqPos = 0;
|
|
int32_t rReqPos = 0;
|
|
|
|
// The value of the (suppressed) exponent after the number has been put into
|
|
// a notation with exponents (ex: compact, scientific).
|
|
int32_t exponent = 0;
|
|
|
|
/**
|
|
* The BCD of the 16 digits of the number represented by this object. Every 4 bits of the long map
|
|
* to one digit. For example, the number "12345" in BCD is "0x12345".
|
|
*
|
|
* <p>Whenever bcd changes internally, {@link #compact()} must be called, except in special cases
|
|
* like setting the digit to zero.
|
|
*/
|
|
union {
|
|
struct {
|
|
int8_t *ptr;
|
|
int32_t len;
|
|
} bcdBytes;
|
|
uint64_t bcdLong;
|
|
} fBCD;
|
|
|
|
bool usingBytes = false;
|
|
|
|
/**
|
|
* Whether this {@link DecimalQuantity} has been explicitly converted to an exact double. true if
|
|
* backed by a double that was explicitly converted via convertToAccurateDouble; false otherwise.
|
|
* Used for testing.
|
|
*/
|
|
bool explicitExactDouble = false;
|
|
|
|
void roundToMagnitude(int32_t magnitude, RoundingMode roundingMode, bool nickel, UErrorCode& status);
|
|
|
|
/**
|
|
* Returns a single digit from the BCD list. No internal state is changed by calling this method.
|
|
*
|
|
* @param position The position of the digit to pop, counted in BCD units from the least
|
|
* significant digit. If outside the range supported by the implementation, zero is returned.
|
|
* @return The digit at the specified location.
|
|
*/
|
|
int8_t getDigitPos(int32_t position) const;
|
|
|
|
/**
|
|
* Sets the digit in the BCD list. This method only sets the digit; it is the caller's
|
|
* responsibility to call {@link #compact} after setting the digit.
|
|
*
|
|
* @param position The position of the digit to pop, counted in BCD units from the least
|
|
* significant digit. If outside the range supported by the implementation, an AssertionError
|
|
* is thrown.
|
|
* @param value The digit to set at the specified location.
|
|
*/
|
|
void setDigitPos(int32_t position, int8_t value);
|
|
|
|
/**
|
|
* Adds zeros to the end of the BCD list. This will result in an invalid BCD representation; it is
|
|
* the caller's responsibility to do further manipulation and then call {@link #compact}.
|
|
*
|
|
* @param numDigits The number of zeros to add.
|
|
*/
|
|
void shiftLeft(int32_t numDigits);
|
|
|
|
/**
|
|
* Directly removes digits from the end of the BCD list.
|
|
* Updates the scale and precision.
|
|
*
|
|
* CAUTION: it is the caller's responsibility to call {@link #compact} after this method.
|
|
*/
|
|
void shiftRight(int32_t numDigits);
|
|
|
|
/**
|
|
* Directly removes digits from the front of the BCD list.
|
|
* Updates precision.
|
|
*
|
|
* CAUTION: it is the caller's responsibility to call {@link #compact} after this method.
|
|
*/
|
|
void popFromLeft(int32_t numDigits);
|
|
|
|
/**
|
|
* Sets the internal representation to zero. Clears any values stored in scale, precision,
|
|
* hasDouble, origDouble, origDelta, exponent, and BCD data.
|
|
*/
|
|
void setBcdToZero();
|
|
|
|
/**
|
|
* Sets the internal BCD state to represent the value in the given int. The int is guaranteed to
|
|
* be either positive. The internal state is guaranteed to be empty when this method is called.
|
|
*
|
|
* @param n The value to consume.
|
|
*/
|
|
void readIntToBcd(int32_t n);
|
|
|
|
/**
|
|
* Sets the internal BCD state to represent the value in the given long. The long is guaranteed to
|
|
* be either positive. The internal state is guaranteed to be empty when this method is called.
|
|
*
|
|
* @param n The value to consume.
|
|
*/
|
|
void readLongToBcd(int64_t n);
|
|
|
|
void readDecNumberToBcd(const DecNum& dn);
|
|
|
|
void readDoubleConversionToBcd(const char* buffer, int32_t length, int32_t point);
|
|
|
|
void copyFieldsFrom(const DecimalQuantity& other);
|
|
|
|
void copyBcdFrom(const DecimalQuantity &other);
|
|
|
|
void moveBcdFrom(DecimalQuantity& src);
|
|
|
|
/**
|
|
* Removes trailing zeros from the BCD (adjusting the scale as required) and then computes the
|
|
* precision. The precision is the number of digits in the number up through the greatest nonzero
|
|
* digit.
|
|
*
|
|
* <p>This method must always be called when bcd changes in order for assumptions to be correct in
|
|
* methods like {@link #fractionCount()}.
|
|
*/
|
|
void compact();
|
|
|
|
void _setToInt(int32_t n);
|
|
|
|
void _setToLong(int64_t n);
|
|
|
|
void _setToDoubleFast(double n);
|
|
|
|
void _setToDecNum(const DecNum& dn, UErrorCode& status);
|
|
|
|
void convertToAccurateDouble();
|
|
|
|
/** Ensure that a byte array of at least 40 digits is allocated. */
|
|
void ensureCapacity();
|
|
|
|
void ensureCapacity(int32_t capacity);
|
|
|
|
/** Switches the internal storage mechanism between the 64-bit long and the byte array. */
|
|
void switchStorage();
|
|
};
|
|
|
|
} // namespace impl
|
|
} // namespace number
|
|
U_NAMESPACE_END
|
|
|
|
|
|
#endif //__NUMBER_DECIMALQUANTITY_H__
|
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|