[apple/icu.git] / icuSources / i18n / number_roundingutils.h

// © 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_ROUNDINGUTILS_H__
#define __NUMBER_ROUNDINGUTILS_H__

#include "number_types.h"

U_NAMESPACE_BEGIN
namespace number {
namespace impl {
namespace roundingutils {

enum Section {
    SECTION_LOWER_EDGE = -1,
    SECTION_UPPER_EDGE = -2,
    SECTION_LOWER = 1,
    SECTION_MIDPOINT = 2,
    SECTION_UPPER = 3
};

/**
 * Converts a rounding mode and metadata about the quantity being rounded to a boolean determining
 * whether the value should be rounded toward infinity or toward zero.
 *
 * <p>The parameters are of type int because benchmarks on an x86-64 processor against OpenJDK
 * showed that ints were demonstrably faster than enums in switch statements.
 *
 * @param isEven Whether the digit immediately before the rounding magnitude is even.
 * @param isNegative Whether the quantity is negative.
 * @param section Whether the part of the quantity to the right of the rounding magnitude is
 *     exactly halfway between two digits, whether it is in the lower part (closer to zero), or
 *     whether it is in the upper part (closer to infinity). See {@link #SECTION_LOWER}, {@link
 *     #SECTION_MIDPOINT}, and {@link #SECTION_UPPER}.
 * @param roundingMode The integer version of the {@link RoundingMode}, which you can get via
 *     {@link RoundingMode#ordinal}.
 * @param status Error code, set to U_FORMAT_INEXACT_ERROR if the rounding mode is kRoundUnnecessary.
 * @return true if the number should be rounded toward zero; false if it should be rounded toward
 *     infinity.
 */
inline bool
getRoundingDirection(bool isEven, bool isNegative, Section section, RoundingMode roundingMode,
                     UErrorCode &status) {
    switch (roundingMode) {
        case RoundingMode::UNUM_ROUND_UP:
            // round away from zero
            return false;

        case RoundingMode::UNUM_ROUND_DOWN:
            // round toward zero
            return true;

        case RoundingMode::UNUM_ROUND_CEILING:
            // round toward positive infinity
            return isNegative;

        case RoundingMode::UNUM_ROUND_FLOOR:
            // round toward negative infinity
            return !isNegative;

        case RoundingMode::UNUM_ROUND_HALFUP:
            switch (section) {
                case SECTION_MIDPOINT:
                    return false;
                case SECTION_LOWER:
                    return true;
                case SECTION_UPPER:
                    return false;
                default:
                    break;
            }
            break;

        case RoundingMode::UNUM_ROUND_HALFDOWN:
            switch (section) {
                case SECTION_MIDPOINT:
                    return true;
                case SECTION_LOWER:
                    return true;
                case SECTION_UPPER:
                    return false;
                default:
                    break;
            }
            break;

        case RoundingMode::UNUM_ROUND_HALFEVEN:
            switch (section) {
                case SECTION_MIDPOINT:
                    return isEven;
                case SECTION_LOWER:
                    return true;
                case SECTION_UPPER:
                    return false;
                default:
                    break;
            }
            break;

        default:
            break;
    }

    status = U_FORMAT_INEXACT_ERROR;
    return false;
}

/**
 * Gets whether the given rounding mode's rounding boundary is at the midpoint. The rounding
 * boundary is the point at which a number switches from being rounded down to being rounded up.
 * For example, with rounding mode HALF_EVEN, HALF_UP, or HALF_DOWN, the rounding boundary is at
 * the midpoint, and this function would return true. However, for UP, DOWN, CEILING, and FLOOR,
 * the rounding boundary is at the "edge", and this function would return false.
 *
 * @param roundingMode The integer version of the {@link RoundingMode}.
 * @return true if rounding mode is HALF_EVEN, HALF_UP, or HALF_DOWN; false otherwise.
 */
inline bool roundsAtMidpoint(int roundingMode) {
    switch (roundingMode) {
        case RoundingMode::UNUM_ROUND_UP:
        case RoundingMode::UNUM_ROUND_DOWN:
        case RoundingMode::UNUM_ROUND_CEILING:
        case RoundingMode::UNUM_ROUND_FLOOR:
            return false;

        default:
            return true;
    }
}

/**
 * Computes the number of fraction digits in a double. Used for computing maxFrac for an increment.
 * Calls into the DoubleToStringConverter library to do so.
 *
 * @param singleDigit An output parameter; set to a number if that is the
 *        only digit in the double, or -1 if there is more than one digit.
 */
digits_t doubleFractionLength(double input, int8_t* singleDigit);

} // namespace roundingutils


/**
 * Encapsulates a Precision and a RoundingMode and performs rounding on a DecimalQuantity.
 *
 * This class does not exist in Java: instead, the base Precision class is used.
 */
class RoundingImpl {
  public:
    RoundingImpl() = default;  // default constructor: leaves object in undefined state

