icu4c/source/i18n/number_rounding.cpp - platform/external/icu - Git at Google

 // © 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 && !UPRV_INCOMPLETE_CPP11_SUPPORT

 #include "uassert.h"
 #include "unicode/numberformatter.h"
 #include "number_types.h"
 #include "number_decimalquantity.h"

 using namespace icu;
 using namespace icu::number;
 using namespace icu::number::impl;

 namespace {

 int32_t getRoundingMagnitudeFraction(int maxFrac) {
     if (maxFrac == -1) {
         return INT32_MIN;
     }
     return -maxFrac;
 }

 int32_t getRoundingMagnitudeSignificant(const DecimalQuantity &value, int maxSig) {
     if (maxSig == -1) {
         return INT32_MIN;
     }
     int magnitude = value.isZero() ? 0 : value.getMagnitude();
     return magnitude - maxSig + 1;
 }

 int32_t getDisplayMagnitudeFraction(int minFrac) {
     if (minFrac == 0) {
         return INT32_MAX;
     }
     return -minFrac;
 }

 int32_t getDisplayMagnitudeSignificant(const DecimalQuantity &value, int minSig) {
     int magnitude = value.isZero() ? 0 : value.getMagnitude();
     return magnitude - minSig + 1;
 }

 }


 Rounder Rounder::unlimited() {
     return Rounder(RND_NONE, {}, kDefaultMode);
 }

 FractionRounder Rounder::integer() {
     return constructFraction(0, 0);
 }

 FractionRounder Rounder::fixedFraction(int32_t minMaxFractionPlaces) {
     if (minMaxFractionPlaces >= 0 && minMaxFractionPlaces <= kMaxIntFracSig) {
         return constructFraction(minMaxFractionPlaces, minMaxFractionPlaces);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 FractionRounder Rounder::minFraction(int32_t minFractionPlaces) {
     if (minFractionPlaces >= 0 && minFractionPlaces <= kMaxIntFracSig) {
         return constructFraction(minFractionPlaces, -1);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 FractionRounder Rounder::maxFraction(int32_t maxFractionPlaces) {
     if (maxFractionPlaces >= 0 && maxFractionPlaces <= kMaxIntFracSig) {
         return constructFraction(0, maxFractionPlaces);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 FractionRounder Rounder::minMaxFraction(int32_t minFractionPlaces, int32_t maxFractionPlaces) {
     if (minFractionPlaces >= 0 && maxFractionPlaces <= kMaxIntFracSig &&
         minFractionPlaces <= maxFractionPlaces) {
         return constructFraction(minFractionPlaces, maxFractionPlaces);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 Rounder Rounder::fixedDigits(int32_t minMaxSignificantDigits) {
     if (minMaxSignificantDigits >= 0 && minMaxSignificantDigits <= kMaxIntFracSig) {
         return constructSignificant(minMaxSignificantDigits, minMaxSignificantDigits);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 Rounder Rounder::minDigits(int32_t minSignificantDigits) {
     if (minSignificantDigits >= 0 && minSignificantDigits <= kMaxIntFracSig) {
         return constructSignificant(minSignificantDigits, -1);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 Rounder Rounder::maxDigits(int32_t maxSignificantDigits) {
     if (maxSignificantDigits >= 0 && maxSignificantDigits <= kMaxIntFracSig) {
         return constructSignificant(0, maxSignificantDigits);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 Rounder Rounder::minMaxDigits(int32_t minSignificantDigits, int32_t maxSignificantDigits) {
     if (minSignificantDigits >= 0 && maxSignificantDigits <= kMaxIntFracSig &&
         minSignificantDigits <= maxSignificantDigits) {
         return constructSignificant(minSignificantDigits, maxSignificantDigits);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 IncrementRounder Rounder::increment(double roundingIncrement) {
     if (roundingIncrement > 0.0) {
         return constructIncrement(roundingIncrement, 0);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 CurrencyRounder Rounder::currency(UCurrencyUsage currencyUsage) {
     return constructCurrency(currencyUsage);
 }

 Rounder Rounder::withMode(RoundingMode roundingMode) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
     return {fType, fUnion, roundingMode};
 }

 Rounder FractionRounder::withMinDigits(int32_t minSignificantDigits) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
     if (minSignificantDigits >= 0 && minSignificantDigits <= kMaxIntFracSig) {
         return constructFractionSignificant(*this, minSignificantDigits, -1);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 Rounder FractionRounder::withMaxDigits(int32_t maxSignificantDigits) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
     if (maxSignificantDigits >= 0 && maxSignificantDigits <= kMaxIntFracSig) {
         return constructFractionSignificant(*this, -1, maxSignificantDigits);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 // Private method on base class
 Rounder Rounder::withCurrency(const CurrencyUnit &currency, UErrorCode &status) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
     U_ASSERT(fType == RND_CURRENCY);
     const char16_t *isoCode = currency.getISOCurrency();
     double increment = ucurr_getRoundingIncrementForUsage(isoCode, fUnion.currencyUsage, &status);
     int32_t minMaxFrac = ucurr_getDefaultFractionDigitsForUsage(
             isoCode, fUnion.currencyUsage, &status);
     if (increment != 0.0) {
         return constructIncrement(increment, minMaxFrac);
     } else {
         return constructFraction(minMaxFrac, minMaxFrac);
     }
 }

 // Public method on CurrencyRounder subclass
 Rounder CurrencyRounder::withCurrency(const CurrencyUnit &currency) const {
     UErrorCode localStatus = U_ZERO_ERROR;
     Rounder result = Rounder::withCurrency(currency, localStatus);
     if (U_FAILURE(localStatus)) {
         return {localStatus};
     }
     return result;
 }

 Rounder IncrementRounder::withMinFraction(int32_t minFrac) const {
     if (fType == RND_ERROR) { return *this; } // no-op in error state
     if (minFrac >= 0 && minFrac <= kMaxIntFracSig) {
         return constructIncrement(fUnion.increment.fIncrement, minFrac);
     } else {
         return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
     }
 }

 FractionRounder Rounder::constructFraction(int32_t minFrac, int32_t maxFrac) {
     FractionSignificantSettings settings;
     settings.fMinFrac = static_cast<int8_t> (minFrac);
     settings.fMaxFrac = static_cast<int8_t> (maxFrac);
     settings.fMinSig = -1;
     settings.fMaxSig = -1;
     RounderUnion union_;
     union_.fracSig = settings;
     return {RND_FRACTION, union_, kDefaultMode};
 }

 Rounder Rounder::constructSignificant(int32_t minSig, int32_t maxSig) {
     FractionSignificantSettings settings;
     settings.fMinFrac = -1;
     settings.fMaxFrac = -1;
     settings.fMinSig = static_cast<int8_t>(minSig);
     settings.fMaxSig = static_cast<int8_t>(maxSig);
     RounderUnion union_;
     union_.fracSig = settings;
     return {RND_SIGNIFICANT, union_, kDefaultMode};
 }

 Rounder
 Rounder::constructFractionSignificant(const FractionRounder &base, int32_t minSig, int32_t maxSig) {
     FractionSignificantSettings settings = base.fUnion.fracSig;
     settings.fMinSig = static_cast<int8_t>(minSig);
     settings.fMaxSig = static_cast<int8_t>(maxSig);
     RounderUnion union_;
     union_.fracSig = settings;
     return {RND_FRACTION_SIGNIFICANT, union_, kDefaultMode};
 }

 IncrementRounder Rounder::constructIncrement(double increment, int32_t minFrac) {
     IncrementSettings settings;
     settings.fIncrement = increment;
     settings.fMinFrac = minFrac;
     RounderUnion union_;
     union_.increment = settings;
     return {RND_INCREMENT, union_, kDefaultMode};
 }

 CurrencyRounder Rounder::constructCurrency(UCurrencyUsage usage) {
     RounderUnion union_;
     union_.currencyUsage = usage;
     return {RND_CURRENCY, union_, kDefaultMode};
 }

 Rounder Rounder::constructPassThrough() {
     RounderUnion union_;
     union_.errorCode = U_ZERO_ERROR; // initialize the variable
     return {RND_PASS_THROUGH, union_, kDefaultMode};
 }

 void Rounder::setLocaleData(const CurrencyUnit &currency, UErrorCode &status) {
     if (fType == RND_CURRENCY) {
         *this = withCurrency(currency, status);
     }
 }

 int32_t
 Rounder::chooseMultiplierAndApply(impl::DecimalQuantity &input, const impl::MultiplierProducer &producer,
                                   UErrorCode &status) {
     // TODO: Make a better and more efficient implementation.
     // TODO: Avoid the object creation here.
     DecimalQuantity copy(input);

     U_ASSERT(!input.isZero());
     int32_t magnitude = input.getMagnitude();
     int32_t multiplier = producer.getMultiplier(magnitude);
     input.adjustMagnitude(multiplier);
     apply(input, status);

     // If the number turned to zero when rounding, do not re-attempt the rounding.
     if (!input.isZero() && input.getMagnitude() == magnitude + multiplier + 1) {
         magnitude += 1;
         input = copy;
         multiplier = producer.getMultiplier(magnitude);
         input.adjustMagnitude(multiplier);
         U_ASSERT(input.getMagnitude() == magnitude + multiplier - 1);
         apply(input, status);
         U_ASSERT(input.getMagnitude() == magnitude + multiplier);
     }

     return multiplier;
 }

 /** This is the method that contains the actual rounding logic. */
 void Rounder::apply(impl::DecimalQuantity &value, UErrorCode& status) const {
     switch (fType) {
         case RND_BOGUS:
         case RND_ERROR:
             // Errors should be caught before the apply() method is called
             status = U_INTERNAL_PROGRAM_ERROR;
             break;

         case RND_NONE:
             value.roundToInfinity();
             break;

         case RND_FRACTION:
             value.roundToMagnitude(
                     getRoundingMagnitudeFraction(fUnion.fracSig.fMaxFrac), fRoundingMode, status);
             value.setFractionLength(
                     uprv_max(0, -getDisplayMagnitudeFraction(fUnion.fracSig.fMinFrac)), INT32_MAX);
             break;

         case RND_SIGNIFICANT:
             value.roundToMagnitude(
                     getRoundingMagnitudeSignificant(value, fUnion.fracSig.fMaxSig),
                     fRoundingMode,
                     status);
             value.setFractionLength(
                     uprv_max(0, -getDisplayMagnitudeSignificant(value, fUnion.fracSig.fMinSig)),
                     INT32_MAX);
             break;

         case RND_FRACTION_SIGNIFICANT: {
             int32_t displayMag = getDisplayMagnitudeFraction(fUnion.fracSig.fMinFrac);
             int32_t roundingMag = getRoundingMagnitudeFraction(fUnion.fracSig.fMaxFrac);
             if (fUnion.fracSig.fMinSig == -1) {
                 // Max Sig override
                 int32_t candidate = getRoundingMagnitudeSignificant(value, fUnion.fracSig.fMaxSig);
                 roundingMag = uprv_max(roundingMag, candidate);
             } else {
                 // Min Sig override
                 int32_t candidate = getDisplayMagnitudeSignificant(value, fUnion.fracSig.fMinSig);
                 roundingMag = uprv_min(roundingMag, candidate);
             }
             value.roundToMagnitude(roundingMag, fRoundingMode, status);
             value.setFractionLength(uprv_max(0, -displayMag), INT32_MAX);
             break;
         }

         case RND_INCREMENT:
             value.roundToIncrement(
                 fUnion.increment.fIncrement, fRoundingMode, fUnion.increment.fMinFrac, status);
             value.setFractionLength(fUnion.increment.fMinFrac, fUnion.increment.fMinFrac);
             break;

         case RND_CURRENCY:
             // Call .withCurrency() before .apply()!
             U_ASSERT(false);

         case RND_PASS_THROUGH:
             break;
     }
 }

 void Rounder::apply(impl::DecimalQuantity &value, int32_t minInt, UErrorCode /*status*/) {
     // This method is intended for the one specific purpose of helping print "00.000E0".
     U_ASSERT(fType == RND_SIGNIFICANT);
     U_ASSERT(value.isZero());
     value.setFractionLength(fUnion.fracSig.fMinSig - minInt, INT32_MAX);
 }

 #endif /* #if !UCONFIG_NO_FORMATTING */
	// © 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 && !UPRV_INCOMPLETE_CPP11_SUPPORT

	#include "uassert.h"
	#include "unicode/numberformatter.h"
	#include "number_types.h"
	#include "number_decimalquantity.h"

	using namespace icu;
	using namespace icu::number;
	using namespace icu::number::impl;

	namespace {

	int32_t getRoundingMagnitudeFraction(int maxFrac) {
	if (maxFrac == -1) {
	return INT32_MIN;
	}
	return -maxFrac;
	}

	int32_t getRoundingMagnitudeSignificant(const DecimalQuantity &value, int maxSig) {
	if (maxSig == -1) {
	return INT32_MIN;
	}
	int magnitude = value.isZero() ? 0 : value.getMagnitude();
	return magnitude - maxSig + 1;
	}

	int32_t getDisplayMagnitudeFraction(int minFrac) {
	if (minFrac == 0) {
	return INT32_MAX;
	}
	return -minFrac;
	}

	int32_t getDisplayMagnitudeSignificant(const DecimalQuantity &value, int minSig) {
	int magnitude = value.isZero() ? 0 : value.getMagnitude();
	return magnitude - minSig + 1;
	}

	}


	Rounder Rounder::unlimited() {
	return Rounder(RND_NONE, {}, kDefaultMode);
	}

	FractionRounder Rounder::integer() {
	return constructFraction(0, 0);
	}

	FractionRounder Rounder::fixedFraction(int32_t minMaxFractionPlaces) {
	if (minMaxFractionPlaces >= 0 && minMaxFractionPlaces <= kMaxIntFracSig) {
	return constructFraction(minMaxFractionPlaces, minMaxFractionPlaces);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	FractionRounder Rounder::minFraction(int32_t minFractionPlaces) {
	if (minFractionPlaces >= 0 && minFractionPlaces <= kMaxIntFracSig) {
	return constructFraction(minFractionPlaces, -1);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	FractionRounder Rounder::maxFraction(int32_t maxFractionPlaces) {
	if (maxFractionPlaces >= 0 && maxFractionPlaces <= kMaxIntFracSig) {
	return constructFraction(0, maxFractionPlaces);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	FractionRounder Rounder::minMaxFraction(int32_t minFractionPlaces, int32_t maxFractionPlaces) {
	if (minFractionPlaces >= 0 && maxFractionPlaces <= kMaxIntFracSig &&
	minFractionPlaces <= maxFractionPlaces) {
	return constructFraction(minFractionPlaces, maxFractionPlaces);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	Rounder Rounder::fixedDigits(int32_t minMaxSignificantDigits) {
	if (minMaxSignificantDigits >= 0 && minMaxSignificantDigits <= kMaxIntFracSig) {
	return constructSignificant(minMaxSignificantDigits, minMaxSignificantDigits);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	Rounder Rounder::minDigits(int32_t minSignificantDigits) {
	if (minSignificantDigits >= 0 && minSignificantDigits <= kMaxIntFracSig) {
	return constructSignificant(minSignificantDigits, -1);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	Rounder Rounder::maxDigits(int32_t maxSignificantDigits) {
	if (maxSignificantDigits >= 0 && maxSignificantDigits <= kMaxIntFracSig) {
	return constructSignificant(0, maxSignificantDigits);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	Rounder Rounder::minMaxDigits(int32_t minSignificantDigits, int32_t maxSignificantDigits) {
	if (minSignificantDigits >= 0 && maxSignificantDigits <= kMaxIntFracSig &&
	minSignificantDigits <= maxSignificantDigits) {
	return constructSignificant(minSignificantDigits, maxSignificantDigits);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	IncrementRounder Rounder::increment(double roundingIncrement) {
	if (roundingIncrement > 0.0) {
	return constructIncrement(roundingIncrement, 0);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	CurrencyRounder Rounder::currency(UCurrencyUsage currencyUsage) {
	return constructCurrency(currencyUsage);
	}

	Rounder Rounder::withMode(RoundingMode roundingMode) const {
	if (fType == RND_ERROR) { return *this; } // no-op in error state
	return {fType, fUnion, roundingMode};
	}

	Rounder FractionRounder::withMinDigits(int32_t minSignificantDigits) const {
	if (fType == RND_ERROR) { return *this; } // no-op in error state
	if (minSignificantDigits >= 0 && minSignificantDigits <= kMaxIntFracSig) {
	return constructFractionSignificant(*this, minSignificantDigits, -1);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	Rounder FractionRounder::withMaxDigits(int32_t maxSignificantDigits) const {
	if (fType == RND_ERROR) { return *this; } // no-op in error state
	if (maxSignificantDigits >= 0 && maxSignificantDigits <= kMaxIntFracSig) {
	return constructFractionSignificant(*this, -1, maxSignificantDigits);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	// Private method on base class
	Rounder Rounder::withCurrency(const CurrencyUnit &currency, UErrorCode &status) const {
	if (fType == RND_ERROR) { return *this; } // no-op in error state
	U_ASSERT(fType == RND_CURRENCY);
	const char16_t *isoCode = currency.getISOCurrency();
	double increment = ucurr_getRoundingIncrementForUsage(isoCode, fUnion.currencyUsage, &status);
	int32_t minMaxFrac = ucurr_getDefaultFractionDigitsForUsage(
	isoCode, fUnion.currencyUsage, &status);
	if (increment != 0.0) {
	return constructIncrement(increment, minMaxFrac);
	} else {
	return constructFraction(minMaxFrac, minMaxFrac);
	}
	}

	// Public method on CurrencyRounder subclass
	Rounder CurrencyRounder::withCurrency(const CurrencyUnit &currency) const {
	UErrorCode localStatus = U_ZERO_ERROR;
	Rounder result = Rounder::withCurrency(currency, localStatus);
	if (U_FAILURE(localStatus)) {
	return {localStatus};
	}
	return result;
	}

	Rounder IncrementRounder::withMinFraction(int32_t minFrac) const {
	if (fType == RND_ERROR) { return *this; } // no-op in error state
	if (minFrac >= 0 && minFrac <= kMaxIntFracSig) {
	return constructIncrement(fUnion.increment.fIncrement, minFrac);
	} else {
	return {U_NUMBER_DIGIT_WIDTH_OUTOFBOUNDS_ERROR};
	}
	}

	FractionRounder Rounder::constructFraction(int32_t minFrac, int32_t maxFrac) {
	FractionSignificantSettings settings;
	settings.fMinFrac = static_cast<int8_t> (minFrac);
	settings.fMaxFrac = static_cast<int8_t> (maxFrac);
	settings.fMinSig = -1;
	settings.fMaxSig = -1;
	RounderUnion union_;
	union_.fracSig = settings;
	return {RND_FRACTION, union_, kDefaultMode};
	}

	Rounder Rounder::constructSignificant(int32_t minSig, int32_t maxSig) {
	FractionSignificantSettings settings;
	settings.fMinFrac = -1;
	settings.fMaxFrac = -1;
	settings.fMinSig = static_cast<int8_t>(minSig);
	settings.fMaxSig = static_cast<int8_t>(maxSig);
	RounderUnion union_;
	union_.fracSig = settings;
	return {RND_SIGNIFICANT, union_, kDefaultMode};
	}

	Rounder
	Rounder::constructFractionSignificant(const FractionRounder &base, int32_t minSig, int32_t maxSig) {
	FractionSignificantSettings settings = base.fUnion.fracSig;
	settings.fMinSig = static_cast<int8_t>(minSig);
	settings.fMaxSig = static_cast<int8_t>(maxSig);
	RounderUnion union_;
	union_.fracSig = settings;
	return {RND_FRACTION_SIGNIFICANT, union_, kDefaultMode};
	}

	IncrementRounder Rounder::constructIncrement(double increment, int32_t minFrac) {
	IncrementSettings settings;
	settings.fIncrement = increment;
	settings.fMinFrac = minFrac;
	RounderUnion union_;
	union_.increment = settings;
	return {RND_INCREMENT, union_, kDefaultMode};
	}

	CurrencyRounder Rounder::constructCurrency(UCurrencyUsage usage) {
	RounderUnion union_;
	union_.currencyUsage = usage;
	return {RND_CURRENCY, union_, kDefaultMode};
	}

	Rounder Rounder::constructPassThrough() {
	RounderUnion union_;
	union_.errorCode = U_ZERO_ERROR; // initialize the variable
	return {RND_PASS_THROUGH, union_, kDefaultMode};
	}

	void Rounder::setLocaleData(const CurrencyUnit &currency, UErrorCode &status) {
	if (fType == RND_CURRENCY) {
	*this = withCurrency(currency, status);
	}
	}

	int32_t
	Rounder::chooseMultiplierAndApply(impl::DecimalQuantity &input, const impl::MultiplierProducer &producer,
	UErrorCode &status) {
	// TODO: Make a better and more efficient implementation.
	// TODO: Avoid the object creation here.
	DecimalQuantity copy(input);

	U_ASSERT(!input.isZero());
	int32_t magnitude = input.getMagnitude();
	int32_t multiplier = producer.getMultiplier(magnitude);
	input.adjustMagnitude(multiplier);
	apply(input, status);

	// If the number turned to zero when rounding, do not re-attempt the rounding.
	if (!input.isZero() && input.getMagnitude() == magnitude + multiplier + 1) {
	magnitude += 1;
	input = copy;
	multiplier = producer.getMultiplier(magnitude);
	input.adjustMagnitude(multiplier);
	U_ASSERT(input.getMagnitude() == magnitude + multiplier - 1);
	apply(input, status);
	U_ASSERT(input.getMagnitude() == magnitude + multiplier);
	}

	return multiplier;
	}

	/** This is the method that contains the actual rounding logic. */
	void Rounder::apply(impl::DecimalQuantity &value, UErrorCode& status) const {
	switch (fType) {
	case RND_BOGUS:
	case RND_ERROR:
	// Errors should be caught before the apply() method is called
	status = U_INTERNAL_PROGRAM_ERROR;
	break;

	case RND_NONE:
	value.roundToInfinity();
	break;

	case RND_FRACTION:
	value.roundToMagnitude(
	getRoundingMagnitudeFraction(fUnion.fracSig.fMaxFrac), fRoundingMode, status);
	value.setFractionLength(
	uprv_max(0, -getDisplayMagnitudeFraction(fUnion.fracSig.fMinFrac)), INT32_MAX);
	break;

	case RND_SIGNIFICANT:
	value.roundToMagnitude(
	getRoundingMagnitudeSignificant(value, fUnion.fracSig.fMaxSig),
	fRoundingMode,
	status);
	value.setFractionLength(
	uprv_max(0, -getDisplayMagnitudeSignificant(value, fUnion.fracSig.fMinSig)),
	INT32_MAX);
	break;

	case RND_FRACTION_SIGNIFICANT: {
	int32_t displayMag = getDisplayMagnitudeFraction(fUnion.fracSig.fMinFrac);
	int32_t roundingMag = getRoundingMagnitudeFraction(fUnion.fracSig.fMaxFrac);
	if (fUnion.fracSig.fMinSig == -1) {
	// Max Sig override
	int32_t candidate = getRoundingMagnitudeSignificant(value, fUnion.fracSig.fMaxSig);
	roundingMag = uprv_max(roundingMag, candidate);
	} else {
	// Min Sig override
	int32_t candidate = getDisplayMagnitudeSignificant(value, fUnion.fracSig.fMinSig);
	roundingMag = uprv_min(roundingMag, candidate);
	}
	value.roundToMagnitude(roundingMag, fRoundingMode, status);
	value.setFractionLength(uprv_max(0, -displayMag), INT32_MAX);
	break;
	}

	case RND_INCREMENT:
	value.roundToIncrement(
	fUnion.increment.fIncrement, fRoundingMode, fUnion.increment.fMinFrac, status);
	value.setFractionLength(fUnion.increment.fMinFrac, fUnion.increment.fMinFrac);
	break;

	case RND_CURRENCY:
	// Call .withCurrency() before .apply()!
	U_ASSERT(false);

	case RND_PASS_THROUGH:
	break;
	}
	}

	void Rounder::apply(impl::DecimalQuantity &value, int32_t minInt, UErrorCode /status/) {
	// This method is intended for the one specific purpose of helping print "00.000E0".
	U_ASSERT(fType == RND_SIGNIFICANT);
	U_ASSERT(value.isZero());
	value.setFractionLength(fUnion.fracSig.fMinSig - minInt, INT32_MAX);
	}

	#endif /* #if !UCONFIG_NO_FORMATTING */