diff --git a/icu4c/source/i18n/plurrule.cpp b/icu4c/source/i18n/plurrule.cpp
index 7d1037f..edc3d88 100644
--- a/icu4c/source/i18n/plurrule.cpp
+++ b/icu4c/source/i18n/plurrule.cpp
@@ -26,6 +26,7 @@
 #include "hash.h"
 #include "locutil.h"
 #include "mutex.h"
+#include "number_decnum.h"
 #include "patternprops.h"
 #include "plurrule_impl.h"
 #include "putilimp.h"
@@ -45,7 +46,9 @@
 U_NAMESPACE_BEGIN
 
 using namespace icu::pluralimpl;
+using icu::number::impl::DecNum;
 using icu::number::impl::DecimalQuantity;
+using icu::number::impl::RoundingMode;
 
 static const UChar PLURAL_KEYWORD_OTHER[]={LOW_O,LOW_T,LOW_H,LOW_E,LOW_R,0};
 static const UChar PLURAL_DEFAULT_RULE[]={LOW_O,LOW_T,LOW_H,LOW_E,LOW_R,COLON,SPACE,LOW_N,0};
@@ -369,36 +372,18 @@
     return 0;
 }
 
-
-static double scaleForInt(double d) {
-    double scale = 1.0;
-    while (d != floor(d)) {
-        d = d * 10.0;
-        scale = scale * 10.0;
-    }
-    return scale;
-}
-
-static const double powers10[7] = {1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0}; // powers of 10 for 0..6
-static double applyExponent(double source, int32_t exponent) {
-    if (exponent >= 0 && exponent <= 6) {
-        return source * powers10[exponent];
-    }
-    return source * pow(10.0, exponent);
-}
-
 /**
- * Helper method for the overrides of getSamples() for double and FixedDecimal
- * return value types.  Provide only one of an allocated array of doubles or
- * FixedDecimals, and a nullptr for the other.
+ * Helper method for the overrides of getSamples() for double and DecimalQuantity
+ * return value types.  Provide only one of an allocated array of double or
+ * DecimalQuantity, and a nullptr for the other.
  */
 static int32_t
 getSamplesFromString(const UnicodeString &samples, double *destDbl,
-                        FixedDecimal* destFd, int32_t destCapacity,
+                        DecimalQuantity* destDq, int32_t destCapacity,
                         UErrorCode& status) {
 
-    if ((destDbl == nullptr && destFd == nullptr)
-            || (destDbl != nullptr && destFd != nullptr)) {
+    if ((destDbl == nullptr && destDq == nullptr)
+            || (destDbl != nullptr && destDq != nullptr)) {
         status = U_INTERNAL_PROGRAM_ERROR;
         return 0;
     }
@@ -420,58 +405,75 @@
         // std::cout << "PluralRules::getSamples(), samplesRange = \"" << sampleRange.toUTF8String(ss) << "\"\n";
         int32_t tildeIndex = sampleRange.indexOf(TILDE);
         if (tildeIndex < 0) {
-            FixedDecimal fixed(sampleRange, status);
+            DecimalQuantity dq = DecimalQuantity::fromExponentString(sampleRange, status);
             if (isDouble) {
-                double sampleValue = fixed.source;
-                if (fixed.visibleDecimalDigitCount == 0 || sampleValue != floor(sampleValue)) {
-                    destDbl[sampleCount++] = applyExponent(sampleValue, fixed.exponent);
+                // See warning note below about lack of precision for floating point samples for numbers with
+                // trailing zeroes in the decimal fraction representation.
+                double dblValue = dq.toDouble();
+                if (!(dblValue == floor(dblValue) && dq.fractionCount() > 0)) {
+                    destDbl[sampleCount++] = dblValue;
                 }
             } else {
-                destFd[sampleCount++] = fixed;
+                destDq[sampleCount++] = dq;
             }
         } else {
-            FixedDecimal fixedLo(sampleRange.tempSubStringBetween(0, tildeIndex), status);
-            FixedDecimal fixedHi(sampleRange.tempSubStringBetween(tildeIndex+1), status);
-            double rangeLo = fixedLo.source;
-            double rangeHi = fixedHi.source;
+            DecimalQuantity rangeLo =
+                DecimalQuantity::fromExponentString(sampleRange.tempSubStringBetween(0, tildeIndex), status);
+            DecimalQuantity rangeHi = DecimalQuantity::fromExponentString(sampleRange.tempSubStringBetween(tildeIndex+1), status);
             if (U_FAILURE(status)) {
                 break;
             }
-            if (rangeHi < rangeLo) {
+            if (rangeHi.toDouble() < rangeLo.toDouble()) {
                 status = U_INVALID_FORMAT_ERROR;
                 break;
             }
 
-            // For ranges of samples with fraction decimal digits, scale the number up so that we
-            //   are adding one in the units place. Avoids roundoffs from repetitive adds of tenths.
+            DecimalQuantity incrementDq;
+            incrementDq.setToInt(1);
+            int32_t lowerDispMag = rangeLo.getLowerDisplayMagnitude();
+            int32_t exponent = rangeLo.getExponent();
+            int32_t incrementScale = lowerDispMag + exponent;
+            incrementDq.adjustMagnitude(incrementScale);
+            double incrementVal = incrementDq.toDouble();  // 10 ^ incrementScale
+            
 
-            double scale = scaleForInt(rangeLo);
-            double t = scaleForInt(rangeHi);
-            if (t > scale) {
-                scale = t;
-            }
-            rangeLo *= scale;
-            rangeHi *= scale;
-            for (double n=rangeLo; n<=rangeHi; n+=1) {
-                double sampleValue = n/scale;
+            DecimalQuantity dq(rangeLo);
+            double dblValue = dq.toDouble();
+            double end = rangeHi.toDouble();
+
+            while (dblValue <= end) {
                 if (isDouble) {
                     // Hack Alert: don't return any decimal samples with integer values that
                     //    originated from a format with trailing decimals.
                     //    This API is returning doubles, which can't distinguish having displayed
                     //    zeros to the right of the decimal.
                     //    This results in test failures with values mapping back to a different keyword.
-                    if (!(sampleValue == floor(sampleValue) && fixedLo.visibleDecimalDigitCount > 0)) {
-                        destDbl[sampleCount++] = sampleValue;
+                    if (!(dblValue == floor(dblValue) && dq.fractionCount() > 0)) {
+                        destDbl[sampleCount++] = dblValue;
                     }
                 } else {
-                    int32_t v = (int32_t) fixedLo.getPluralOperand(PluralOperand::PLURAL_OPERAND_V);
-                    int32_t e = (int32_t) fixedLo.getPluralOperand(PluralOperand::PLURAL_OPERAND_E);
-                    FixedDecimal newSample = FixedDecimal::createWithExponent(sampleValue, v, e);
-                    destFd[sampleCount++] = newSample;
+                    destDq[sampleCount++] = dq;
                 }
                 if (sampleCount >= destCapacity) {
                     break;
                 }
+
+                // Increment dq for next iteration
+
+                // Because DecNum and DecimalQuantity do not support
+                // add operations, we need to convert to/from double,
+                // despite precision lossiness for decimal fractions like 0.1.
+                dblValue += incrementVal;
+                DecNum newDqDecNum;
+                newDqDecNum.setTo(dblValue, status);
+                DecimalQuantity newDq;             
+                newDq.setToDecNum(newDqDecNum, status);
+                newDq.setMinFraction(-lowerDispMag);
+                newDq.roundToMagnitude(lowerDispMag, RoundingMode::UNUM_ROUND_HALFEVEN, status);
+                newDq.adjustMagnitude(-exponent);
+                newDq.adjustExponent(exponent);
+                dblValue = newDq.toDouble();
+                dq = newDq;
             }
         }
         sampleStartIdx = sampleEndIdx + 1;
@@ -505,7 +507,7 @@
 }
 
 int32_t
-PluralRules::getSamples(const UnicodeString &keyword, FixedDecimal *dest,
+PluralRules::getSamples(const UnicodeString &keyword, DecimalQuantity *dest,
                         int32_t destCapacity, UErrorCode& status) {
     if (U_FAILURE(status)) {
         return 0;
diff --git a/icu4c/source/i18n/plurrule_impl.h b/icu4c/source/i18n/plurrule_impl.h
index 7274da5..c27b655 100644
--- a/icu4c/source/i18n/plurrule_impl.h
+++ b/icu4c/source/i18n/plurrule_impl.h
@@ -34,7 +34,7 @@
  * A FixedDecimal version of UPLRULES_NO_UNIQUE_VALUE used in PluralRulesTest
  * for parsing of samples.
  */
-#define UPLRULES_NO_UNIQUE_VALUE_DECIMAL (FixedDecimal((double)-0.00123456777))
+#define UPLRULES_NO_UNIQUE_VALUE_DECIMAL(ERROR_CODE) (DecimalQuantity::fromExponentString(u"-0.00123456777", ERROR_CODE))
 
 class PluralRulesTest;
 
diff --git a/icu4c/source/i18n/unicode/plurrule.h b/icu4c/source/i18n/unicode/plurrule.h
index e3822dd..b4298de 100644
--- a/icu4c/source/i18n/unicode/plurrule.h
+++ b/icu4c/source/i18n/unicode/plurrule.h
@@ -59,9 +59,15 @@
 class FormattedNumberRange;
 namespace impl {
 class UFormattedNumberRangeData;
+class DecimalQuantity;
+class DecNum;
 }
 }
 
+#ifndef U_HIDE_INTERNAL_API
+using icu::number::impl::DecimalQuantity;
+#endif  /* U_HIDE_INTERNAL_API */
+
 /**
  * Defines rules for mapping non-negative numeric values onto a small set of
  * keywords. Rules are constructed from a text description, consisting
@@ -468,7 +474,7 @@
 
 #ifndef U_HIDE_INTERNAL_API
     /**
-     * Internal-only function that returns FixedDecimals instead of doubles.
+     * Internal-only function that returns DecimalQuantitys instead of doubles.
      *
      * Returns sample values for which select() would return the keyword.  If
      * the keyword is unknown, returns no values, but this is not an error.
@@ -488,7 +494,7 @@
      * @internal
      */
     int32_t getSamples(const UnicodeString &keyword,
-                       FixedDecimal *dest, int32_t destCapacity,
+                       DecimalQuantity *dest, int32_t destCapacity,
                        UErrorCode& status);
 #endif  /* U_HIDE_INTERNAL_API */
 
diff --git a/icu4c/source/test/intltest/plurults.cpp b/icu4c/source/test/intltest/plurults.cpp
index 54cc77a..8de9745 100644
--- a/icu4c/source/test/intltest/plurults.cpp
+++ b/icu4c/source/test/intltest/plurults.cpp
@@ -50,7 +50,9 @@
     TESTCASE_AUTO(testAPI);
     // TESTCASE_AUTO(testGetUniqueKeywordValue);
     TESTCASE_AUTO(testGetSamples);
-    TESTCASE_AUTO(testGetFixedDecimalSamples);
+    TESTCASE_AUTO(testGetDecimalQuantitySamples);
+    TESTCASE_AUTO(testGetOrAddSamplesFromString);
+    TESTCASE_AUTO(testGetOrAddSamplesFromStringCompactNotation);
     TESTCASE_AUTO(testSamplesWithExponent);
     TESTCASE_AUTO(testSamplesWithCompactNotation);
     TESTCASE_AUTO(testWithin);
@@ -396,9 +398,16 @@
     assertRuleKeyValue("a: n is 1", "other", UPLRULES_NO_UNIQUE_VALUE); // key matches default rule
 }
 
+/**
+ * Using the double API for getting plural samples, assert all samples match the keyword
+ * they are listed under, for all locales.
+ * 
+ * Specifically, iterate over all locales, get plural rules for the locale, iterate over every rule,
+ * then iterate over every sample in the rule, parse sample to a number (double), use that number
+ * as an input to .select() for the rules object, and assert the actual return plural keyword matches
+ * what we expect based on the plural rule string.
+ */
 void PluralRulesTest::testGetSamples() {
-    // TODO: fix samples, re-enable this test.
-
     // no get functional equivalent API in ICU4C, so just
     // test every locale...
     UErrorCode status = U_ZERO_ERROR;
@@ -457,21 +466,24 @@
     }
 }
 
-void PluralRulesTest::testGetFixedDecimalSamples() {
-    // TODO: fix samples, re-enable this test.
-
+/**
+ * Using the DecimalQuantity API for getting plural samples, assert all samples match the keyword
+ * they are listed under, for all locales.
+ * 
+ * Specifically, iterate over all locales, get plural rules for the locale, iterate over every rule,
+ * then iterate over every sample in the rule, parse sample to a number (DecimalQuantity), use that number
+ * as an input to .select() for the rules object, and assert the actual return plural keyword matches
+ * what we expect based on the plural rule string.
+ */
+void PluralRulesTest::testGetDecimalQuantitySamples() {
     // no get functional equivalent API in ICU4C, so just
     // test every locale...
     UErrorCode status = U_ZERO_ERROR;
     int32_t numLocales;
     const Locale* locales = Locale::getAvailableLocales(numLocales);
 
-    FixedDecimal values[1000];
+    DecimalQuantity values[1000];
     for (int32_t i = 0; U_SUCCESS(status) && i < numLocales; ++i) {
-        //if (uprv_strcmp(locales[i].getLanguage(), "fr") == 0 &&
-        //        logKnownIssue("21322", "PluralRules::getSamples cannot distinguish 1e5 from 100000")) {
-        //    continue;
-        //}
         LocalPointer<PluralRules> rules(PluralRules::forLocale(locales[i], status));
         if (U_FAILURE(status)) {
             break;
@@ -501,21 +513,24 @@
                 count = UPRV_LENGTHOF(values);
             }
             for (int32_t j = 0; j < count; ++j) {
-                if (values[j] == UPLRULES_NO_UNIQUE_VALUE_DECIMAL) {
+                if (values[j] == UPLRULES_NO_UNIQUE_VALUE_DECIMAL(status)) {
                     errln("got 'no unique value' among values");
                 } else {
+                    if (U_FAILURE(status)){
+                        errln(UnicodeString(u"getSamples() failed for sample ") +
+                            values[j].toExponentString() +
+                            UnicodeString(u", keyword ") + *keyword);
+                        continue;
+                    }
                     UnicodeString resultKeyword = rules->select(values[j]);
                     // if (strcmp(locales[i].getName(), "uk") == 0) {    // Debug only.
                     //     std::cout << "  uk " << US(resultKeyword).cstr() << " " << values[j] << std::endl;
                     // }
                     if (*keyword != resultKeyword) {
-                        if (values[j].exponent == 0 || !logKnownIssue("21714", "PluralRules::select treats 1c6 as 1")) {
-                            UnicodeString valueString(values[j].toString());
-                            char valueBuf[16];
-                            valueString.extract(0, valueString.length(), valueBuf, sizeof(valueBuf));
-                            errln("file %s, line %d, Locale %s, sample for keyword \"%s\":  %s, select(%s) returns keyword \"%s\"",
-                                      __FILE__, __LINE__, locales[i].getName(), US(*keyword).cstr(), valueBuf, valueBuf, US(resultKeyword).cstr());
-                        }
+                        errln("file %s, line %d, Locale %s, sample for keyword \"%s\":  %s, select(%s) returns keyword \"%s\"",
+                            __FILE__, __LINE__, locales[i].getName(), US(*keyword).cstr(),
+                            US(values[j].toExponentString()).cstr(), US(values[j].toExponentString()).cstr(),
+                            US(resultKeyword).cstr());
                     }
                 }
             }
@@ -523,6 +538,102 @@
     }
 }
 
+/**
+ * Test addSamples (Java) / getSamplesFromString (C++) to ensure the expansion of plural rule sample range
+ * expands to a sequence of sample numbers that is incremented as the right scale.
+ *
+ *  Do this for numbers with fractional digits but no exponent.
+ */
+void PluralRulesTest::testGetOrAddSamplesFromString() {
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString description(u"testkeyword: e != 0 @decimal 2.0c6~4.0c6, …");
+    LocalPointer<PluralRules> rules(PluralRules::createRules(description, status));
+    if (U_FAILURE(status)) {
+        errln("Couldn't create plural rules from a string, with error = %s", u_errorName(status));
+        return;
+    }
+
+    LocalPointer<StringEnumeration> keywords(rules->getKeywords(status));
+    if (U_FAILURE(status)) {
+        errln("Couldn't get keywords from a parsed rules object, with error = %s", u_errorName(status));
+        return;
+    }
+
+    DecimalQuantity values[1000];
+    const UnicodeString keyword(u"testkeyword");
+    int32_t count = rules->getSamples(keyword, values, UPRV_LENGTHOF(values), status);
+    if (U_FAILURE(status)) {
+        errln(UnicodeString(u"getSamples() failed for plural rule keyword ") + keyword);
+        return;
+    }
+
+    UnicodeString expDqStrs[] = {
+        u"2.0c6", u"2.1c6", u"2.2c6", u"2.3c6", u"2.4c6", u"2.5c6", u"2.6c6", u"2.7c6", u"2.8c6", u"2.9c6",
+        u"3.0c6", u"3.1c6", u"3.2c6", u"3.3c6", u"3.4c6", u"3.5c6", u"3.6c6", u"3.7c6", u"3.8c6", u"3.9c6",
+        u"4.0c6"
+    };
+    assertEquals(u"Number of parsed samples from test string incorrect", 21, count);
+    for (int i = 0; i < count; i++) {
+        UnicodeString expDqStr = expDqStrs[i];
+        DecimalQuantity sample = values[i];
+        UnicodeString sampleStr = sample.toExponentString();
+
+        assertEquals(u"Expansion of sample range to sequence of sample values should increment at the right scale",
+            expDqStr, sampleStr);
+    }
+}
+
+/**
+ * Test addSamples (Java) / getSamplesFromString (C++) to ensure the expansion of plural rule sample range
+ * expands to a sequence of sample numbers that is incremented as the right scale.
+ *
+ *  Do this for numbers written in a notation that has an exponent, for which the number is an
+ *  integer (also as defined in the UTS 35 spec for the plural operands) but whose representation
+ *  has fractional digits in the significand written before the exponent.
+ */
+void PluralRulesTest::testGetOrAddSamplesFromStringCompactNotation() {
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString description(u"testkeyword: e != 0 @decimal 2.0~4.0, …");
+    LocalPointer<PluralRules> rules(PluralRules::createRules(description, status));
+    if (U_FAILURE(status)) {
+        errln("Couldn't create plural rules from a string, with error = %s", u_errorName(status));
+        return;
+    }
+
+    LocalPointer<StringEnumeration> keywords(rules->getKeywords(status));
+    if (U_FAILURE(status)) {
+        errln("Couldn't get keywords from a parsed rules object, with error = %s", u_errorName(status));
+        return;
+    }
+
+    DecimalQuantity values[1000];
+    const UnicodeString keyword(u"testkeyword");
+    int32_t count = rules->getSamples(keyword, values, UPRV_LENGTHOF(values), status);
+    if (U_FAILURE(status)) {
+        errln(UnicodeString(u"getSamples() failed for plural rule keyword ") + keyword);
+        return;
+    }
+
+    UnicodeString expDqStrs[] = {
+        u"2.0", u"2.1", u"2.2", u"2.3", u"2.4", u"2.5", u"2.6", u"2.7", u"2.8", u"2.9",
+        u"3.0", u"3.1", u"3.2", u"3.3", u"3.4", u"3.5", u"3.6", u"3.7", u"3.8", u"3.9",
+        u"4.0"
+    };
+    assertEquals(u"Number of parsed samples from test string incorrect", 21, count);
+    for (int i = 0; i < count; i++) {
+        UnicodeString expDqStr = expDqStrs[i];
+        DecimalQuantity sample = values[i];
+        UnicodeString sampleStr = sample.toExponentString();
+
+        assertEquals(u"Expansion of sample range to sequence of sample values should increment at the right scale",
+            expDqStr, sampleStr);
+    }
+}
+
+/**
+ * This test is for the support of X.YeZ scientific notation of numbers in
+ * the plural sample string.
+ */
 void PluralRulesTest::testSamplesWithExponent() {
     // integer samples
     UErrorCode status = U_ZERO_ERROR;
@@ -538,9 +649,9 @@
         errln("Couldn't create plural rules from a string using exponent notation, with error = %s", u_errorName(status));
         return;
     }
-    checkNewSamples(description, test, u"one", u"@integer 0, 1, 1e5", FixedDecimal(0));
-    checkNewSamples(description, test, u"many", u"@integer 1000000, 2e6, 3e6, 4e6, 5e6, 6e6, 7e6, …", FixedDecimal(1000000));
-    checkNewSamples(description, test, u"other", u"@integer 2~17, 100, 1000, 10000, 100000, 2e5, 3e5, 4e5, 5e5, 6e5, 7e5, …", FixedDecimal(2));
+    checkNewSamples(description, test, u"one", u"@integer 0, 1, 1e5", DecimalQuantity::fromExponentString(u"0", status));
+    checkNewSamples(description, test, u"many", u"@integer 1000000, 2e6, 3e6, 4e6, 5e6, 6e6, 7e6, …", DecimalQuantity::fromExponentString(u"1000000", status));
+    checkNewSamples(description, test, u"other", u"@integer 2~17, 100, 1000, 10000, 100000, 2e5, 3e5, 4e5, 5e5, 6e5, 7e5, …", DecimalQuantity::fromExponentString(u"2", status));
 
     // decimal samples
     status = U_ZERO_ERROR;
@@ -555,12 +666,15 @@
         errln("Couldn't create plural rules from a string using exponent notation, with error = %s", u_errorName(status));
         return;
     }
-    checkNewSamples(description2, test2, u"one", u"@decimal 0.0~1.5, 1.1e5", FixedDecimal(0, 1));
-    checkNewSamples(description2, test2, u"many", u"@decimal 2.1e6, 3.1e6, 4.1e6, 5.1e6, 6.1e6, 7.1e6, …", FixedDecimal::createWithExponent(2.1, 1, 6));
-    checkNewSamples(description2, test2, u"other", u"@decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 2.1e5, 3.1e5, 4.1e5, 5.1e5, 6.1e5, 7.1e5, …", FixedDecimal(2.0, 1));
+    checkNewSamples(description2, test2, u"one", u"@decimal 0.0~1.5, 1.1e5", DecimalQuantity::fromExponentString(u"0.0", status));
+    checkNewSamples(description2, test2, u"many", u"@decimal 2.1e6, 3.1e6, 4.1e6, 5.1e6, 6.1e6, 7.1e6, …", DecimalQuantity::fromExponentString(u"2.1c6", status));
+    checkNewSamples(description2, test2, u"other", u"@decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 2.1e5, 3.1e5, 4.1e5, 5.1e5, 6.1e5, 7.1e5, …", DecimalQuantity::fromExponentString(u"2.0", status));
 }
 
-
+/**
+ * This test is for the support of X.YcZ compact notation of numbers in
+ * the plural sample string.
+ */
 void PluralRulesTest::testSamplesWithCompactNotation() {
     // integer samples
     UErrorCode status = U_ZERO_ERROR;
@@ -576,9 +690,9 @@
         errln("Couldn't create plural rules from a string using exponent notation, with error = %s", u_errorName(status));
         return;
     }
-    checkNewSamples(description, test, u"one", u"@integer 0, 1, 1c5", FixedDecimal(0));
-    checkNewSamples(description, test, u"many", u"@integer 1000000, 2c6, 3c6, 4c6, 5c6, 6c6, 7c6, …", FixedDecimal(1000000));
-    checkNewSamples(description, test, u"other", u"@integer 2~17, 100, 1000, 10000, 100000, 2c5, 3c5, 4c5, 5c5, 6c5, 7c5, …", FixedDecimal(2));
+    checkNewSamples(description, test, u"one", u"@integer 0, 1, 1c5", DecimalQuantity::fromExponentString(u"0", status));
+    checkNewSamples(description, test, u"many", u"@integer 1000000, 2c6, 3c6, 4c6, 5c6, 6c6, 7c6, …", DecimalQuantity::fromExponentString(u"1000000", status));
+    checkNewSamples(description, test, u"other", u"@integer 2~17, 100, 1000, 10000, 100000, 2c5, 3c5, 4c5, 5c5, 6c5, 7c5, …", DecimalQuantity::fromExponentString(u"2", status));
 
     // decimal samples
     status = U_ZERO_ERROR;
@@ -593,9 +707,9 @@
         errln("Couldn't create plural rules from a string using exponent notation, with error = %s", u_errorName(status));
         return;
     }
-    checkNewSamples(description2, test2, u"one", u"@decimal 0.0~1.5, 1.1c5", FixedDecimal(0, 1));
-    checkNewSamples(description2, test2, u"many", u"@decimal 2.1c6, 3.1c6, 4.1c6, 5.1c6, 6.1c6, 7.1c6, …", FixedDecimal::createWithExponent(2.1, 1, 6));
-    checkNewSamples(description2, test2, u"other", u"@decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 2.1c5, 3.1c5, 4.1c5, 5.1c5, 6.1c5, 7.1c5, …", FixedDecimal(2.0, 1));
+    checkNewSamples(description2, test2, u"one", u"@decimal 0.0~1.5, 1.1c5", DecimalQuantity::fromExponentString(u"0.0", status));
+    checkNewSamples(description2, test2, u"many", u"@decimal 2.1c6, 3.1c6, 4.1c6, 5.1c6, 6.1c6, 7.1c6, …", DecimalQuantity::fromExponentString(u"2.1c6", status));
+    checkNewSamples(description2, test2, u"other", u"@decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 2.1c5, 3.1c5, 4.1c5, 5.1c5, 6.1c5, 7.1c5, …", DecimalQuantity::fromExponentString(u"2.0", status));
 }
 
 void PluralRulesTest::checkNewSamples(
@@ -603,17 +717,17 @@
         const LocalPointer<PluralRules> &test,
         UnicodeString keyword,
         UnicodeString samplesString,
-        FixedDecimal firstInRange) {
+        DecimalQuantity firstInRange) {
 
     UErrorCode status = U_ZERO_ERROR;
-    FixedDecimal samples[1000];
+    DecimalQuantity samples[1000];
     
     test->getSamples(keyword, samples, UPRV_LENGTHOF(samples), status);
     if (U_FAILURE(status)) {
         errln("Couldn't retrieve plural samples, with error = %s", u_errorName(status));
         return;
     }
-    FixedDecimal actualFirstSample = samples[0];
+    DecimalQuantity actualFirstSample = samples[0];
 
     if (!(firstInRange == actualFirstSample)) {
         CStr descCstr(description);
@@ -776,6 +890,11 @@
 
 // For the time being, the  compact notation exponent operand `c` is an alias
 // for the scientific exponent operand `e` and compact notation.
+/**
+ * Test the proper plural rule keyword selection given an input number that is
+ * already formatted into scientific notation. This exercises the `e` plural operand
+ * for the formatted number.
+ */
 void
 PluralRulesTest::testScientificPluralKeyword() {
     IcuTestErrorCode errorCode(*this, "testScientificPluralKeyword");
@@ -838,6 +957,11 @@
     }
 }
 
+/**
+ * Test the proper plural rule keyword selection given an input number that is
+ * already formatted into compact notation. This exercises the `c` plural operand
+ * for the formatted number.
+ */
 void
 PluralRulesTest::testCompactDecimalPluralKeyword() {
     IcuTestErrorCode errorCode(*this, "testCompactDecimalPluralKeyword");
diff --git a/icu4c/source/test/intltest/plurults.h b/icu4c/source/test/intltest/plurults.h
index 76ecb6b..f02a484 100644
--- a/icu4c/source/test/intltest/plurults.h
+++ b/icu4c/source/test/intltest/plurults.h
@@ -14,6 +14,7 @@
 #if !UCONFIG_NO_FORMATTING
 
 #include "intltest.h"
+#include "number_decimalquantity.h"
 #include "unicode/localpointer.h"
 #include "unicode/plurrule.h"
 
@@ -30,7 +31,9 @@
     void testAPI();
     void testGetUniqueKeywordValue();
     void testGetSamples();
-    void testGetFixedDecimalSamples();
+    void testGetDecimalQuantitySamples();
+    void testGetOrAddSamplesFromString();
+    void testGetOrAddSamplesFromStringCompactNotation();
     void testSamplesWithExponent();
     void testSamplesWithCompactNotation();
     void testWithin();
@@ -55,7 +58,7 @@
                          const LocalPointer<PluralRules> &test,
                          UnicodeString keyword,
                          UnicodeString samplesString,
-                         FixedDecimal firstInRange);
+                         ::icu::number::impl::DecimalQuantity firstInRange);
     UnicodeString getPluralKeyword(const LocalPointer<PluralRules> &rules,
                                    Locale locale, double number, const char16_t* skeleton);
     void checkSelect(const LocalPointer<PluralRules> &rules, UErrorCode &status, 
diff --git a/icu4j/main/classes/core/src/com/ibm/icu/text/PluralRules.java b/icu4j/main/classes/core/src/com/ibm/icu/text/PluralRules.java
index bf0e411..9cc7923 100644
--- a/icu4j/main/classes/core/src/com/ibm/icu/text/PluralRules.java
+++ b/icu4j/main/classes/core/src/com/ibm/icu/text/PluralRules.java
@@ -15,21 +15,22 @@
 import java.io.ObjectOutputStream;
 import java.io.ObjectStreamException;
 import java.io.Serializable;
+import java.math.BigDecimal;
 import java.text.ParseException;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Set;
-import java.util.TreeSet;
 import java.util.regex.Pattern;
 
 import com.ibm.icu.impl.PluralRulesLoader;
 import com.ibm.icu.impl.StandardPlural;
+import com.ibm.icu.impl.number.DecimalQuantity;
+import com.ibm.icu.impl.number.DecimalQuantity_DualStorageBCD;
 import com.ibm.icu.impl.number.range.StandardPluralRanges;
 import com.ibm.icu.number.FormattedNumber;
 import com.ibm.icu.number.FormattedNumberRange;
@@ -330,6 +331,16 @@
     public static final double NO_UNIQUE_VALUE = -0.00123456777;
 
     /**
+     * Value returned by {@link #getUniqueKeywordDecimalQuantityValue} when there is no
+     * unique value to return.
+     * @internal CLDR
+     * @deprecated This API is ICU internal only.
+     */
+    @Deprecated
+    public static final DecimalQuantity NO_UNIQUE_VALUE_DECIMAL_QUANTITY =
+        new DecimalQuantity_DualStorageBCD(-0.00123456777);
+
+    /**
      * Type of plurals and PluralRules.
      * @stable ICU 50
      */
@@ -868,50 +879,6 @@
         }
 
         /**
-         * @internal CLDR
-         * @deprecated This API is ICU internal only.
-         */
-        @Deprecated
-        public FixedDecimal (String n) {
-            // Ugly, but for samples we don't care.
-            this(parseDecimalSampleRangeNumString(n));
-        }
-
-        /**
-         * @internal CLDR
-         * @deprecated This API is ICU internal only
-         */
-        @Deprecated
-        private static FixedDecimal parseDecimalSampleRangeNumString(String num) {
-            if (num.contains("e") || num.contains("c")) {
-                int ePos = num.lastIndexOf('e');
-                if (ePos < 0) {
-                    ePos = num.lastIndexOf('c');
-                }
-                int expNumPos = ePos + 1;
-                String exponentStr = num.substring(expNumPos);
-                int exponent = Integer.parseInt(exponentStr);
-                String fractionStr = num.substring(0, ePos);
-                return FixedDecimal.createWithExponent(
-                        Double.parseDouble(fractionStr),
-                        getVisibleFractionCount(fractionStr),
-                        exponent);
-            } else {
-                return new FixedDecimal(Double.parseDouble(num), getVisibleFractionCount(num));
-            }
-        }
-
-        private static int getVisibleFractionCount(String value) {
-            value = value.trim();
-            int decimalPos = value.indexOf('.') + 1;
-            if (decimalPos == 0) {
-                return 0;
-            } else {
-                return value.length() - decimalPos;
-            }
-        }
-
-        /**
          * {@inheritDoc}
          *
          * @internal CLDR
@@ -1070,19 +1037,6 @@
             return (isNegative ? -source : source) * Math.pow(10, exponent);
         }
 
-        /**
-         * @internal CLDR
-         * @deprecated This API is ICU internal only.
-         */
-        @Deprecated
-        public long getShiftedValue() {
-            if (exponent != 0 && visibleDecimalDigitCount == 0 && decimalDigits == 0) {
-                // Need to take exponent into account if we have it
-                return (long)(source * Math.pow(10, exponent));
-            }
-            return integerValue * baseFactor + decimalDigits;
-        }
-
         private void writeObject(
                 ObjectOutputStream out)
                         throws IOException {
@@ -1141,31 +1095,32 @@
     }
 
     /**
-     * A range of NumberInfo that includes all values with the same visibleFractionDigitCount.
+     * A range of DecimalQuantity representing PluralRules samples that includes
+     * all values with the same visibleFractionDigitCount.
      * @internal CLDR
      * @deprecated This API is ICU internal only.
      */
     @Deprecated
-    public static class FixedDecimalRange {
+    public static class DecimalQuantitySamplesRange {
         /**
          * @internal CLDR
          * @deprecated This API is ICU internal only.
          */
         @Deprecated
-        public final FixedDecimal start;
+        public final DecimalQuantity start;
         /**
          * @internal CLDR
          * @deprecated This API is ICU internal only.
          */
         @Deprecated
-        public final FixedDecimal end;
+        public final DecimalQuantity end;
         /**
          * @internal CLDR
          * @deprecated This API is ICU internal only.
          */
         @Deprecated
-        public FixedDecimalRange(FixedDecimal start, FixedDecimal end) {
-            if (start.visibleDecimalDigitCount != end.visibleDecimalDigitCount) {
+        public DecimalQuantitySamplesRange(DecimalQuantity start, DecimalQuantity end) {
+            if (start.getPluralOperand(Operand.v)!= end.getPluralOperand(Operand.v)) {
                 throw new IllegalArgumentException("Ranges must have the same number of visible decimals: " + start + "~" + end);
             }
             this.start = start;
@@ -1178,17 +1133,18 @@
         @Deprecated
         @Override
         public String toString() {
-            return start + (end == start ? "" : "~" + end);
+            return start.toExponentString() + (end == start ? "" : "~" + end.toExponentString());
         }
     }
 
     /**
-     * A list of NumberInfo that includes all values with the same visibleFractionDigitCount.
+     * A list of DecimalQuantity representing PluralRules that includes all
+     * values with the same visibleFractionDigitCount.
      * @internal CLDR
      * @deprecated This API is ICU internal only.
      */
     @Deprecated
-    public static class FixedDecimalSamples {
+    public static class DecimalQuantitySamples {
         /**
          * @internal CLDR
          * @deprecated This API is ICU internal only.
@@ -1200,7 +1156,7 @@
          * @deprecated This API is ICU internal only.
          */
         @Deprecated
-        public final Set<FixedDecimalRange> samples;
+        public final Set<DecimalQuantitySamplesRange> samples;
         /**
          * @internal CLDR
          * @deprecated This API is ICU internal only.
@@ -1212,7 +1168,7 @@
          * @param sampleType
          * @param samples
          */
-        private FixedDecimalSamples(SampleType sampleType, Set<FixedDecimalRange> samples, boolean bounded) {
+        private DecimalQuantitySamples(SampleType sampleType, Set<DecimalQuantitySamplesRange> samples, boolean bounded) {
             super();
             this.sampleType = sampleType;
             this.samples = samples;
@@ -1221,11 +1177,11 @@
         /*
          * Parse a list of the form described in CLDR. The source must be trimmed.
          */
-        static FixedDecimalSamples parse(String source) {
+        static DecimalQuantitySamples parse(String source) {
             SampleType sampleType2;
             boolean bounded2 = true;
             boolean haveBound = false;
-            Set<FixedDecimalRange> samples2 = new LinkedHashSet<>();
+            Set<DecimalQuantitySamplesRange> samples2 = new LinkedHashSet<>();
 
             if (source.startsWith("integer")) {
                 sampleType2 = SampleType.INTEGER;
@@ -1248,25 +1204,33 @@
                 String[] rangeParts = TILDE_SEPARATED.split(range, 0);
                 switch (rangeParts.length) {
                 case 1:
-                    FixedDecimal sample = new FixedDecimal(rangeParts[0]);
+                    DecimalQuantity sample =
+                        DecimalQuantity_DualStorageBCD.fromExponentString(rangeParts[0]);
                     checkDecimal(sampleType2, sample);
-                    samples2.add(new FixedDecimalRange(sample, sample));
+                    samples2.add(new DecimalQuantitySamplesRange(sample, sample));
                     break;
                 case 2:
-                    FixedDecimal start = new FixedDecimal(rangeParts[0]);
-                    FixedDecimal end = new FixedDecimal(rangeParts[1]);
+                    DecimalQuantity start =
+                            DecimalQuantity_DualStorageBCD.fromExponentString(rangeParts[0]);
+                    DecimalQuantity end =
+                            DecimalQuantity_DualStorageBCD.fromExponentString(rangeParts[1]);
                     checkDecimal(sampleType2, start);
                     checkDecimal(sampleType2, end);
-                    samples2.add(new FixedDecimalRange(start, end));
+                    samples2.add(new DecimalQuantitySamplesRange(start, end));
                     break;
                 default: throw new IllegalArgumentException("Ill-formed number range: " + range);
                 }
             }
-            return new FixedDecimalSamples(sampleType2, Collections.unmodifiableSet(samples2), bounded2);
+            return new DecimalQuantitySamples(sampleType2, Collections.unmodifiableSet(samples2), bounded2);
         }
 
-        private static void checkDecimal(SampleType sampleType2, FixedDecimal sample) {
-            if ((sampleType2 == SampleType.INTEGER) != (sample.getVisibleDecimalDigitCount() == 0)) {
+        private static void checkDecimal(SampleType sampleType2, DecimalQuantity sample) {
+            // TODO(CLDR-15452): Remove the need for the fallback check for exponent notation integers classified
+            // as "@decimal" type samples, if/when changes are made to
+            // resolve https://unicode-org.atlassian.net/browse/CLDR-15452
+            if ((sampleType2 == SampleType.INTEGER && sample.getPluralOperand(Operand.v) != 0)
+                    || (sampleType2 == SampleType.DECIMAL && sample.getPluralOperand(Operand.v) == 0
+                        && sample.getPluralOperand(Operand.e) == 0)) {
                 throw new IllegalArgumentException("Ill-formed number range: " + sample);
             }
         }
@@ -1276,17 +1240,64 @@
          * @deprecated This API is ICU internal only.
          */
         @Deprecated
-        public Set<Double> addSamples(Set<Double> result) {
-            for (FixedDecimalRange item : samples) {
-                // we have to convert to longs so we don't get strange double issues
-                long startDouble = item.start.getShiftedValue();
-                long endDouble = item.end.getShiftedValue();
+        public Collection<Double> addSamples(Collection<Double> result) {
+            addSamples(result, null);
+            return result;
+        }
 
-                for (long d = startDouble; d <= endDouble; d += 1) {
-                    result.add(d/(double)item.start.baseFactor);
+        /**
+         * @internal CLDR
+         * @deprecated This API is ICU internal only.
+         */
+        @Deprecated
+        public Collection<DecimalQuantity> addDecimalQuantitySamples(Collection<DecimalQuantity> result) {
+            addSamples(null, result);
+            return result;
+        }
+
+        /**
+         * @internal CLDR
+         * @deprecated This API is ICU internal only.
+         */
+        @Deprecated
+        public void addSamples(Collection<Double> doubleResult, Collection<DecimalQuantity> dqResult) {
+            if ((doubleResult == null && dqResult == null)
+                    || (doubleResult != null && dqResult != null)) {
+                return;
+            }
+            boolean isDouble = doubleResult != null;
+            for (DecimalQuantitySamplesRange range : samples) {
+                DecimalQuantity start = range.start;
+                DecimalQuantity end = range.end;
+                int lowerDispMag = start.getLowerDisplayMagnitude();
+                int exponent = start.getExponent();
+                int incrementScale = lowerDispMag + exponent;
+                BigDecimal incrementBd = BigDecimal.ONE.movePointRight(incrementScale);
+
+                for (DecimalQuantity dq = start.createCopy(); dq.toDouble() <= end.toDouble(); ) {
+                    if (isDouble) {
+                        double dblValue = dq.toDouble();
+                        // Hack Alert: don't return any decimal samples with integer values that
+                        //    originated from a format with trailing decimals.
+                        //    This API is returning doubles, which can't distinguish having displayed
+                        //    zeros to the right of the decimal.
+                        //    This results in test failures with values mapping back to a different keyword.
+                        if (!(dblValue == Math.floor(dblValue)) && dq.getPluralOperand(Operand.v) > 0) {
+                            doubleResult.add(dblValue);
+                        }
+                    } else {
+                        dqResult.add(dq);
+                    }
+
+                    // Increment dq for next iteration
+                    java.math.BigDecimal dqBd = dq.toBigDecimal();
+                    java.math.BigDecimal newDqBd = dqBd.add(incrementBd);
+                    dq = new DecimalQuantity_DualStorageBCD(newDqBd);
+                    dq.setMinFraction(-lowerDispMag);
+                    dq.adjustMagnitude(-exponent);
+                    dq.adjustExponent(exponent);
                 }
             }
-            return result;
         }
 
         /**
@@ -1298,7 +1309,7 @@
         public String toString() {
             StringBuilder b = new StringBuilder("@").append(sampleType.toString().toLowerCase(Locale.ENGLISH));
             boolean first = true;
-            for (FixedDecimalRange item : samples) {
+            for (DecimalQuantitySamplesRange item : samples) {
                 if (first) {
                     first = false;
                 } else {
@@ -1317,7 +1328,7 @@
          * @deprecated This API is ICU internal only.
          */
         @Deprecated
-        public Set<FixedDecimalRange> getSamples() {
+        public Set<DecimalQuantitySamplesRange> getSamples() {
             return samples;
         }
 
@@ -1326,10 +1337,10 @@
          * @deprecated This API is ICU internal only.
          */
         @Deprecated
-        public void getStartEndSamples(Set<FixedDecimal> target) {
-            for (FixedDecimalRange item : samples) {
-                target.add(item.start);
-                target.add(item.end);
+        public void getStartEndSamples(Set<DecimalQuantity> target) {
+            for (DecimalQuantitySamplesRange range : samples) {
+                target.add(range.start);
+                target.add(range.end);
             }
         }
     }
@@ -1610,19 +1621,19 @@
         description = description.substring(x+1).trim();
         String[] constraintOrSamples = AT_SEPARATED.split(description, 0);
         boolean sampleFailure = false;
-        FixedDecimalSamples integerSamples = null, decimalSamples = null;
+        DecimalQuantitySamples integerSamples = null, decimalSamples = null;
         switch (constraintOrSamples.length) {
         case 1: break;
         case 2:
-            integerSamples = FixedDecimalSamples.parse(constraintOrSamples[1]);
+            integerSamples = DecimalQuantitySamples.parse(constraintOrSamples[1]);
             if (integerSamples.sampleType == SampleType.DECIMAL) {
                 decimalSamples = integerSamples;
                 integerSamples = null;
             }
             break;
         case 3:
-            integerSamples = FixedDecimalSamples.parse(constraintOrSamples[1]);
-            decimalSamples = FixedDecimalSamples.parse(constraintOrSamples[2]);
+            integerSamples = DecimalQuantitySamples.parse(constraintOrSamples[1]);
+            decimalSamples = DecimalQuantitySamples.parse(constraintOrSamples[2]);
             if (integerSamples.sampleType != SampleType.INTEGER || decimalSamples.sampleType != SampleType.DECIMAL) {
                 throw new IllegalArgumentException("Must have @integer then @decimal in " + description);
             }
@@ -1857,10 +1868,10 @@
         private static final long serialVersionUID = 1;
         private final String keyword;
         private final Constraint constraint;
-        private final FixedDecimalSamples integerSamples;
-        private final FixedDecimalSamples decimalSamples;
+        private final DecimalQuantitySamples integerSamples;
+        private final DecimalQuantitySamples decimalSamples;
 
-        public Rule(String keyword, Constraint constraint, FixedDecimalSamples integerSamples, FixedDecimalSamples decimalSamples) {
+        public Rule(String keyword, Constraint constraint, DecimalQuantitySamples integerSamples, DecimalQuantitySamples decimalSamples) {
             this.keyword = keyword;
             this.constraint = constraint;
             this.integerSamples = integerSamples;
@@ -1972,7 +1983,7 @@
 
         public boolean isLimited(String keyword, SampleType sampleType) {
             if (hasExplicitBoundingInfo) {
-                FixedDecimalSamples mySamples = getDecimalSamples(keyword, sampleType);
+                DecimalQuantitySamples mySamples = getDecimalSamples(keyword, sampleType);
                 return mySamples == null ? true : mySamples.bounded;
             }
 
@@ -2024,7 +2035,7 @@
             return false;
         }
 
-        public FixedDecimalSamples getDecimalSamples(String keyword, SampleType sampleType) {
+        public DecimalQuantitySamples getDecimalSamples(String keyword, SampleType sampleType) {
             for (Rule rule : rules) {
                 if (rule.getKeyword().equals(keyword)) {
                     return sampleType == SampleType.INTEGER ? rule.integerSamples : rule.decimalSamples;
@@ -2285,11 +2296,29 @@
      * @stable ICU 4.8
      */
     public double getUniqueKeywordValue(String keyword) {
-        Collection<Double> values = getAllKeywordValues(keyword);
+        DecimalQuantity uniqValDq = getUniqueKeywordDecimalQuantityValue(keyword);
+        if (uniqValDq.equals(NO_UNIQUE_VALUE_DECIMAL_QUANTITY)) {
+            return NO_UNIQUE_VALUE;
+        } else {
+            return uniqValDq.toDouble();
+        }
+    }
+
+    /**
+     * Returns the unique value that this keyword matches, or {@link #NO_UNIQUE_VALUE}
+     * if the keyword matches multiple values or is not defined for this PluralRules.
+     *
+     * @param keyword the keyword to check for a unique value
+     * @internal Visible For Testing
+     * @deprecated This API is ICU internal only.
+     */
+    @Deprecated
+    public DecimalQuantity getUniqueKeywordDecimalQuantityValue(String keyword) {
+        Collection<DecimalQuantity> values = getAllKeywordDecimalQuantityValues(keyword);
         if (values != null && values.size() == 1) {
             return values.iterator().next();
         }
-        return NO_UNIQUE_VALUE;
+        return NO_UNIQUE_VALUE_DECIMAL_QUANTITY;
     }
 
     /**
@@ -2302,6 +2331,31 @@
      * @stable ICU 4.8
      */
     public Collection<Double> getAllKeywordValues(String keyword) {
+        Collection<DecimalQuantity> samples = getAllKeywordDecimalQuantityValues(keyword);
+        if (samples == null) {
+            return null;
+        } else {
+            Collection<Double> result = new LinkedHashSet<>();
+            for (DecimalQuantity dq : samples) {
+                result.add(dq.toDouble());
+            }
+            return result;
+        }
+    }
+
+    /**
+     * Returns all the values that trigger this keyword, or null if the number of such
+     * values is unlimited.
+     *
+     * @param keyword the keyword
+     * @return the values that trigger this keyword, or null.  The returned collection
+     * is immutable. It will be empty if the keyword is not defined.
+     *
+     * @internal Visible For Testing
+     * @deprecated This API is ICU internal only.
+     */
+    @Deprecated
+    public Collection<DecimalQuantity> getAllKeywordDecimalQuantityValues(String keyword) {
         return getAllKeywordValues(keyword, SampleType.INTEGER);
     }
 
@@ -2318,12 +2372,11 @@
      * @deprecated This API is ICU internal only.
      */
     @Deprecated
-    public Collection<Double> getAllKeywordValues(String keyword, SampleType type) {
+    public Collection<DecimalQuantity> getAllKeywordValues(String keyword, SampleType type) {
         if (!isLimited(keyword, type)) {
             return null;
         }
-        Collection<Double> samples = getSamples(keyword, type);
-        return samples == null ? null : Collections.unmodifiableCollection(samples);
+        return getDecimalQuantitySamples(keyword, type);
     }
 
     /**
@@ -2341,6 +2394,22 @@
     }
 
     /**
+     * Returns a list of integer values for which select() would return that keyword,
+     * or null if the keyword is not defined. The returned collection is unmodifiable.
+     * The returned list is not complete, and there might be additional values that
+     * would return the keyword.
+     *
+     * @param keyword the keyword to test
+     * @return a list of values matching the keyword.
+     * @internal CLDR
+     * @deprecated ICU internal only
+     */
+    @Deprecated
+  public Collection<DecimalQuantity> getDecimalQuantitySamples(String keyword) {
+        return getDecimalQuantitySamples(keyword, SampleType.INTEGER);
+    }
+
+    /**
      * Returns a list of values for which select() would return that keyword,
      * or null if the keyword is not defined.
      * The returned collection is unmodifiable.
@@ -2356,15 +2425,43 @@
      */
     @Deprecated
     public Collection<Double> getSamples(String keyword, SampleType sampleType) {
+        Collection<DecimalQuantity> samples = getDecimalQuantitySamples(keyword, sampleType);
+        if (samples == null) {
+            return null;
+        } else {
+            Collection<Double> result = new LinkedHashSet<>();
+            for (DecimalQuantity dq: samples) {
+                result.add(dq.toDouble());
+            }
+            return result;
+        }
+    }
+
+    /**
+     * Returns a list of values for which select() would return that keyword,
+     * or null if the keyword is not defined.
+     * The returned collection is unmodifiable.
+     * The returned list is not complete, and there might be additional values that
+     * would return the keyword. The keyword might be defined, and yet have an empty set of samples,
+     * IF there are samples for the other sampleType.
+     *
+     * @param keyword the keyword to test
+     * @param sampleType the type of samples requested, INTEGER or DECIMAL
+     * @return a list of values matching the keyword.
+     * @internal CLDR
+     * @deprecated ICU internal only
+     */
+    @Deprecated
+    public Collection<DecimalQuantity> getDecimalQuantitySamples(String keyword, SampleType sampleType) {
         if (!keywords.contains(keyword)) {
             return null;
         }
-        Set<Double> result = new TreeSet<>();
+        Set<DecimalQuantity> result = new LinkedHashSet<>();
 
         if (rules.hasExplicitBoundingInfo) {
-            FixedDecimalSamples samples = rules.getDecimalSamples(keyword, sampleType);
+            DecimalQuantitySamples samples = rules.getDecimalSamples(keyword, sampleType);
             return samples == null ? Collections.unmodifiableSet(result)
-                    : Collections.unmodifiableSet(samples.addSamples(result));
+                    : Collections.unmodifiableCollection(samples.addDecimalQuantitySamples(result));
         }
 
         // hack in case the rule is created without explicit samples
@@ -2373,28 +2470,31 @@
         switch (sampleType) {
         case INTEGER:
             for (int i = 0; i < 200; ++i) {
-                if (!addSample(keyword, i, maxCount, result)) {
+                if (!addSample(keyword, new DecimalQuantity_DualStorageBCD(i), maxCount, result)) {
                     break;
                 }
             }
-            addSample(keyword, 1000000, maxCount, result); // hack for Welsh
+            addSample(keyword, new DecimalQuantity_DualStorageBCD(1000000), maxCount, result); // hack for Welsh
             break;
         case DECIMAL:
             for (int i = 0; i < 2000; ++i) {
-                if (!addSample(keyword, new FixedDecimal(i/10d, 1), maxCount, result)) {
+                DecimalQuantity_DualStorageBCD nextSample = new DecimalQuantity_DualStorageBCD(i);
+                nextSample.adjustMagnitude(-1);
+                if (!addSample(keyword, nextSample, maxCount, result)) {
                     break;
                 }
             }
-            addSample(keyword, new FixedDecimal(1000000d, 1), maxCount, result); // hack for Welsh
+            addSample(keyword, DecimalQuantity_DualStorageBCD.fromExponentString("1000000.0"), maxCount, result); // hack for Welsh
             break;
         }
+
         return result.size() == 0 ? null : Collections.unmodifiableSet(result);
     }
 
-    private boolean addSample(String keyword, Number sample, int maxCount, Set<Double> result) {
-        String selectedKeyword = sample instanceof FixedDecimal ? select((FixedDecimal)sample) : select(sample.doubleValue());
+    private boolean addSample(String keyword, DecimalQuantity sample, int maxCount, Set<DecimalQuantity> result) {
+        String selectedKeyword = select(sample);
         if (selectedKeyword.equals(keyword)) {
-            result.add(sample.doubleValue());
+            result.add(sample);
             if (--maxCount < 0) {
                 return false;
             }
@@ -2416,7 +2516,7 @@
      * @deprecated This API is ICU internal only.
      */
     @Deprecated
-    public FixedDecimalSamples getDecimalSamples(String keyword, SampleType sampleType) {
+    public DecimalQuantitySamples getDecimalSamples(String keyword, SampleType sampleType) {
         return rules.getDecimalSamples(keyword, sampleType);
     }
 
@@ -2525,14 +2625,14 @@
      *            the offset used, or 0.0d if not. Internally, the offset is subtracted from each explicit value before
      *            checking against the keyword values.
      * @param explicits
-     *            a set of Doubles that are used explicitly (eg [=0], "[=1]"). May be empty or null.
+     *            a set of {@code DecimalQuantity}s that are used explicitly (eg [=0], "[=1]"). May be empty or null.
      * @param uniqueValue
      *            If non null, set to the unique value.
      * @return the KeywordStatus
      * @draft ICU 50
      */
-    public KeywordStatus getKeywordStatus(String keyword, int offset, Set<Double> explicits,
-            Output<Double> uniqueValue) {
+    public KeywordStatus getKeywordStatus(String keyword, int offset, Set<DecimalQuantity> explicits,
+            Output<DecimalQuantity> uniqueValue) {
         return getKeywordStatus(keyword, offset, explicits, uniqueValue, SampleType.INTEGER);
     }
     /**
@@ -2544,7 +2644,7 @@
      *            the offset used, or 0.0d if not. Internally, the offset is subtracted from each explicit value before
      *            checking against the keyword values.
      * @param explicits
-     *            a set of Doubles that are used explicitly (eg [=0], "[=1]"). May be empty or null.
+     *            a set of {@code DecimalQuantity}s that are used explicitly (eg [=0], "[=1]"). May be empty or null.
      * @param sampleType
      *            request KeywordStatus relative to INTEGER or DECIMAL values
      * @param uniqueValue
@@ -2554,8 +2654,8 @@
      * @deprecated This API is ICU internal only.
      */
     @Deprecated
-    public KeywordStatus getKeywordStatus(String keyword, int offset, Set<Double> explicits,
-            Output<Double> uniqueValue, SampleType sampleType) {
+    public KeywordStatus getKeywordStatus(String keyword, int offset,
+            Set<DecimalQuantity> explicits, Output<DecimalQuantity> uniqueValue, SampleType sampleType) {
         if (uniqueValue != null) {
             uniqueValue.value = null;
         }
@@ -2568,7 +2668,7 @@
             return KeywordStatus.UNBOUNDED;
         }
 
-        Collection<Double> values = getSamples(keyword, sampleType);
+        Collection<DecimalQuantity> values = getDecimalQuantitySamples(keyword, sampleType);
 
         int originalSize = values.size();
 
@@ -2590,9 +2690,12 @@
 
         // Compute if the quick test is insufficient.
 
-        HashSet<Double> subtractedSet = new HashSet<>(values);
-        for (Double explicit : explicits) {
-            subtractedSet.remove(explicit - offset);
+        ArrayList<DecimalQuantity> subtractedSet = new ArrayList<>(values);
+        for (DecimalQuantity explicit : explicits) {
+            BigDecimal explicitBd = explicit.toBigDecimal();
+            BigDecimal valToRemoveBd = explicitBd.subtract(new BigDecimal(offset));
+            DecimalQuantity_DualStorageBCD valToRemove = new DecimalQuantity_DualStorageBCD(valToRemoveBd);
+            subtractedSet.remove(valToRemove);
         }
         if (subtractedSet.size() == 0) {
             return KeywordStatus.SUPPRESSED;
diff --git a/icu4j/main/classes/core/src/com/ibm/icu/text/PluralSamples.java b/icu4j/main/classes/core/src/com/ibm/icu/text/PluralSamples.java
deleted file mode 100644
index 6b260c6..0000000
--- a/icu4j/main/classes/core/src/com/ibm/icu/text/PluralSamples.java
+++ /dev/null
@@ -1,332 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
- *******************************************************************************
- * Copyright (C) 2013-2015, International Business Machines Corporation and
- * others. All Rights Reserved.
- *******************************************************************************
- */
-package com.ibm.icu.text;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.TreeSet;
-
-import com.ibm.icu.text.PluralRules.FixedDecimal;
-import com.ibm.icu.text.PluralRules.KeywordStatus;
-import com.ibm.icu.util.Output;
-
-/**
- * @author markdavis
- * Refactor samples as first step to moving into CLDR
- * 
- * @internal
- * @deprecated This API is ICU internal only.
- */
-@Deprecated
-public class PluralSamples {
-
-    private PluralRules pluralRules;
-    private final Map<String, List<Double>> _keySamplesMap;
-
-    /**
-     * @internal
-     * @deprecated This API is ICU internal only.
-     */
-    @Deprecated
-    public final Map<String, Boolean> _keyLimitedMap;
-    private final Map<String, Set<FixedDecimal>> _keyFractionSamplesMap;
-    private final Set<FixedDecimal> _fractionSamples;
-
-    /**
-     * @internal
-     * @deprecated This API is ICU internal only.
-     */
-    @Deprecated
-    public PluralSamples(PluralRules pluralRules) {
-        this.pluralRules = pluralRules;
-        Set<String> keywords = pluralRules.getKeywords();
-        // ensure both _keySamplesMap and _keyLimitedMap are initialized.
-        // If this were allowed to vary on a per-call basis, we'd have to recheck and
-        // possibly rebuild the samples cache.  Doesn't seem worth it.
-        // This 'max samples' value only applies to keywords that are unlimited, for
-        // other keywords all the matching values are returned.  This might be a lot.
-        final int MAX_SAMPLES = 3;
-
-        Map<String, Boolean> temp = new HashMap<String, Boolean>();
-        for (String k : keywords) {
-            temp.put(k, pluralRules.isLimited(k));
-        }
-        _keyLimitedMap = temp;
-
-        Map<String, List<Double>> sampleMap = new HashMap<String, List<Double>>();
-        int keywordsRemaining = keywords.size();
-
-        int limit = 128; // Math.max(5, getRepeatLimit() * MAX_SAMPLES) * 2;
-
-        for (int i = 0; keywordsRemaining > 0 && i < limit; ++i) {
-            keywordsRemaining = addSimpleSamples(pluralRules, MAX_SAMPLES, sampleMap, keywordsRemaining, i / 2.0);
-        }
-        // Hack for Celtic
-        keywordsRemaining = addSimpleSamples(pluralRules, MAX_SAMPLES, sampleMap, keywordsRemaining, 1000000);
-
-
-        // collect explicit samples
-        Map<String, Set<FixedDecimal>> sampleFractionMap = new HashMap<String, Set<FixedDecimal>>();
-        Set<FixedDecimal> mentioned = new TreeSet<FixedDecimal>();
-        // make sure that there is at least one 'other' value
-        Map<String, Set<FixedDecimal>> foundKeywords = new HashMap<String, Set<FixedDecimal>>();
-        for (FixedDecimal s : mentioned) {
-            String keyword = pluralRules.select(s);
-            addRelation(foundKeywords, keyword, s);
-        }
-        main:
-            if (foundKeywords.size() != keywords.size()) {
-                for (int i = 1; i < 1000; ++i) {
-                    boolean done = addIfNotPresent(i, mentioned, foundKeywords);
-                    if (done) break main;
-                }
-                // if we are not done, try tenths
-                for (int i = 10; i < 1000; ++i) {
-                    boolean done = addIfNotPresent(i/10d, mentioned, foundKeywords);
-                    if (done) break main;
-                }
-                System.out.println("Failed to find sample for each keyword: " + foundKeywords + "\n\t" + pluralRules + "\n\t" + mentioned);
-            }
-        mentioned.add(new FixedDecimal(0)); // always there
-        mentioned.add(new FixedDecimal(1)); // always there
-        mentioned.add(new FixedDecimal(2)); // always there
-        mentioned.add(new FixedDecimal(0.1,1)); // always there
-        mentioned.add(new FixedDecimal(1.99,2)); // always there
-        mentioned.addAll(fractions(mentioned));
-        for (FixedDecimal s : mentioned) {
-            String keyword = pluralRules.select(s);
-            Set<FixedDecimal> list = sampleFractionMap.get(keyword);
-            if (list == null) {
-                list = new LinkedHashSet<FixedDecimal>(); // will be sorted because the iteration is
-                sampleFractionMap.put(keyword, list);
-            }
-            list.add(s);
-        }
-
-        if (keywordsRemaining > 0) {
-            for (String k : keywords) {
-                if (!sampleMap.containsKey(k)) {
-                    sampleMap.put(k, Collections.<Double>emptyList());
-                }
-                if (!sampleFractionMap.containsKey(k)) {
-                    sampleFractionMap.put(k, Collections.<FixedDecimal>emptySet());
-                }
-            }
-        }
-
-        // Make lists immutable so we can return them directly
-        for (Entry<String, List<Double>> entry : sampleMap.entrySet()) {
-            sampleMap.put(entry.getKey(), Collections.unmodifiableList(entry.getValue()));
-        }
-        for (Entry<String, Set<FixedDecimal>> entry : sampleFractionMap.entrySet()) {
-            sampleFractionMap.put(entry.getKey(), Collections.unmodifiableSet(entry.getValue()));
-        }
-        _keySamplesMap = sampleMap;
-        _keyFractionSamplesMap = sampleFractionMap;
-        _fractionSamples = Collections.unmodifiableSet(mentioned);
-    }
-
-    private int addSimpleSamples(PluralRules pluralRules, final int MAX_SAMPLES, Map<String, List<Double>> sampleMap,
-            int keywordsRemaining, double val) {
-        String keyword = pluralRules.select(val);
-        boolean keyIsLimited = _keyLimitedMap.get(keyword);
-
-        List<Double> list = sampleMap.get(keyword);
-        if (list == null) {
-            list = new ArrayList<Double>(MAX_SAMPLES);
-            sampleMap.put(keyword, list);
-        } else if (!keyIsLimited && list.size() == MAX_SAMPLES) {
-            return keywordsRemaining;
-        }
-        list.add(Double.valueOf(val));
-
-        if (!keyIsLimited && list.size() == MAX_SAMPLES) {
-            --keywordsRemaining;
-        }
-        return keywordsRemaining;
-    }
-
-    private void addRelation(Map<String, Set<FixedDecimal>> foundKeywords, String keyword, FixedDecimal s) {
-        Set<FixedDecimal> set = foundKeywords.get(keyword);
-        if (set == null) {
-            foundKeywords.put(keyword, set = new HashSet<FixedDecimal>());
-        }
-        set.add(s);
-    }
-
-    private boolean addIfNotPresent(double d, Set<FixedDecimal> mentioned, Map<String, Set<FixedDecimal>> foundKeywords) {
-        FixedDecimal numberInfo = new FixedDecimal(d);
-        String keyword = pluralRules.select(numberInfo);
-        if (!foundKeywords.containsKey(keyword) || keyword.equals("other")) {
-            addRelation(foundKeywords, keyword, numberInfo);
-            mentioned.add(numberInfo);
-            if (keyword.equals("other")) {
-                if (foundKeywords.get("other").size() > 1) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    private static final int[] TENS = {1, 10, 100, 1000, 10000, 100000, 1000000};
-
-    private static final int LIMIT_FRACTION_SAMPLES = 3;
-
-
-    private Set<FixedDecimal> fractions(Set<FixedDecimal> original) {
-        Set<FixedDecimal> toAddTo = new HashSet<FixedDecimal>();
-
-        Set<Integer> result = new HashSet<Integer>();
-        for (FixedDecimal base1 : original) {
-            result.add((int)base1.integerValue);
-        }
-        List<Integer> ints = new ArrayList<Integer>(result);
-        Set<String> keywords = new HashSet<String>();
-
-        for (int j = 0; j < ints.size(); ++j) {
-            Integer base = ints.get(j);
-            String keyword = pluralRules.select(base);
-            if (keywords.contains(keyword)) {
-                continue;
-            }
-            keywords.add(keyword);
-            toAddTo.add(new FixedDecimal(base,1)); // add .0
-            toAddTo.add(new FixedDecimal(base,2)); // add .00
-            Integer fract = getDifferentCategory(ints, keyword);
-            if (fract >= TENS[LIMIT_FRACTION_SAMPLES-1]) { // make sure that we always get the value
-                toAddTo.add(new FixedDecimal(base + "." + fract));
-            } else {
-                for (int visibleFractions = 1; visibleFractions < LIMIT_FRACTION_SAMPLES; ++visibleFractions) {
-                    for (int i = 1; i <= visibleFractions; ++i) {
-                        // with visible fractions = 3, and fract = 1, then we should get x.10, 0.01
-                        // with visible fractions = 3, and fract = 15, then we should get x.15, x.15
-                        if (fract >= TENS[i]) {
-                            continue;
-                        }
-                        toAddTo.add(new FixedDecimal(base + fract/(double)TENS[i], visibleFractions));
-                    }
-                }
-            }
-        }
-        return toAddTo;
-    }
-
-    private Integer getDifferentCategory(List<Integer> ints, String keyword) {
-        for (int i = ints.size() - 1; i >= 0; --i) {
-            Integer other = ints.get(i);
-            String keywordOther = pluralRules.select(other);
-            if (!keywordOther.equals(keyword)) {
-                return other;
-            }
-        }
-        return 37;
-    }
-
-    /**
-     * @internal
-     * @deprecated This API is ICU internal only.
-     */
-    @Deprecated
-    public KeywordStatus getStatus(String keyword, int offset, Set<Double> explicits, Output<Double> uniqueValue) {
-        if (uniqueValue != null) {
-            uniqueValue.value = null;
-        }
-
-        if (!pluralRules.getKeywords().contains(keyword)) {
-            return KeywordStatus.INVALID;
-        }
-        Collection<Double> values = pluralRules.getAllKeywordValues(keyword);
-        if (values == null) {
-            return KeywordStatus.UNBOUNDED;
-        }
-        int originalSize = values.size();
-
-        if (explicits == null) {
-            explicits = Collections.emptySet();
-        }
-
-        // Quick check on whether there are multiple elements
-
-        if (originalSize > explicits.size()) {
-            if (originalSize == 1) {
-                if (uniqueValue != null) {
-                    uniqueValue.value = values.iterator().next();
-                }
-                return KeywordStatus.UNIQUE;
-            }
-            return KeywordStatus.BOUNDED;
-        }
-
-        // Compute if the quick test is insufficient.
-
-        HashSet<Double> subtractedSet = new HashSet<Double>(values);
-        for (Double explicit : explicits) {
-            subtractedSet.remove(explicit - offset);
-        }
-        if (subtractedSet.size() == 0) {
-            return KeywordStatus.SUPPRESSED;
-        }
-
-        if (uniqueValue != null && subtractedSet.size() == 1) {
-            uniqueValue.value = subtractedSet.iterator().next();
-        }
-
-        return originalSize == 1 ? KeywordStatus.UNIQUE : KeywordStatus.BOUNDED;
-    }
-
-    Map<String, List<Double>> getKeySamplesMap() {
-        return _keySamplesMap;
-    }
-
-    Map<String, Set<FixedDecimal>> getKeyFractionSamplesMap() {
-        return _keyFractionSamplesMap;
-    }
-
-    Set<FixedDecimal> getFractionSamples() {
-        return _fractionSamples;
-    }
-
-    /**
-     * Returns all the values that trigger this keyword, or null if the number of such
-     * values is unlimited.
-     *
-     * @param keyword the keyword
-     * @return the values that trigger this keyword, or null.  The returned collection
-     * is immutable. It will be empty if the keyword is not defined.
-     * @stable ICU 4.8
-     */
-
-    Collection<Double> getAllKeywordValues(String keyword) {
-        // HACK for now
-        if (!pluralRules.getKeywords().contains(keyword)) {
-            return Collections.<Double>emptyList();
-        }
-        Collection<Double> result = getKeySamplesMap().get(keyword);
-
-        // We depend on MAX_SAMPLES here.  It's possible for a conjunction
-        // of unlimited rules that 'looks' unlimited to return a limited
-        // number of values.  There's no bounds to this limited number, in
-        // general, because you can construct arbitrarily complex rules.  Since
-        // we always generate 3 samples if a rule is really unlimited, that's
-        // where we put the cutoff.
-        if (result.size() > 2 && !_keyLimitedMap.get(keyword)) {
-            return null;
-        }
-        return result;
-    }
-}
diff --git a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/PluralFormatUnitTest.java b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/PluralFormatUnitTest.java
index 0b22c8e..1e2c0d9 100644
--- a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/PluralFormatUnitTest.java
+++ b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/PluralFormatUnitTest.java
@@ -23,6 +23,7 @@
 import org.junit.runners.JUnit4;
 
 import com.ibm.icu.dev.test.TestFmwk;
+import com.ibm.icu.impl.number.DecimalQuantity;
 import com.ibm.icu.text.DecimalFormat;
 import com.ibm.icu.text.DecimalFormatSymbols;
 import com.ibm.icu.text.MessageFormat;
@@ -228,10 +229,10 @@
             logln(localeName + "\ttoString\t" + rules.toString());
             Set<String> keywords = rules.getKeywords();
             for (String keyword : keywords) {
-                Collection<Double> list = rules.getSamples(keyword);
+                Collection<DecimalQuantity> list = rules.getDecimalQuantitySamples(keyword);
                 if (list.size() == 0) {
                     // if there aren't any integer samples, get the decimal ones.
-                    list = rules.getSamples(keyword, SampleType.DECIMAL);
+                    list = rules.getDecimalQuantitySamples(keyword, SampleType.DECIMAL);
                 }
 
                 if (list == null || list.size() == 0) {
diff --git a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/PluralRulesTest.java b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/PluralRulesTest.java
index d07f41e..f0bed53 100644
--- a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/PluralRulesTest.java
+++ b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/format/PluralRulesTest.java
@@ -23,6 +23,7 @@
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Locale;
@@ -31,6 +32,8 @@
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -41,6 +44,8 @@
 import com.ibm.icu.dev.util.CollectionUtilities;
 import com.ibm.icu.impl.Relation;
 import com.ibm.icu.impl.Utility;
+import com.ibm.icu.impl.number.DecimalQuantity;
+import com.ibm.icu.impl.number.DecimalQuantity_DualStorageBCD;
 import com.ibm.icu.number.FormattedNumber;
 import com.ibm.icu.number.FormattedNumberRange;
 import com.ibm.icu.number.LocalizedNumberFormatter;
@@ -50,9 +55,9 @@
 import com.ibm.icu.number.UnlocalizedNumberFormatter;
 import com.ibm.icu.text.NumberFormat;
 import com.ibm.icu.text.PluralRules;
+import com.ibm.icu.text.PluralRules.DecimalQuantitySamples;
+import com.ibm.icu.text.PluralRules.DecimalQuantitySamplesRange;
 import com.ibm.icu.text.PluralRules.FixedDecimal;
-import com.ibm.icu.text.PluralRules.FixedDecimalRange;
-import com.ibm.icu.text.PluralRules.FixedDecimalSamples;
 import com.ibm.icu.text.PluralRules.KeywordStatus;
 import com.ibm.icu.text.PluralRules.PluralType;
 import com.ibm.icu.text.PluralRules.SampleType;
@@ -177,17 +182,27 @@
         PluralRules test = PluralRules.createRules(description);
 
         checkNewSamples(description, test, "one", PluralRules.SampleType.INTEGER, "@integer 3, 19", true,
-                new FixedDecimal(3));
+                DecimalQuantity_DualStorageBCD.fromExponentString("3"));
         checkNewSamples(description, test, "one", PluralRules.SampleType.DECIMAL, "@decimal 3.50~3.53, …", false,
-                new FixedDecimal(3.5, 2));
-        checkOldSamples(description, test, "one", SampleType.INTEGER, 3d, 19d);
-        checkOldSamples(description, test, "one", SampleType.DECIMAL, 3.5d, 3.51d, 3.52d, 3.53d);
+                DecimalQuantity_DualStorageBCD.fromExponentString("3.50"));
+        checkOldSamples(description, test, "one", SampleType.INTEGER,
+                DecimalQuantity_DualStorageBCD.fromExponentString("3"),
+                DecimalQuantity_DualStorageBCD.fromExponentString("19"));
+        checkOldSamples(description, test, "one", SampleType.DECIMAL,
+                DecimalQuantity_DualStorageBCD.fromExponentString("3.50"),
+                DecimalQuantity_DualStorageBCD.fromExponentString("3.51"),
+                DecimalQuantity_DualStorageBCD.fromExponentString("3.52"),
+                DecimalQuantity_DualStorageBCD.fromExponentString("3.53"));
 
         checkNewSamples(description, test, "other", PluralRules.SampleType.INTEGER, "", true, null);
         checkNewSamples(description, test, "other", PluralRules.SampleType.DECIMAL, "@decimal 99.0~99.2, 999.0, …",
-                false, new FixedDecimal(99d, 1));
+                false, DecimalQuantity_DualStorageBCD.fromExponentString("99.0"));
         checkOldSamples(description, test, "other", SampleType.INTEGER);
-        checkOldSamples(description, test, "other", SampleType.DECIMAL, 99d, 99.1, 99.2d, 999d);
+        checkOldSamples(description, test, "other", SampleType.DECIMAL,
+                DecimalQuantity_DualStorageBCD.fromExponentString("99.0"),
+                DecimalQuantity_DualStorageBCD.fromExponentString("99.1"),
+                DecimalQuantity_DualStorageBCD.fromExponentString("99.2"),
+                DecimalQuantity_DualStorageBCD.fromExponentString("999.0"));
     }
 
     /**
@@ -205,22 +220,26 @@
         // Creating the PluralRules object means being able to parse numbers
         // like 1e5 and 1.1e5
         PluralRules test = PluralRules.createRules(description);
+
+        // Currently, 'c' is the canonical representation of numbers with suppressed exponent, and 'e'
+        // is an alias. The test helpers here skip 'e' for round-trip sample string parsing and formatting.
+
         checkNewSamples(description, test, "one", PluralRules.SampleType.INTEGER, "@integer 0, 1, 1e5", true,
-                new FixedDecimal(0));
+                DecimalQuantity_DualStorageBCD.fromExponentString("0"));
         checkNewSamples(description, test, "one", PluralRules.SampleType.DECIMAL, "@decimal 0.0~1.5, 1.1e5", true,
-                new FixedDecimal(0, 1));
+                DecimalQuantity_DualStorageBCD.fromExponentString("0.0"));
         checkNewSamples(description, test, "many", PluralRules.SampleType.INTEGER, "@integer 1000000, 2e6, 3e6, 4e6, 5e6, 6e6, 7e6, …", false,
-                new FixedDecimal(1000000));
+                DecimalQuantity_DualStorageBCD.fromExponentString("1000000"));
         checkNewSamples(description, test, "many", PluralRules.SampleType.DECIMAL, "@decimal 2.1e6, 3.1e6, 4.1e6, 5.1e6, 6.1e6, 7.1e6, …", false,
-                FixedDecimal.createWithExponent(2.1, 1, 6));
+                DecimalQuantity_DualStorageBCD.fromExponentString("2.1c6"));
         checkNewSamples(description, test, "other", PluralRules.SampleType.INTEGER, "@integer 2~17, 100, 1000, 10000, 100000, 2e5, 3e5, 4e5, 5e5, 6e5, 7e5, …", false,
-                new FixedDecimal(2));
+                DecimalQuantity_DualStorageBCD.fromExponentString("2"));
         checkNewSamples(description, test, "other", PluralRules.SampleType.DECIMAL, "@decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 2.1e5, 3.1e5, 4.1e5, 5.1e5, 6.1e5, 7.1e5, …", false,
-                new FixedDecimal(2.0, 1));
+                DecimalQuantity_DualStorageBCD.fromExponentString("2.0"));
     }
 
     /**
-     * This test is for the support of X.YcZ compactnotation of numbers in
+     * This test is for the support of X.YcZ compact notation of numbers in
      * the plural sample string.
      */
     @Test
@@ -236,34 +255,53 @@
         // Note: Since `c` is currently an alias to `e`, the toString() of
         // FixedDecimal will return "1e5" even when input is "1c5".
         PluralRules test = PluralRules.createRules(description);
-        checkNewSamples(description, test, "one", PluralRules.SampleType.INTEGER, "@integer 0, 1, 1e5", true,
-                new FixedDecimal(0));
-        checkNewSamples(description, test, "one", PluralRules.SampleType.DECIMAL, "@decimal 0.0~1.5, 1.1e5", true,
-                new FixedDecimal(0, 1));
-        checkNewSamples(description, test, "many", PluralRules.SampleType.INTEGER, "@integer 1000000, 2e6, 3e6, 4e6, 5e6, 6e6, 7e6, …", false,
-                new FixedDecimal(1000000));
-        checkNewSamples(description, test, "many", PluralRules.SampleType.DECIMAL, "@decimal 2.1e6, 3.1e6, 4.1e6, 5.1e6, 6.1e6, 7.1e6, …", false,
-                FixedDecimal.createWithExponent(2.1, 1, 6));
-        checkNewSamples(description, test, "other", PluralRules.SampleType.INTEGER, "@integer 2~17, 100, 1000, 10000, 100000, 2e5, 3e5, 4e5, 5e5, 6e5, 7e5, …", false,
-                new FixedDecimal(2));
-        checkNewSamples(description, test, "other", PluralRules.SampleType.DECIMAL, "@decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 2.1e5, 3.1e5, 4.1e5, 5.1e5, 6.1e5, 7.1e5, …", false,
-                new FixedDecimal(2.0, 1));
+
+        checkNewSamples(description, test, "one", PluralRules.SampleType.INTEGER, "@integer 0, 1, 1c5", true,
+                DecimalQuantity_DualStorageBCD.fromExponentString("0"));
+        checkNewSamples(description, test, "one", PluralRules.SampleType.DECIMAL, "@decimal 0.0~1.5, 1.1c5", true,
+                DecimalQuantity_DualStorageBCD.fromExponentString("0.0"));
+        checkNewSamples(description, test, "many", PluralRules.SampleType.INTEGER, "@integer 1000000, 2c6, 3c6, 4c6, 5c6, 6c6, 7c6, …", false,
+                DecimalQuantity_DualStorageBCD.fromExponentString("1000000"));
+        checkNewSamples(description, test, "many", PluralRules.SampleType.DECIMAL, "@decimal 2.1c6, 3.1c6, 4.1c6, 5.1c6, 6.1c6, 7.1c6, …", false,
+                DecimalQuantity_DualStorageBCD.fromExponentString("2.1c6"));
+        checkNewSamples(description, test, "other", PluralRules.SampleType.INTEGER, "@integer 2~17, 100, 1000, 10000, 100000, 2c5, 3c5, 4c5, 5c5, 6c5, 7c5, …", false,
+                DecimalQuantity_DualStorageBCD.fromExponentString("2"));
+        checkNewSamples(description, test, "other", PluralRules.SampleType.DECIMAL, "@decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 2.1c5, 3.1c5, 4.1c5, 5.1c5, 6.1c5, 7.1c5, …", false,
+                DecimalQuantity_DualStorageBCD.fromExponentString("2.0"));
     }
 
     public void checkOldSamples(String description, PluralRules rules, String keyword, SampleType sampleType,
-            Double... expected) {
-        Collection<Double> oldSamples = rules.getSamples(keyword, sampleType);
-        if (!assertEquals("getOldSamples; " + keyword + "; " + description, new HashSet(Arrays.asList(expected)),
-                oldSamples)) {
+            DecimalQuantity... expected) {
+        Collection<DecimalQuantity> oldSamples = rules.getDecimalQuantitySamples(keyword, sampleType);
+
+        // Collect actual (oldSamples) and expected (expectedSamplesList) into the
+        // same concrete collection for comparison purposes.
+        ArrayList<DecimalQuantity> oldSamplesList = new ArrayList(oldSamples);
+        ArrayList<DecimalQuantity> expectedSamplesList = new ArrayList(Arrays.asList(expected));
+
+        if (!assertEquals("getOldSamples; " + keyword + "; " + description, expectedSamplesList,
+                oldSamplesList)) {
             rules.getSamples(keyword, sampleType);
         }
     }
 
     public void checkNewSamples(String description, PluralRules test, String keyword, SampleType sampleType,
-            String samplesString, boolean isBounded, FixedDecimal firstInRange) {
+            String samplesString, boolean isBounded, DecimalQuantity firstInRange) {
         String title = description + ", " + sampleType;
-        FixedDecimalSamples samples = test.getDecimalSamples(keyword, sampleType);
+        DecimalQuantitySamples samples = test.getDecimalSamples(keyword, sampleType);
         if (samples != null) {
+
+            // For now, skip round-trip formatting test when samples string uses
+            // 'e' instead of 'c' for compact notation.
+
+            // We are skipping tests for 'e' by replacing 'e' with 'c' in exponent
+            // notation.
+            Pattern p = Pattern.compile("(\\d+)(e)([-]?\\d+)");
+            Matcher m = p.matcher(samplesString);
+            if (m.find()) {
+                samplesString = m.replaceAll("$1c$3");
+            }
+
             assertEquals("samples; " + title, samplesString, samples.toString());
             assertEquals("bounded; " + title, isBounded, samples.bounded);
             assertEquals("first; " + title, firstInRange, samples.samples.iterator().next().start);
@@ -391,11 +429,11 @@
         main: for (ULocale locale : factory.getAvailableULocales()) {
             PluralRules rules = factory.forLocale(locale);
             Map<String, PluralRules> keywordToRule = new HashMap<>();
-            Collection<FixedDecimalSamples> samples = new LinkedHashSet<>();
+            Collection<DecimalQuantitySamples> samples = new LinkedHashSet<>();
 
             for (String keyword : rules.getKeywords()) {
                 for (SampleType sampleType : SampleType.values()) {
-                    FixedDecimalSamples samples2 = rules.getDecimalSamples(keyword, sampleType);
+                    DecimalQuantitySamples samples2 = rules.getDecimalSamples(keyword, sampleType);
                     if (samples2 != null) {
                         samples.add(samples2);
                     }
@@ -412,15 +450,16 @@
                 }
                 keywordToRule.put(keyword, singleRule);
             }
-            Map<FixedDecimal, String> collisionTest = new TreeMap();
-            for (FixedDecimalSamples sample3 : samples) {
-                Set<FixedDecimalRange> samples2 = sample3.getSamples();
+
+            Map<DecimalQuantity, String> collisionTest = new LinkedHashMap();
+            for (DecimalQuantitySamples sample3 : samples) {
+                Set<DecimalQuantitySamplesRange> samples2 = sample3.getSamples();
                 if (samples2 == null) {
                     continue;
                 }
-                for (FixedDecimalRange sample : samples2) {
+                for (DecimalQuantitySamplesRange sample : samples2) {
                     for (int i = 0; i < 1; ++i) {
-                        FixedDecimal item = i == 0 ? sample.start : sample.end;
+                        DecimalQuantity item = i == 0 ? sample.start : sample.end;
                         collisionTest.clear();
                         for (Entry<String, PluralRules> entry : keywordToRule.entrySet()) {
                             PluralRules rule = entry.getValue();
@@ -460,9 +499,9 @@
     }
 
     public void checkValue(String title1, PluralRules rules, String expected, String value) {
-        FixedDecimal fdNum = new FixedDecimal(value);
+        DecimalQuantity dqNum = DecimalQuantity_DualStorageBCD.fromExponentString(value);
 
-        String result = rules.select(fdNum);
+        String result = rules.select(dqNum);
         ULocale locale = null;
         assertEquals(getAssertMessage(title1, locale, rules, expected) + "; value: " + value, expected, result);
     }
@@ -733,13 +772,20 @@
         }
     }
 
-    private void assertRuleValue(String rule, double value) {
+    private void assertRuleValue(String rule, DecimalQuantity value) {
         assertRuleKeyValue("a:" + rule, "a", value);
     }
 
-    private void assertRuleKeyValue(String rule, String key, double value) {
+    private void assertRuleKeyValue(String rule, String key, DecimalQuantity value) {
         PluralRules pr = PluralRules.createRules(rule);
-        assertEquals(rule, value, pr.getUniqueKeywordValue(key));
+
+        // as a DecimalQuantity
+        assertEquals(rule, value, pr.getUniqueKeywordDecimalQuantityValue(key));
+
+        // as a double
+        double expDouble = value.equals(PluralRules.NO_UNIQUE_VALUE_DECIMAL_QUANTITY) ?
+                PluralRules.NO_UNIQUE_VALUE : value.toDouble();
+        assertEquals(rule, expDouble, pr.getUniqueKeywordValue(key));
     }
 
     /*
@@ -747,26 +793,36 @@
      */
     @Test
     public void TestGetUniqueKeywordValue() {
-        assertRuleKeyValue("a: n is 1", "not_defined", PluralRules.NO_UNIQUE_VALUE); // key not defined
-        assertRuleValue("n within 2..2", 2);
-        assertRuleValue("n is 1", 1);
-        assertRuleValue("n in 2..2", 2);
-        assertRuleValue("n in 3..4", PluralRules.NO_UNIQUE_VALUE);
-        assertRuleValue("n within 3..4", PluralRules.NO_UNIQUE_VALUE);
-        assertRuleValue("n is 2 or n is 2", 2);
-        assertRuleValue("n is 2 and n is 2", 2);
-        assertRuleValue("n is 2 or n is 3", PluralRules.NO_UNIQUE_VALUE);
-        assertRuleValue("n is 2 and n is 3", PluralRules.NO_UNIQUE_VALUE);
-        assertRuleValue("n is 2 or n in 2..3", PluralRules.NO_UNIQUE_VALUE);
-        assertRuleValue("n is 2 and n in 2..3", 2);
-        assertRuleKeyValue("a: n is 1", "other", PluralRules.NO_UNIQUE_VALUE); // key matches default rule
-        assertRuleValue("n in 2,3", PluralRules.NO_UNIQUE_VALUE);
-        assertRuleValue("n in 2,3..6 and n not in 2..3,5..6", 4);
+        LocalizedNumberFormatter fmtr = NumberFormatter.withLocale(ULocale.ROOT);
+
+        assertRuleKeyValue("a: n is 1", "not_defined", PluralRules.NO_UNIQUE_VALUE_DECIMAL_QUANTITY); // key not defined
+        assertRuleValue("n within 2..2", new DecimalQuantity_DualStorageBCD(2));
+        assertRuleValue("n is 1", new DecimalQuantity_DualStorageBCD(1));
+        assertRuleValue("n in 2..2", new DecimalQuantity_DualStorageBCD(2));
+        assertRuleValue("n in 3..4", PluralRules.NO_UNIQUE_VALUE_DECIMAL_QUANTITY);
+        assertRuleValue("n within 3..4", PluralRules.NO_UNIQUE_VALUE_DECIMAL_QUANTITY);
+        assertRuleValue("n is 2 or n is 2", new DecimalQuantity_DualStorageBCD(2));
+        assertRuleValue("n is 2 and n is 2", new DecimalQuantity_DualStorageBCD(2));
+        assertRuleValue("n is 2 or n is 3", PluralRules.NO_UNIQUE_VALUE_DECIMAL_QUANTITY);
+        assertRuleValue("n is 2 and n is 3", PluralRules.NO_UNIQUE_VALUE_DECIMAL_QUANTITY);
+        assertRuleValue("n is 2 or n in 2..3", PluralRules.NO_UNIQUE_VALUE_DECIMAL_QUANTITY);
+        assertRuleValue("n is 2 and n in 2..3", new DecimalQuantity_DualStorageBCD(2));
+        assertRuleKeyValue("a: n is 1", "other", PluralRules.NO_UNIQUE_VALUE_DECIMAL_QUANTITY); // key matches default rule
+        assertRuleValue("n in 2,3", PluralRules.NO_UNIQUE_VALUE_DECIMAL_QUANTITY);
+        assertRuleValue("n in 2,3..6 and n not in 2..3,5..6", new DecimalQuantity_DualStorageBCD(4));
     }
 
     /**
      * The version in PluralFormatUnitTest is not really a test, and it's in the wrong place anyway, so I'm putting a
      * variant of it here.
+     *
+     * Using the double API for getting plural samples, assert all samples match the keyword
+     * they are listed under, for all locales.
+     *
+     * Specifically, iterate over all locales, get plural rules for the locale, iterate over every rule,
+     * then iterate over every sample in the rule, parse sample to a number (double), use that number
+     * as an input to .select() for the rules object, and assert the actual return plural keyword matches
+     * what we expect based on the plural rule string.
      */
     @Test
     public void TestGetSamples() {
@@ -775,10 +831,6 @@
             uniqueRuleSet.add(PluralRules.getFunctionalEquivalent(locale, null));
         }
         for (ULocale locale : uniqueRuleSet) {
-            //if (locale.getLanguage().equals("fr") &&
-            //        logKnownIssue("21322", "PluralRules::getSamples cannot distinguish 1e5 from 100000")) {
-            //    continue;
-            //}
             PluralRules rules = factory.forLocale(locale);
             logln("\nlocale: " + (locale == ULocale.ROOT ? "root" : locale.toString()) + ", rules: " + rules);
             Set<String> keywords = rules.getKeywords();
@@ -791,8 +843,8 @@
                 if (list.size() == 0) {
                     // when the samples (meaning integer samples) are null, then then integerSamples must be, and the
                     // decimalSamples must not be
-                    FixedDecimalSamples integerSamples = rules.getDecimalSamples(keyword, SampleType.INTEGER);
-                    FixedDecimalSamples decimalSamples = rules.getDecimalSamples(keyword, SampleType.DECIMAL);
+                    DecimalQuantitySamples integerSamples = rules.getDecimalSamples(keyword, SampleType.INTEGER);
+                    DecimalQuantitySamples decimalSamples = rules.getDecimalSamples(keyword, SampleType.DECIMAL);
                     assertTrue(getAssertMessage("List is not null", locale, rules, keyword), integerSamples == null
                             && decimalSamples != null && decimalSamples.samples.size() != 0);
                 } else {
@@ -816,6 +868,131 @@
         }
     }
 
+    /**
+     * This replicates the setup of TestGetSamples(), but parses samples as DecimalQuantity instead of double.
+     *
+     * Using the DecimalQuantity API for getting plural samples, assert all samples match the keyword
+     * they are listed under, for all locales.
+     *
+     * Specifically, iterate over all locales, get plural rules for the locale, iterate over every rule,
+     * then iterate over every sample in the rule, parse sample to a number (DecimalQuantity), use that number
+     * as an input to .select() for the rules object, and assert the actual return plural keyword matches
+     * what we expect based on the plural rule string.
+     */
+    @Test
+    public void TestGetDecimalQuantitySamples() {
+        Set<ULocale> uniqueRuleSet = new HashSet<>();
+        for (ULocale locale : factory.getAvailableULocales()) {
+            uniqueRuleSet.add(PluralRules.getFunctionalEquivalent(locale, null));
+        }
+        for (ULocale locale : uniqueRuleSet) {
+            PluralRules rules = factory.forLocale(locale);
+            logln("\nlocale: " + (locale == ULocale.ROOT ? "root" : locale.toString()) + ", rules: " + rules);
+            Set<String> keywords = rules.getKeywords();
+            for (String keyword : keywords) {
+                Collection<DecimalQuantity> list = rules.getDecimalQuantitySamples(keyword);
+                logln("keyword: " + keyword + ", samples: " + list);
+                // with fractions, the samples can be empty and thus the list null. In that case, however, there will be
+                // FixedDecimal values.
+                // So patch the test for that.
+                if (list.size() == 0) {
+                    // when the samples (meaning integer samples) are null, then then integerSamples must be, and the
+                    // decimalSamples must not be
+                    DecimalQuantitySamples integerSamples = rules.getDecimalSamples(keyword, SampleType.INTEGER);
+                    DecimalQuantitySamples decimalSamples = rules.getDecimalSamples(keyword, SampleType.DECIMAL);
+                    assertTrue(getAssertMessage("List is not null", locale, rules, keyword), integerSamples == null
+                            && decimalSamples != null && decimalSamples.samples.size() != 0);
+                } else {
+                    if (!assertTrue(getAssertMessage("Test getSamples.isEmpty", locale, rules, keyword),
+                            !list.isEmpty())) {
+                        rules.getDecimalQuantitySamples(keyword);
+                    }
+                    if (rules.toString().contains(": j")) {
+                        // hack until we remove j
+                    } else {
+                        for (DecimalQuantity value : list) {
+                            assertEquals(getAssertMessage("Match keyword", locale, rules, keyword) + "; value '"
+                                    + value + "'", keyword, rules.select(value));
+                        }
+                    }
+                }
+            }
+
+            assertNull(locale + ", list is null", rules.getDecimalQuantitySamples("@#$%^&*"));
+            assertNull(locale + ", list is null", rules.getDecimalQuantitySamples("@#$%^&*", SampleType.DECIMAL));
+        }
+    }
+
+    /**
+     * Test addSamples (Java) / getSamplesFromString (C++) to ensure the expansion of plural rule sample range
+     * expands to a sequence of sample numbers that is incremented as the right scale.
+     *
+     *  Do this for numbers with fractional digits but no exponent.
+     */
+    @Test
+    public void testGetOrAddSamplesFromString() {
+        PluralRules rules = PluralRules.createRules("testkeyword: e != 0 @decimal 2.0~4.0, …");
+
+        Set<String> keywords = rules.getKeywords();
+        assertTrue("At least parse the test keyword in the test rule string", 0 < keywords.size());
+
+        String expKeyword = "testkeyword";
+        Collection<DecimalQuantity> list = rules.getDecimalQuantitySamples(expKeyword, SampleType.DECIMAL);
+
+        String[] expDqStrs = {
+                "2.0", "2.1", "2.2", "2.3", "2.4", "2.5", "2.6", "2.7", "2.8", "2.9",
+                "3.0", "3.1", "3.2", "3.3", "3.4", "3.5", "3.6", "3.7", "3.8", "3.9",
+                "4.0"
+        };
+        assertEquals("Number of parsed samples from test string incorrect", expDqStrs.length, list.size());
+        ArrayList<DecimalQuantity> actSamples = new ArrayList<>(list);
+        for (int i = 0; i < list.size(); i++) {
+            String expDqStr = expDqStrs[i];
+            DecimalQuantity sample = actSamples.get(i);
+            String sampleStr = sample.toExponentString();
+
+            assertEquals("Expansion of sample range to sequence of sample values should increment at the right scale",
+                    expDqStr, sampleStr);
+
+        }
+    }
+
+    /**
+     * Test addSamples (Java) / getSamplesFromString (C++) to ensure the expansion of plural rule sample range
+     * expands to a sequence of sample numbers that is incremented as the right scale.
+     *
+     *  Do this for numbers written in a notation that has an exponent, for which the number is an
+     *  integer (also as defined in the UTS 35 spec for the plural operands) but whose representation
+     *  has fractional digits in the significand written before the exponent.
+     */
+    @Test
+    public void testGetOrAddSamplesFromStringCompactNotation() {
+        PluralRules rules = PluralRules.createRules("testkeyword: e != 0 @decimal 2.0c6~4.0c6, …");
+
+        Set<String> keywords = rules.getKeywords();
+        assertTrue("At least parse the test keyword in the test rule string", 0 < keywords.size());
+
+        String expKeyword = "testkeyword";
+        Collection<DecimalQuantity> list = rules.getDecimalQuantitySamples(expKeyword, SampleType.DECIMAL);
+
+        String[] expDqStrs = {
+                "2.0c6", "2.1c6", "2.2c6", "2.3c6", "2.4c6", "2.5c6", "2.6c6", "2.7c6", "2.8c6", "2.9c6",
+                "3.0c6", "3.1c6", "3.2c6", "3.3c6", "3.4c6", "3.5c6", "3.6c6", "3.7c6", "3.8c6", "3.9c6",
+                "4.0c6"
+        };
+        assertEquals("Number of parsed samples from test string incorrect", expDqStrs.length, list.size());
+        ArrayList<DecimalQuantity> actSamples = new ArrayList<>(list);
+        for (int i = 0; i < list.size(); i++) {
+            String expDqStr = expDqStrs[i];
+            DecimalQuantity sample = actSamples.get(i);
+            String sampleStr = sample.toExponentString();
+
+            assertEquals("Expansion of sample range to sequence of sample values should increment at the right scale",
+                    expDqStr, sampleStr);
+
+        }
+    }
+
     public String getAssertMessage(String message, ULocale locale, PluralRules rules, String keyword) {
         String ruleString = "";
         if (keyword != null) {
@@ -882,24 +1059,42 @@
                 if (valueList != null) {
                     valueList = valueList.trim();
                 }
-                Collection<Double> values;
+                Collection<DecimalQuantity> values;
                 if (valueList == null || valueList.length() == 0) {
                     values = Collections.EMPTY_SET;
                 } else if ("null".equals(valueList)) {
                     values = null;
                 } else {
-                    values = new TreeSet<>();
+                    values = new LinkedHashSet<>();
                     for (String value : valueList.split(",")) {
-                        values.add(Double.parseDouble(value));
+                        values.add(DecimalQuantity_DualStorageBCD.fromExponentString(value));
                     }
                 }
 
-                Collection<Double> results = p.getAllKeywordValues(keyword);
-                assertEquals(keyword + " in " + ruleDescription, values, results == null ? null : new HashSet(results));
+                Collection<DecimalQuantity> results = p.getAllKeywordDecimalQuantityValues(keyword);
+
+                // Convert DecimalQuantity using a 1:1 conversion to String for comparison purposes
+                Set<String> valuesForComparison = new HashSet<>();
+                if (values != null) {
+                    for (DecimalQuantity dq : values) {
+                        valuesForComparison.add(dq.toExponentString());
+                    }
+                }
+                Set<String> resultsForComparison = new HashSet<>();
+                if (results != null) {
+                    for (DecimalQuantity dq : results) {
+                        resultsForComparison.add(dq.toExponentString());
+                    }
+                }
+
+                assertEquals(keyword + " in " + ruleDescription,
+                        values == null ? null : valuesForComparison,
+                        results == null ? null : resultsForComparison
+                );
 
                 if (results != null) {
                     try {
-                        results.add(PluralRules.NO_UNIQUE_VALUE);
+                        results.add(PluralRules.NO_UNIQUE_VALUE_DECIMAL_QUANTITY);
                         fail("returned set is modifiable");
                     } catch (UnsupportedOperationException e) {
                         // pass
@@ -967,13 +1162,9 @@
                     for (String keyword : rules.getKeywords()) {
                         boolean isLimited = rules.isLimited(keyword, sampleType);
                         boolean computeLimited = rules.computeLimited(keyword, sampleType);
-                        if (!keyword.equals("other") && !(locale.getLanguage().equals("fr") && logKnownIssue("ICU-21322", "fr plurals many case computeLimited == isLimited"))) {
-                            assertEquals(getAssertMessage("computeLimited == isLimited", locale, rules, keyword),
-                                    computeLimited, isLimited);
-                        }
-                        Collection<Double> samples = rules.getSamples(keyword, sampleType);
+                        Collection<DecimalQuantity> samples = rules.getDecimalQuantitySamples(keyword, sampleType);
                         assertNotNull(getAssertMessage("Samples must not be null", locale, rules, keyword), samples);
-                        /* FixedDecimalSamples decimalSamples = */rules.getDecimalSamples(keyword, sampleType);
+                        rules.getDecimalSamples(keyword, sampleType);
                         // assertNotNull(getAssertMessage("Decimal samples must be null if unlimited", locale, rules,
                         // keyword), decimalSamples);
                     }
@@ -985,29 +1176,30 @@
     @Test
     public void TestKeywords() {
         Set<String> possibleKeywords = new LinkedHashSet(Arrays.asList("zero", "one", "two", "few", "many", "other"));
+        DecimalQuantity ONE_INTEGER = DecimalQuantity_DualStorageBCD.fromExponentString("1");
         Object[][][] tests = {
                 // format is locale, explicits, then triples of keyword, status, unique value.
-                { { "en", null }, { "one", KeywordStatus.UNIQUE, 1.0d }, { "other", KeywordStatus.UNBOUNDED, null } },
-                { { "pl", null }, { "one", KeywordStatus.UNIQUE, 1.0d }, { "few", KeywordStatus.UNBOUNDED, null },
+                { { "en", null }, { "one", KeywordStatus.UNIQUE, ONE_INTEGER }, { "other", KeywordStatus.UNBOUNDED, null } },
+                { { "pl", null }, { "one", KeywordStatus.UNIQUE, ONE_INTEGER }, { "few", KeywordStatus.UNBOUNDED, null },
                         { "many", KeywordStatus.UNBOUNDED, null },
                         { "other", KeywordStatus.SUPPRESSED, null, KeywordStatus.UNBOUNDED, null } // note that it is
                                                                                                    // suppressed in
                                                                                                    // INTEGER but not
                                                                                                    // DECIMAL
-                }, { { "en", new HashSet<>(Arrays.asList(1.0d)) }, // check that 1 is suppressed
+                }, { { "en", new HashSet<>(Arrays.asList(ONE_INTEGER)) }, // check that 1 is suppressed
                         { "one", KeywordStatus.SUPPRESSED, null }, { "other", KeywordStatus.UNBOUNDED, null } }, };
-        Output<Double> uniqueValue = new Output<>();
+        Output<DecimalQuantity> uniqueValue = new Output<>();
         for (Object[][] test : tests) {
             ULocale locale = new ULocale((String) test[0][0]);
             // NumberType numberType = (NumberType) test[1];
-            Set<Double> explicits = (Set<Double>) test[0][1];
+            Set<DecimalQuantity> explicits = (Set<DecimalQuantity>) test[0][1];
             PluralRules pluralRules = factory.forLocale(locale);
             LinkedHashSet<String> remaining = new LinkedHashSet(possibleKeywords);
             for (int i = 1; i < test.length; ++i) {
                 Object[] row = test[i];
                 String keyword = (String) row[0];
                 KeywordStatus statusExpected = (KeywordStatus) row[1];
-                Double uniqueExpected = (Double) row[2];
+                DecimalQuantity uniqueExpected = (DecimalQuantity) row[2];
                 remaining.remove(keyword);
                 KeywordStatus status = pluralRules.getKeywordStatus(keyword, 0, explicits, uniqueValue);
                 assertEquals(getAssertMessage("Unique Value", locale, pluralRules, keyword), uniqueExpected,
@@ -1015,7 +1207,7 @@
                 assertEquals(getAssertMessage("Keyword Status", locale, pluralRules, keyword), statusExpected, status);
                 if (row.length > 3) {
                     statusExpected = (KeywordStatus) row[3];
-                    uniqueExpected = (Double) row[4];
+                    uniqueExpected = (DecimalQuantity) row[4];
                     status = pluralRules.getKeywordStatus(keyword, 0, explicits, uniqueValue, SampleType.DECIMAL);
                     assertEquals(getAssertMessage("Unique Value - decimal", locale, pluralRules, keyword),
                             uniqueExpected, uniqueValue.value);
@@ -1033,6 +1225,11 @@
 
     // For the time being, the compact notation exponent operand `c` is an alias
     // for the scientific exponent operand `e` and compact notation.
+    /**
+     * Test the proper plural rule keyword selection given an input number that is
+     * already formatted into scientific notation. This exercises the `e` plural operand
+     * for the formatted number.
+     */
     @Test
     public void testScientificPluralKeyword() {
         PluralRules rules = PluralRules.createRules("one: i = 0,1 @integer 0, 1 @decimal 0.0~1.5;  many: e = 0 and i % 1000000 = 0 and v = 0 or " +
@@ -1082,6 +1279,11 @@
         }
     }
 
+    /**
+     * Test the proper plural rule keyword selection given an input number that is
+     * already formatted into compact notation. This exercises the `c` plural operand
+     * for the formatted number.
+     */
     @Test
     public void testCompactDecimalPluralKeyword() {
         PluralRules rules = PluralRules.createRules("one: i = 0,1 @integer 0, 1 @decimal 0.0~1.5;  many: c = 0 and i % 1000000 = 0 and v = 0 or " +
@@ -1261,8 +1463,13 @@
 
     @Test
     public void TestLocales() {
+        // This test will fail when the locale snapshot gets out of sync with the real CLDR data.
+        // In that case, temporarily use "if (true)",
+        // copy & paste the output into the initializer above,
+        // and revert to "if (false)" for normal testing.
         if (false) {
             generateLOCALE_SNAPSHOT();
+            return;
         }
         for (String test : LOCALE_SNAPSHOT) {
             test = test.trim();
@@ -1308,7 +1515,7 @@
                 System.out.print("        \"" + CollectionUtilities.join(locales, ","));
                 for (StandardPluralCategories spc : set) {
                     String keyword = spc.toString();
-                    FixedDecimalSamples samples = rule.getDecimalSamples(keyword, SampleType.INTEGER);
+                    DecimalQuantitySamples samples = rule.getDecimalSamples(keyword, SampleType.INTEGER);
                     System.out.print("; " + spc + ": " + samples);
                 }
                 System.out.println("\",");