    RoundingImpl(const Precision& precision, UNumberFormatRoundingMode roundingMode,
                 const CurrencyUnit& currency, UErrorCode& status);

    static RoundingImpl passThrough();

    /** Required for ScientificFormatter */
    bool isSignificantDigits() const;

    /**
     * Rounding endpoint used by Engineering and Compact notation. Chooses the most appropriate multiplier (magnitude
     * adjustment), applies the adjustment, rounds, and returns the chosen multiplier.
     *
     * <p>
     * In most cases, this is simple. However, when rounding the number causes it to cross a multiplier boundary, we
     * need to re-do the rounding. For example, to display 999,999 in Engineering notation with 2 sigfigs, first you
     * guess the multiplier to be -3. However, then you end up getting 1000E3, which is not the correct output. You then
     * change your multiplier to be -6, and you get 1.0E6, which is correct.
     *
     * @param input The quantity to process.
     * @param producer Function to call to return a multiplier based on a magnitude.
     * @return The number of orders of magnitude the input was adjusted by this method.
     */
    int32_t
    chooseMultiplierAndApply(impl::DecimalQuantity &input, const impl::MultiplierProducer &producer,
                             UErrorCode &status);

    void apply(impl::DecimalQuantity &value, UErrorCode &status) const;

    /** Version of {@link #apply} that obeys minInt constraints. Used for scientific notation compatibility mode. */
    void apply(impl::DecimalQuantity &value, int32_t minInt, UErrorCode status);

  private:
    Precision fPrecision;
    UNumberFormatRoundingMode fRoundingMode;
    bool fPassThrough;
};


} // namespace impl
} // namespace number
U_NAMESPACE_END

#endif //__NUMBER_ROUNDINGUTILS_H__

#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
0f5d89e8 A	1	// © 2017 and later: Unicode, Inc. and others.
	2	// License & terms of use: http://www.unicode.org/copyright.html
	3
	4	#include "unicode/utypes.h"
	5
	6	#if !UCONFIG_NO_FORMATTING
	7	#ifndef __NUMBER_ROUNDINGUTILS_H__
	8	#define __NUMBER_ROUNDINGUTILS_H__
	9
	10	#include "number_types.h"
	11
	12	U_NAMESPACE_BEGIN
	13	namespace number {
	14	namespace impl {
	15	namespace roundingutils {
	16
	17	enum Section {
	18	SECTION_LOWER_EDGE = -1,
	19	SECTION_UPPER_EDGE = -2,
	20	SECTION_LOWER = 1,
	21	SECTION_MIDPOINT = 2,
	22	SECTION_UPPER = 3
	23	};
	24
	25	/**
	26	* Converts a rounding mode and metadata about the quantity being rounded to a boolean determining
	27	* whether the value should be rounded toward infinity or toward zero.
	28	*
	29	* <p>The parameters are of type int because benchmarks on an x86-64 processor against OpenJDK
	30	* showed that ints were demonstrably faster than enums in switch statements.
	31	*
	32	* @param isEven Whether the digit immediately before the rounding magnitude is even.
	33	* @param isNegative Whether the quantity is negative.
	34	* @param section Whether the part of the quantity to the right of the rounding magnitude is
	35	* exactly halfway between two digits, whether it is in the lower part (closer to zero), or
	36	* whether it is in the upper part (closer to infinity). See {@link #SECTION_LOWER}, {@link
	37	* #SECTION_MIDPOINT}, and {@link #SECTION_UPPER}.
	38	* @param roundingMode The integer version of the {@link RoundingMode}, which you can get via
	39	* {@link RoundingMode#ordinal}.
	40	* @param status Error code, set to U_FORMAT_INEXACT_ERROR if the rounding mode is kRoundUnnecessary.
	41	* @return true if the number should be rounded toward zero; false if it should be rounded toward
	42	* infinity.
	43	*/
	44	inline bool
	45	getRoundingDirection(bool isEven, bool isNegative, Section section, RoundingMode roundingMode,
	46	UErrorCode &status) {
	47	switch (roundingMode) {
	48	case RoundingMode::UNUM_ROUND_UP:
	49	// round away from zero
	50	return false;
	51
	52	case RoundingMode::UNUM_ROUND_DOWN:
	53	// round toward zero
	54	return true;
	55
	56	case RoundingMode::UNUM_ROUND_CEILING:
	57	// round toward positive infinity
	58	return isNegative;
	59
	60	case RoundingMode::UNUM_ROUND_FLOOR:
	61	// round toward negative infinity
	62	return !isNegative;
	63
	64	case RoundingMode::UNUM_ROUND_HALFUP:
65	switch (section) {
66	case SECTION_MIDPOINT:
67	return false;
68	case SECTION_LOWER:
69	return true;
70	case SECTION_UPPER:
71	return false;
72	default:
73	break;
74	}
75	break;
76
77	case RoundingMode::UNUM_ROUND_HALFDOWN:
78	switch (section) {
79	case SECTION_MIDPOINT:
80	return true;
81	case SECTION_LOWER:
82	return true;
83	case SECTION_UPPER:
84	return false;
85	default:
86	break;
87	}
88	break;
89
90	case RoundingMode::UNUM_ROUND_HALFEVEN:
91	switch (section) {
92	case SECTION_MIDPOINT:
93	return isEven;
94	case SECTION_LOWER:
95	return true;
96	case SECTION_UPPER:
97	return false;
98	default:
99	break;
100	}
101	break;
102
103	default:
104	break;
105	}
106
107	status = U_FORMAT_INEXACT_ERROR;
108	return false;
109	}
110
111	/**
112	* Gets whether the given rounding mode's rounding boundary is at the midpoint. The rounding
113	* boundary is the point at which a number switches from being rounded down to being rounded up.
114	* For example, with rounding mode HALF_EVEN, HALF_UP, or HALF_DOWN, the rounding boundary is at
115	* the midpoint, and this function would return true. However, for UP, DOWN, CEILING, and FLOOR,
116	* the rounding boundary is at the "edge", and this function would return false.
117	*
118	* @param roundingMode The integer version of the {@link RoundingMode}.
119	* @return true if rounding mode is HALF_EVEN, HALF_UP, or HALF_DOWN; false otherwise.
120	*/
121	inline bool roundsAtMidpoint(int roundingMode) {
122	switch (roundingMode) {
123	case RoundingMode::UNUM_ROUND_UP:
124	case RoundingMode::UNUM_ROUND_DOWN:
125	case RoundingMode::UNUM_ROUND_CEILING:
126	case RoundingMode::UNUM_ROUND_FLOOR:
127	return false;
128
129	default:
130	return true;
131	}
132	}
133
134	/**
135	* Computes the number of fraction digits in a double. Used for computing maxFrac for an increment.
136	* Calls into the DoubleToStringConverter library to do so.
3d1f044b A	137	*
	138	* @param singleDigit An output parameter; set to a number if that is the
	139	* only digit in the double, or -1 if there is more than one digit.
0f5d89e8	140	*/
3d1f044b	141	digits_t doubleFractionLength(double input, int8_t* singleDigit);
0f5d89e8 A	142
	143	} // namespace roundingutils
	144
	145
	146	/**
	147	* Encapsulates a Precision and a RoundingMode and performs rounding on a DecimalQuantity.
	148	*
	149	* This class does not exist in Java: instead, the base Precision class is used.
	150	*/
	151	class RoundingImpl {
	152	public:
	153	RoundingImpl() = default; // default constructor: leaves object in undefined state
	154
	155	RoundingImpl(const Precision& precision, UNumberFormatRoundingMode roundingMode,
	156	const CurrencyUnit& currency, UErrorCode& status);
	157
	158	static RoundingImpl passThrough();
	159
	160	/** Required for ScientificFormatter */
	161	bool isSignificantDigits() const;
	162
	163	/**
	164	* Rounding endpoint used by Engineering and Compact notation. Chooses the most appropriate multiplier (magnitude
	165	* adjustment), applies the adjustment, rounds, and returns the chosen multiplier.
	166	*
	167	* <p>
	168	* In most cases, this is simple. However, when rounding the number causes it to cross a multiplier boundary, we
	169	* need to re-do the rounding. For example, to display 999,999 in Engineering notation with 2 sigfigs, first you
	170	* guess the multiplier to be -3. However, then you end up getting 1000E3, which is not the correct output. You then
	171	* change your multiplier to be -6, and you get 1.0E6, which is correct.
	172	*
	173	* @param input The quantity to process.
	174	* @param producer Function to call to return a multiplier based on a magnitude.
	175	* @return The number of orders of magnitude the input was adjusted by this method.
	176	*/
	177	int32_t
	178	chooseMultiplierAndApply(impl::DecimalQuantity &input, const impl::MultiplierProducer &producer,
	179	UErrorCode &status);
	180
	181	void apply(impl::DecimalQuantity &value, UErrorCode &status) const;
	182
	183	/** Version of {@link #apply} that obeys minInt constraints. Used for scientific notation compatibility mode. */
	184	void apply(impl::DecimalQuantity &value, int32_t minInt, UErrorCode status);
	185
	186	private:
	187	Precision fPrecision;
	188	UNumberFormatRoundingMode fRoundingMode;
	189	bool fPassThrough;
	190	};
	191
	192
	193	} // namespace impl
	194	} // namespace number
	195	U_NAMESPACE_END
	196
	197	#endif //__NUMBER_ROUNDINGUTILS_H__
	198
	199	#endif /* #if !UCONFIG_NO_FORMATTING */