diff --git a/icu4c/source/i18n/number_decimalquantity.cpp b/icu4c/source/i18n/number_decimalquantity.cpp
index 74547c1..7720955 100644
--- a/icu4c/source/i18n/number_decimalquantity.cpp
+++ b/icu4c/source/i18n/number_decimalquantity.cpp
@@ -273,6 +273,9 @@
             return fractionCountWithoutTrailingZeros();
         case PLURAL_OPERAND_E:
             return static_cast<double>(getExponent());
+        case PLURAL_OPERAND_C:
+            // Plural operand `c` is currently an alias for `e`.
+            return static_cast<double>(getExponent());
         default:
             return std::abs(toDouble());
     }
diff --git a/icu4c/source/i18n/plurrule.cpp b/icu4c/source/i18n/plurrule.cpp
index e1e1667..bfcb6fb 100644
--- a/icu4c/source/i18n/plurrule.cpp
+++ b/icu4c/source/i18n/plurrule.cpp
@@ -60,6 +60,7 @@
 static const UChar PK_VAR_F[]={LOW_F,0};
 static const UChar PK_VAR_T[]={LOW_T,0};
 static const UChar PK_VAR_E[]={LOW_E,0};
+static const UChar PK_VAR_C[]={LOW_C,0};
 static const UChar PK_VAR_V[]={LOW_V,0};
 static const UChar PK_WITHIN[]={LOW_W,LOW_I,LOW_T,LOW_H,LOW_I,LOW_N,0};
 static const UChar PK_DECIMAL[]={LOW_D,LOW_E,LOW_C,LOW_I,LOW_M,LOW_A,LOW_L,0};
@@ -421,7 +422,6 @@
                 destFd[sampleCount++] = fixed;
             }
         } else {
-
             FixedDecimal fixedLo(sampleRange.tempSubStringBetween(0, tildeIndex), status);
             FixedDecimal fixedHi(sampleRange.tempSubStringBetween(tildeIndex+1), status);
             double rangeLo = fixedLo.source;
@@ -514,6 +514,7 @@
     if (rc == nullptr) {
         return 0;
     }
+
     int32_t numSamples = getSamplesFromString(rc->fIntegerSamples, nullptr, dest, destCapacity, status);
     if (numSamples == 0) {
         numSamples = getSamplesFromString(rc->fDecimalSamples, nullptr, dest, destCapacity, status);
@@ -706,6 +707,7 @@
         case tVariableF:
         case tVariableT:
         case tVariableE:
+        case tVariableC:
         case tVariableV:
             U_ASSERT(curAndConstraint != nullptr);
             curAndConstraint->digitsType = type;
@@ -1092,6 +1094,8 @@
         s.append(LOW_T); break;
       case tVariableE:
         s.append(LOW_E); break;
+    case tVariableC:
+        s.append(LOW_C); break;
       default:
         s.append(TILDE);
     }
@@ -1269,6 +1273,7 @@
     case tVariableF:
     case tVariableT:
     case tVariableE:
+    case tVariableC:
     case tVariableV:
         if (type != tIs && type != tMod && type != tIn &&
             type != tNot && type != tWithin && type != tEqual && type != tNotEqual) {
@@ -1286,6 +1291,7 @@
               type == tVariableF ||
               type == tVariableT ||
               type == tVariableE ||
+              type == tVariableC ||
               type == tVariableV ||
               type == tAt)) {
             status = U_UNEXPECTED_TOKEN;
@@ -1318,6 +1324,7 @@
              type != tVariableF &&
              type != tVariableT &&
              type != tVariableE &&
+             type != tVariableC &&
              type != tVariableV) {
             status = U_UNEXPECTED_TOKEN;
         }
@@ -1497,6 +1504,8 @@
         keyType = tVariableT;
     } else if (0 == token.compare(PK_VAR_E, 1)) {
         keyType = tVariableE;
+    } else if (0 == token.compare(PK_VAR_C, 1)) {
+        keyType = tVariableC;
     } else if (0 == token.compare(PK_VAR_V, 1)) {
         keyType = tVariableV;
     } else if (0 == token.compare(PK_IS, 2)) {
@@ -1596,11 +1605,17 @@
         return PLURAL_OPERAND_T;
     case tVariableE:
         return PLURAL_OPERAND_E;
+    case tVariableC:
+        return PLURAL_OPERAND_E;
     default:
         UPRV_UNREACHABLE;  // unexpected.
     }
 }
 
+FixedDecimal::FixedDecimal(double n, int32_t v, int64_t f, int32_t e, int32_t c) {
+    init(n, v, f, e, c);
+}
+
 FixedDecimal::FixedDecimal(double n, int32_t v, int64_t f, int32_t e) {
     init(n, v, f, e);
     // check values. TODO make into unit test.
@@ -1642,16 +1657,30 @@
 FixedDecimal::FixedDecimal(const UnicodeString &num, UErrorCode &status) {
     CharString cs;
     int32_t parsedExponent = 0;
+    int32_t parsedCompactExponent = 0;
 
     int32_t exponentIdx = num.indexOf(u'e');
     if (exponentIdx < 0) {
         exponentIdx = num.indexOf(u'E');
     }
+    int32_t compactExponentIdx = num.indexOf(u'c');
+    if (compactExponentIdx < 0) {
+        compactExponentIdx = num.indexOf(u'C');
+    }
+
     if (exponentIdx >= 0) {
         cs.appendInvariantChars(num.tempSubString(0, exponentIdx), status);
         int32_t expSubstrStart = exponentIdx + 1;
         parsedExponent = ICU_Utility::parseAsciiInteger(num, expSubstrStart);
     }
+    else if (compactExponentIdx >= 0) {
+        cs.appendInvariantChars(num.tempSubString(0, compactExponentIdx), status);
+        int32_t expSubstrStart = compactExponentIdx + 1;
+        parsedCompactExponent = ICU_Utility::parseAsciiInteger(num, expSubstrStart);
+
+        parsedExponent = parsedCompactExponent;
+        exponentIdx = compactExponentIdx;
+    }
     else {
         cs.appendInvariantChars(num, status);
     }
@@ -1706,13 +1735,20 @@
     init(n, v, f, exponent);
 }
 
-
 void FixedDecimal::init(double n, int32_t v, int64_t f, int32_t e) {
+    // Currently, `c` is an alias for `e`
+    init(n, v, f, e, e);
+}
+
+void FixedDecimal::init(double n, int32_t v, int64_t f, int32_t e, int32_t c) {
     isNegative = n < 0.0;
     source = fabs(n);
     _isNaN = uprv_isNaN(source);
     _isInfinite = uprv_isInfinite(source);
     exponent = e;
+    if (exponent == 0) {
+        exponent = c;
+    }
     if (_isNaN || _isInfinite) {
         v = 0;
         f = 0;
@@ -1843,6 +1879,7 @@
         case PLURAL_OPERAND_T: return static_cast<double>(decimalDigitsWithoutTrailingZeros);
         case PLURAL_OPERAND_V: return visibleDecimalDigitCount;
         case PLURAL_OPERAND_E: return exponent;
+        case PLURAL_OPERAND_C: return exponent;
         default:
              UPRV_UNREACHABLE;  // unexpected.
     }
@@ -1876,12 +1913,12 @@
 UnicodeString FixedDecimal::toString() const {
     char pattern[15];
     char buffer[20];
-    if (exponent == 0) {
-        snprintf(pattern, sizeof(pattern), "%%.%df", visibleDecimalDigitCount);
-        snprintf(buffer, sizeof(buffer), pattern, source);
-    } else {
+    if (exponent != 0) {
         snprintf(pattern, sizeof(pattern), "%%.%dfe%%d", visibleDecimalDigitCount);
         snprintf(buffer, sizeof(buffer), pattern, source, exponent);
+    } else {
+        snprintf(pattern, sizeof(pattern), "%%.%df", visibleDecimalDigitCount);
+        snprintf(buffer, sizeof(buffer), pattern, source);
     }
     return UnicodeString(buffer, -1, US_INV);
 }
diff --git a/icu4c/source/i18n/plurrule_impl.h b/icu4c/source/i18n/plurrule_impl.h
index 52af3a7..ccc4813 100644
--- a/icu4c/source/i18n/plurrule_impl.h
+++ b/icu4c/source/i18n/plurrule_impl.h
@@ -145,6 +145,7 @@
   tVariableV,
   tVariableT,
   tVariableE,
+  tVariableC,
   tDecimal,
   tInteger,
   tEOF
@@ -222,12 +223,21 @@
     PLURAL_OPERAND_W,
 
     /**
-     * Suppressed exponent for compact notation (exponent needed in
-     * scientific notation with compact notation to approximate i).
+     * Suppressed exponent for scientific notation (exponent needed in
+     * scientific notation to approximate i).
      */
     PLURAL_OPERAND_E,
 
     /**
+     * This operand is currently treated as an alias for `PLURAL_OPERAND_E`.
+     * In the future, it will represent:
+     *
+     * Suppressed exponent for compact notation (exponent needed in
+     * compact notation to approximate i).
+     */
+    PLURAL_OPERAND_C,
+
+    /**
      * THIS OPERAND IS DEPRECATED AND HAS BEEN REMOVED FROM THE SPEC.
      *
      * <p>Returns the integer value, but will fail if the number has fraction digits.
@@ -280,8 +290,10 @@
       * @param n   the number, e.g. 12.345
       * @param v   The number of visible fraction digits, e.g. 3
       * @param f   The fraction digits, e.g. 345
-      * @param e   The exponent, e.g. 7 in 1.2e7 (for compact/scientific)
+      * @param e   The exponent, e.g. 7 in 1.2e7, for scientific notation
+      * @param c   Currently: an alias for param `e`.
       */
+    FixedDecimal(double  n, int32_t v, int64_t f, int32_t e, int32_t c);
     FixedDecimal(double  n, int32_t v, int64_t f, int32_t e);
     FixedDecimal(double  n, int32_t v, int64_t f);
     FixedDecimal(double n, int32_t);
@@ -302,6 +314,7 @@
 
     int32_t getVisibleFractionDigitCount() const;
 
+    void init(double n, int32_t v, int64_t f, int32_t e, int32_t c);
     void init(double n, int32_t v, int64_t f, int32_t e);
     void init(double n, int32_t v, int64_t f);
     void init(double n);
diff --git a/icu4c/source/test/intltest/numbertest.h b/icu4c/source/test/intltest/numbertest.h
index 3285ff7..39e8885 100644
--- a/icu4c/source/test/intltest/numbertest.h
+++ b/icu4c/source/test/intltest/numbertest.h
@@ -201,7 +201,7 @@
     void testToDouble();
     void testMaxDigits();
     void testNickelRounding();
-    void testCompactDecimalSuppressedExponent();
+    void testScientificAndCompactSuppressedExponent();
     void testSuppressedExponentUnchangedByInitialScaling();
 
     void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par = 0);
diff --git a/icu4c/source/test/intltest/numbertest_decimalquantity.cpp b/icu4c/source/test/intltest/numbertest_decimalquantity.cpp
index 74b97a9..610df96 100644
--- a/icu4c/source/test/intltest/numbertest_decimalquantity.cpp
+++ b/icu4c/source/test/intltest/numbertest_decimalquantity.cpp
@@ -30,7 +30,7 @@
         TESTCASE_AUTO(testToDouble);
         TESTCASE_AUTO(testMaxDigits);
         TESTCASE_AUTO(testNickelRounding);
-        TESTCASE_AUTO(testCompactDecimalSuppressedExponent);
+        TESTCASE_AUTO(testScientificAndCompactSuppressedExponent);
         TESTCASE_AUTO(testSuppressedExponentUnchangedByInitialScaling);
     TESTCASE_AUTO_END;
 }
@@ -478,8 +478,8 @@
     status.expectErrorAndReset(U_FORMAT_INEXACT_ERROR);
 }
 
-void DecimalQuantityTest::testCompactDecimalSuppressedExponent() {
-    IcuTestErrorCode status(*this, "testCompactDecimalSuppressedExponent");
+void DecimalQuantityTest::testScientificAndCompactSuppressedExponent() {
+    IcuTestErrorCode status(*this, "testScientificAndCompactSuppressedExponent");
     Locale ulocale("fr-FR");
 
     struct TestCase {
@@ -489,53 +489,56 @@
         int64_t expectedLong;
         double expectedDouble;
         const char16_t* expectedPlainString;
-        int32_t expectedSuppressedExponent;
+        int32_t expectedSuppressedScientificExponent;
+        int32_t expectedSuppressedCompactExponent;
     } cases[] = {
-        // unlocalized formatter skeleton, input, string output, long output, double output, BigDecimal output, plain string, suppressed exponent
-        {u"",              123456789, u"123 456 789",  123456789L, 123456789.0, u"123456789", 0},
-        {u"compact-long",  123456789, u"123 millions", 123000000L, 123000000.0, u"123000000", 6},
-        {u"compact-short", 123456789, u"123 M",        123000000L, 123000000.0, u"123000000", 6},
-        {u"scientific",    123456789, u"1,234568E8",   123456800L, 123456800.0, u"123456800", 8},
+        // unlocalized formatter skeleton, input, string output, long output,
+        // double output, BigDecimal output, plain string,
+        // suppressed scientific exponent, suppressed compact exponent
+        {u"",              123456789, u"123 456 789",  123456789L, 123456789.0, u"123456789", 0, 0},
+        {u"compact-long",  123456789, u"123 millions", 123000000L, 123000000.0, u"123000000", 6, 6},
+        {u"compact-short", 123456789, u"123 M",        123000000L, 123000000.0, u"123000000", 6, 6},
+        {u"scientific",    123456789, u"1,234568E8",   123456800L, 123456800.0, u"123456800", 8, 8},
 
-        {u"",              1234567, u"1 234 567",   1234567L, 1234567.0, u"1234567", 0},
-        {u"compact-long",  1234567, u"1,2 million", 1200000L, 1200000.0, u"1200000", 6},
-        {u"compact-short", 1234567, u"1,2 M",       1200000L, 1200000.0, u"1200000", 6},
-        {u"scientific",    1234567, u"1,234567E6",  1234567L, 1234567.0, u"1234567", 6},
+        {u"",              1234567, u"1 234 567",   1234567L, 1234567.0, u"1234567", 0, 0},
+        {u"compact-long",  1234567, u"1,2 million", 1200000L, 1200000.0, u"1200000", 6, 6},
+        {u"compact-short", 1234567, u"1,2 M",       1200000L, 1200000.0, u"1200000", 6, 6},
+        {u"scientific",    1234567, u"1,234567E6",  1234567L, 1234567.0, u"1234567", 6, 6},
 
-        {u"",              123456, u"123 456",   123456L, 123456.0, u"123456", 0},
-        {u"compact-long",  123456, u"123 mille", 123000L, 123000.0, u"123000", 3},
-        {u"compact-short", 123456, u"123 k",     123000L, 123000.0, u"123000", 3},
-        {u"scientific",    123456, u"1,23456E5", 123456L, 123456.0, u"123456", 5},
+        {u"",              123456, u"123 456",   123456L, 123456.0, u"123456", 0, 0},
+        {u"compact-long",  123456, u"123 mille", 123000L, 123000.0, u"123000", 3, 3},
+        {u"compact-short", 123456, u"123 k",     123000L, 123000.0, u"123000", 3, 3},
+        {u"scientific",    123456, u"1,23456E5", 123456L, 123456.0, u"123456", 5, 5},
 
-        {u"",              123, u"123",    123L, 123.0, u"123", 0},
-        {u"compact-long",  123, u"123",    123L, 123.0, u"123", 0},
-        {u"compact-short", 123, u"123",    123L, 123.0, u"123", 0},
-        {u"scientific",    123, u"1,23E2", 123L, 123.0, u"123", 2},
+        {u"",              123, u"123",    123L, 123.0, u"123", 0, 0},
+        {u"compact-long",  123, u"123",    123L, 123.0, u"123", 0, 0},
+        {u"compact-short", 123, u"123",    123L, 123.0, u"123", 0, 0},
+        {u"scientific",    123, u"1,23E2", 123L, 123.0, u"123", 2, 2},
 
-        {u"",              1.2, u"1,2",   1L, 1.2, u"1.2", 0},
-        {u"compact-long",  1.2, u"1,2",   1L, 1.2, u"1.2", 0},
-        {u"compact-short", 1.2, u"1,2",   1L, 1.2, u"1.2", 0},
-        {u"scientific",    1.2, u"1,2E0", 1L, 1.2, u"1.2", 0},
+        {u"",              1.2, u"1,2",   1L, 1.2, u"1.2", 0, 0},
+        {u"compact-long",  1.2, u"1,2",   1L, 1.2, u"1.2", 0, 0},
+        {u"compact-short", 1.2, u"1,2",   1L, 1.2, u"1.2", 0, 0},
+        {u"scientific",    1.2, u"1,2E0", 1L, 1.2, u"1.2", 0, 0},
 
-        {u"",              0.12, u"0,12",   0L, 0.12, u"0.12", 0},
-        {u"compact-long",  0.12, u"0,12",   0L, 0.12, u"0.12", 0},
-        {u"compact-short", 0.12, u"0,12",   0L, 0.12, u"0.12", 0},
-        {u"scientific",    0.12, u"1,2E-1", 0L, 0.12, u"0.12", -1},
+        {u"",              0.12, u"0,12",   0L, 0.12, u"0.12",  0,  0},
+        {u"compact-long",  0.12, u"0,12",   0L, 0.12, u"0.12",  0,  0},
+        {u"compact-short", 0.12, u"0,12",   0L, 0.12, u"0.12",  0,  0},
+        {u"scientific",    0.12, u"1,2E-1", 0L, 0.12, u"0.12", -1, -1},
 
-        {u"",              0.012, u"0,012",   0L, 0.012, u"0.012", 0},
-        {u"compact-long",  0.012, u"0,012",   0L, 0.012, u"0.012", 0},
-        {u"compact-short", 0.012, u"0,012",   0L, 0.012, u"0.012", 0},
-        {u"scientific",    0.012, u"1,2E-2",  0L, 0.012, u"0.012", -2},
+        {u"",              0.012, u"0,012",   0L, 0.012, u"0.012",  0,  0},
+        {u"compact-long",  0.012, u"0,012",   0L, 0.012, u"0.012",  0,  0},
+        {u"compact-short", 0.012, u"0,012",   0L, 0.012, u"0.012",  0,  0},
+        {u"scientific",    0.012, u"1,2E-2",  0L, 0.012, u"0.012", -2, -2},
 
-        {u"",              999.9, u"999,9",     999L,  999.9,  u"999.9", 0},
-        {u"compact-long",  999.9, u"1 millier", 1000L, 1000.0, u"1000",  3},
-        {u"compact-short", 999.9, u"1 k",       1000L, 1000.0, u"1000",  3},
-        {u"scientific",    999.9, u"9,999E2",   999L,  999.9,  u"999.9", 2},
+        {u"",              999.9, u"999,9",     999L,  999.9,  u"999.9", 0, 0},
+        {u"compact-long",  999.9, u"1 millier", 1000L, 1000.0, u"1000",  3, 3},
+        {u"compact-short", 999.9, u"1 k",       1000L, 1000.0, u"1000",  3, 3},
+        {u"scientific",    999.9, u"9,999E2",   999L,  999.9,  u"999.9", 2, 2},
 
-        {u"",              1000.0, u"1 000",     1000L, 1000.0, u"1000", 0},
-        {u"compact-long",  1000.0, u"1 millier", 1000L, 1000.0, u"1000", 3},
-        {u"compact-short", 1000.0, u"1 k",       1000L, 1000.0, u"1000", 3},
-        {u"scientific",    1000.0, u"1E3",       1000L, 1000.0, u"1000", 3},
+        {u"",              1000.0, u"1 000",     1000L, 1000.0, u"1000", 0, 0},
+        {u"compact-long",  1000.0, u"1 millier", 1000L, 1000.0, u"1000", 3, 3},
+        {u"compact-short", 1000.0, u"1 k",       1000L, 1000.0, u"1000", 3, 3},
+        {u"scientific",    1000.0, u"1E3",       1000L, 1000.0, u"1000", 3, 3},
     };
     for (const auto& cas : cases) {
         // test the helper methods used to compute plural operand values
@@ -550,18 +553,19 @@
         int64_t actualLong = dq.toLong();
         double actualDouble = dq.toDouble();
         UnicodeString actualPlainString = dq.toPlainString();
-        int32_t actualSuppressedExponent = dq.getExponent();
+        int32_t actualSuppressedScientificExponent = dq.getExponent();
+        int32_t actualSuppressedCompactExponent = dq.getExponent();
 
         assertEquals(
                 u"formatted number " + cas.skeleton + u" toString: " + cas.input,
                 cas.expectedString,
                 actualString);
         assertEquals(
-                u"compact decimal " + cas.skeleton + u" toLong: " + cas.input,
+                u"formatted number " + cas.skeleton + u" toLong: " + cas.input,
                 cas.expectedLong,
                 actualLong);
         assertDoubleEquals(
-                u"compact decimal " + cas.skeleton + u" toDouble: " + cas.input,
+                u"formatted number " + cas.skeleton + u" toDouble: " + cas.input,
                 cas.expectedDouble,
                 actualDouble);
         assertEquals(
@@ -569,36 +573,46 @@
                 cas.expectedPlainString,
                 actualPlainString);
         assertEquals(
-                u"compact decimal " + cas.skeleton + u" suppressed exponent: " + cas.input,
-                cas.expectedSuppressedExponent,
-                actualSuppressedExponent);
+                u"formatted number " + cas.skeleton + u" suppressed scientific exponent: " + cas.input,
+                cas.expectedSuppressedScientificExponent,
+                actualSuppressedScientificExponent);
+        assertEquals(
+                u"formatted number " + cas.skeleton + u" suppressed compact exponent: " + cas.input,
+                cas.expectedSuppressedCompactExponent,
+                actualSuppressedCompactExponent);
 
         // test the actual computed values of the plural operands
 
         double expectedNOperand = cas.expectedDouble;
         double expectedIOperand = cas.expectedLong;
-        double expectedEOperand = cas.expectedSuppressedExponent;
+        double expectedEOperand = cas.expectedSuppressedScientificExponent;
+        double expectedCOperand = cas.expectedSuppressedCompactExponent;
         double actualNOperand = dq.getPluralOperand(PLURAL_OPERAND_N);
         double actualIOperand = dq.getPluralOperand(PLURAL_OPERAND_I);
         double actualEOperand = dq.getPluralOperand(PLURAL_OPERAND_E);
+        double actualCOperand = dq.getPluralOperand(PLURAL_OPERAND_C);
 
         assertDoubleEquals(
-                u"compact decimal " + cas.skeleton + u" n operand: " + cas.input,
+                u"formatted number " + cas.skeleton + u" n operand: " + cas.input,
                 expectedNOperand,
                 actualNOperand);
         assertDoubleEquals(
-                u"compact decimal " + cas.skeleton + u" i operand: " + cas.input,
+                u"formatted number " + cas.skeleton + u" i operand: " + cas.input,
                 expectedIOperand,
                 actualIOperand);
         assertDoubleEquals(
-                u"compact decimal " + cas.skeleton + " e operand: " + cas.input,
+                u"formatted number " + cas.skeleton + " e operand: " + cas.input,
                 expectedEOperand,
                 actualEOperand);
+        assertDoubleEquals(
+                u"formatted number " + cas.skeleton + " c operand: " + cas.input,
+                expectedCOperand,
+                actualCOperand);
     }
 }
 
 void DecimalQuantityTest::testSuppressedExponentUnchangedByInitialScaling() {
-    IcuTestErrorCode status(*this, "testCompactDecimalSuppressedExponent");
+    IcuTestErrorCode status(*this, "testSuppressedExponentUnchangedByInitialScaling");
     Locale ulocale("fr-FR");
     LocalizedNumberFormatter withLocale = NumberFormatter::withLocale(ulocale);
     LocalizedNumberFormatter compactLong =
@@ -612,20 +626,22 @@
         double expectedNOperand;
         double expectedIOperand;
         double expectedEOperand;
+        double expectedCOperand;
     } cases[] = {
         // input, compact long string output,
-        // compact n operand, compact i operand, compact e operand
-        {123456789, "123 millions", 123000000.0, 123000000.0, 6.0},
-        {1234567,   "1,2 million",  1200000.0,   1200000.0,   6.0},
-        {123456,    "123 mille",    123000.0,    123000.0,    3.0},
-        {123,       "123",          123.0,       123.0,       0.0},
+        // compact n operand, compact i operand, compact e operand,
+        // compact c operand
+        {123456789, "123 millions", 123000000.0, 123000000.0, 6.0, 6.0},
+        {1234567,   "1,2 million",  1200000.0,   1200000.0,   6.0, 6.0},
+        {123456,    "123 mille",    123000.0,    123000.0,    3.0, 3.0},
+        {123,       "123",          123.0,       123.0,       0.0, 0.0},
     };
 
     for (const auto& cas : cases) {
         FormattedNumber fnCompactScaled = compactScaled.formatInt(cas.input, status);
         DecimalQuantity dqCompactScaled;
         fnCompactScaled.getDecimalQuantity(dqCompactScaled, status);
-        double compactScaledEOperand = dqCompactScaled.getPluralOperand(PLURAL_OPERAND_E);
+        double compactScaledCOperand = dqCompactScaled.getPluralOperand(PLURAL_OPERAND_C);
 
         FormattedNumber fnCompact = compactLong.formatInt(cas.input, status);
         DecimalQuantity dqCompact;
@@ -634,6 +650,7 @@
         double compactNOperand = dqCompact.getPluralOperand(PLURAL_OPERAND_N);
         double compactIOperand = dqCompact.getPluralOperand(PLURAL_OPERAND_I);
         double compactEOperand = dqCompact.getPluralOperand(PLURAL_OPERAND_E);
+        double compactCOperand = dqCompact.getPluralOperand(PLURAL_OPERAND_C);
         assertEquals(
                 u"formatted number " + Int64ToUnicodeString(cas.input) + " compactLong toString: ",
                 cas.expectedString,
@@ -650,14 +667,18 @@
                 u"compact decimal " + DoubleToUnicodeString(cas.input) + ", e operand vs. expected",
                 cas.expectedEOperand,
                 compactEOperand);
+        assertDoubleEquals(
+                u"compact decimal " + DoubleToUnicodeString(cas.input) + ", c operand vs. expected",
+                cas.expectedCOperand,
+                compactCOperand);
 
         // By scaling by 10^3 in a locale that has words / compact notation
         // based on powers of 10^3, we guarantee that the suppressed
         // exponent will differ by 3.
         assertDoubleEquals(
-                u"decimal " + DoubleToUnicodeString(cas.input) + ", e operand for compact vs. compact scaled",
-                compactEOperand + 3,
-                compactScaledEOperand);
+                u"decimal " + DoubleToUnicodeString(cas.input) + ", c operand for compact vs. compact scaled",
+                compactCOperand + 3,
+                compactScaledCOperand);
     }
 }
 
diff --git a/icu4c/source/test/intltest/plurults.cpp b/icu4c/source/test/intltest/plurults.cpp
index 9610fb6..407e484 100644
--- a/icu4c/source/test/intltest/plurults.cpp
+++ b/icu4c/source/test/intltest/plurults.cpp
@@ -52,8 +52,10 @@
     TESTCASE_AUTO(testGetSamples);
     TESTCASE_AUTO(testGetFixedDecimalSamples);
     TESTCASE_AUTO(testSamplesWithExponent);
+    TESTCASE_AUTO(testSamplesWithCompactNotation);
     TESTCASE_AUTO(testWithin);
     TESTCASE_AUTO(testGetAllKeywordValues);
+    TESTCASE_AUTO(testScientificPluralKeyword);
     TESTCASE_AUTO(testCompactDecimalPluralKeyword);
     TESTCASE_AUTO(testOrdinal);
     TESTCASE_AUTO(testSelect);
@@ -404,7 +406,7 @@
     double values[1000];
     for (int32_t i = 0; U_SUCCESS(status) && i < numLocales; ++i) {
         if (uprv_strcmp(locales[i].getLanguage(), "fr") == 0 &&
-                logKnownIssue("21299", "PluralRules::getSamples cannot distinguish 1e5 from 100000")) {
+                logKnownIssue("21322", "PluralRules::getSamples cannot distinguish 1e5 from 100000")) {
             continue;
         }
         LocalPointer<PluralRules> rules(PluralRules::forLocale(locales[i], status));
@@ -465,7 +467,7 @@
     FixedDecimal values[1000];
     for (int32_t i = 0; U_SUCCESS(status) && i < numLocales; ++i) {
         if (uprv_strcmp(locales[i].getLanguage(), "fr") == 0 &&
-                logKnownIssue("21299", "PluralRules::getSamples cannot distinguish 1e5 from 100000")) {
+                logKnownIssue("21322", "PluralRules::getSamples cannot distinguish 1e5 from 100000")) {
             continue;
         }
         LocalPointer<PluralRules> rules(PluralRules::forLocale(locales[i], status));
@@ -551,6 +553,44 @@
     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));
 }
 
+
+void PluralRulesTest::testSamplesWithCompactNotation() {
+    // integer samples
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString description(
+        u"one: i = 0,1 @integer 0, 1, 1c5 @decimal 0.0~1.5, 1.1c5; "
+        u"many: c = 0 and i != 0 and i % 1000000 = 0 and v = 0 or c != 0..5"
+        u" @integer 1000000, 2c6, 3c6, 4c6, 5c6, 6c6, 7c6, … @decimal 2.1c6, 3.1c6, 4.1c6, 5.1c6, 6.1c6, 7.1c6, …; "
+        u"other:  @integer 2~17, 100, 1000, 10000, 100000, 2c5, 3c5, 4c5, 5c5, 6c5, 7c5, …"
+        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, …"
+    );
+    LocalPointer<PluralRules> test(PluralRules::createRules(description, status));
+    if (U_FAILURE(status)) {
+        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));
+
+    // decimal samples
+    status = U_ZERO_ERROR;
+    UnicodeString description2(
+        u"one: i = 0,1 @decimal 0.0~1.5, 1.1c5; "
+        u"many: c = 0 and i != 0 and i % 1000000 = 0 and v = 0 or c != 0..5"
+        u" @decimal 2.1c6, 3.1c6, 4.1c6, 5.1c6, 6.1c6, 7.1c6, …; "
+        u"other:  @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, …"
+    );
+    LocalPointer<PluralRules> test2(PluralRules::createRules(description2, status));
+    if (U_FAILURE(status)) {
+        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));
+}
+
 void PluralRulesTest::checkNewSamples(
         UnicodeString description, 
         const LocalPointer<PluralRules> &test,
@@ -727,13 +767,77 @@
     }
 }
 
+// For the time being, the  compact notation exponent operand `c` is an alias
+// for the scientific exponent operand `e` and compact notation.
+void
+PluralRulesTest::testScientificPluralKeyword() {
+    IcuTestErrorCode errorCode(*this, "testScientificPluralKeyword");
+
+    LocalPointer<PluralRules> rules(PluralRules::createRules(
+        u"one: i = 0,1 @integer 0, 1 @decimal 0.0~1.5;  "
+        u"many: e = 0 and i % 1000000 = 0 and v = 0 or e != 0 .. 5;  "
+        u"other:  @integer 2~17, 100, 1000, 10000, 100000, 1000000,  "
+        u"  @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …", errorCode));
+
+    if (U_FAILURE(errorCode)) {
+        errln("Couldn't instantiate plurals rules from string, with error = %s", u_errorName(errorCode));
+        return;
+    }
+
+    const char* localeName = "fr-FR";
+    Locale locale = Locale::createFromName(localeName);
+
+    struct TestCase {
+        const char16_t* skeleton;
+        const int input;
+        const char16_t* expectedFormattedOutput;
+        const char16_t* expectedPluralRuleKeyword;
+    } cases[] = {
+        // unlocalized formatter skeleton, input, string output, plural rule keyword
+        {u"",           0, u"0", u"one"},
+        {u"scientific", 0, u"0", u"one"},
+
+        {u"",           1, u"1", u"one"},
+        {u"scientific", 1, u"1", u"one"},
+
+        {u"",           2, u"2", u"other"},
+        {u"scientific", 2, u"2", u"other"},
+
+        {u"",           1000000, u"1 000 000", u"many"},
+        {u"scientific", 1000000, u"1 million", u"many"},
+
+        {u"",           1000001, u"1 000 001", u"other"},
+        {u"scientific", 1000001, u"1 million", u"many"},
+
+        {u"",           120000,  u"1 200 000",    u"other"},
+        {u"scientific", 1200000, u"1,2 millions", u"many"},
+
+        {u"",           1200001, u"1 200 001",    u"other"},
+        {u"scientific", 1200001, u"1,2 millions", u"many"},
+
+        {u"",           2000000, u"2 000 000",  u"many"},
+        {u"scientific", 2000000, u"2 millions", u"many"},
+    };
+    for (const auto& cas : cases) {
+        const char16_t* skeleton = cas.skeleton;
+        const int input = cas.input;
+        const char16_t* expectedPluralRuleKeyword = cas.expectedPluralRuleKeyword;
+
+        UnicodeString actualPluralRuleKeyword =
+            getPluralKeyword(rules, locale, input, skeleton);
+
+        UnicodeString message(UnicodeString(localeName) + u" " + DoubleToUnicodeString(input));
+        assertEquals(message, expectedPluralRuleKeyword, actualPluralRuleKeyword);
+    }
+}
+
 void
 PluralRulesTest::testCompactDecimalPluralKeyword() {
     IcuTestErrorCode errorCode(*this, "testCompactDecimalPluralKeyword");
 
     LocalPointer<PluralRules> rules(PluralRules::createRules(
         u"one: i = 0,1 @integer 0, 1 @decimal 0.0~1.5;  "
-        u"many: e = 0 and i % 1000000 = 0 and v = 0 or e != 0 .. 5;  "
+        u"many: c = 0 and i % 1000000 = 0 and v = 0 or c != 0 .. 5;  "
         u"other:  @integer 2~17, 100, 1000, 10000, 100000, 1000000,  "
         u"  @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …", errorCode));
 
diff --git a/icu4c/source/test/intltest/plurults.h b/icu4c/source/test/intltest/plurults.h
index 8e220dc..927a24d 100644
--- a/icu4c/source/test/intltest/plurults.h
+++ b/icu4c/source/test/intltest/plurults.h
@@ -32,9 +32,11 @@
     void testGetSamples();
     void testGetFixedDecimalSamples();
     void testSamplesWithExponent();
+    void testSamplesWithCompactNotation();
     void testWithin();
     void testGetAllKeywordValues();
     void testCompactDecimalPluralKeyword();
+    void testScientificPluralKeyword();
     void testOrdinal();
     void testSelect();
     void testSelectRange();
diff --git a/icu4j/main/classes/core/src/com/ibm/icu/impl/number/DecimalQuantity_AbstractBCD.java b/icu4j/main/classes/core/src/com/ibm/icu/impl/number/DecimalQuantity_AbstractBCD.java
index bce3400..2d98cc2 100644
--- a/icu4j/main/classes/core/src/com/ibm/icu/impl/number/DecimalQuantity_AbstractBCD.java
+++ b/icu4j/main/classes/core/src/com/ibm/icu/impl/number/DecimalQuantity_AbstractBCD.java
@@ -265,6 +265,9 @@
             return fractionCountWithoutTrailingZeros();
         case e:
             return getExponent();
+        case c:
+            // Plural operand `c` is currently an alias for `e`.
+            return getExponent();
         default:
             return Math.abs(toDouble());
         }
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 b302b4e..870b947 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
@@ -481,8 +481,8 @@
         w,
 
         /**
-         * Suppressed exponent for compact notation (exponent needed in
-         * scientific notation with compact notation to approximate i).
+         * Suppressed exponent for scientific notation (exponent needed in
+         * scientific notation to approximate i).
          *
          * @internal
          * @deprecated This API is ICU internal only.
@@ -491,6 +491,19 @@
         e,
 
         /**
+         * This operand is currently treated as an alias for `PLURAL_OPERAND_E`.
+         * In the future, it will represent:
+         *
+         * Suppressed exponent for compact notation (exponent needed in
+         * compact notation to approximate i).
+         *
+         * @internal
+         * @deprecated This API is ICU internal only.
+         */
+        @Deprecated
+        c,
+
+        /**
          * THIS OPERAND IS DEPRECATED AND HAS BEEN REMOVED FROM THE SPEC.
          *
          * <p>Returns the integer value, but will fail if the number has fraction digits.
@@ -657,10 +670,11 @@
          * @param v number of digits to the right of the decimal place. e.g 1.00 = 2 25. = 0
          * @param f Corresponds to f in the plural rules grammar.
          *   The digits to the right of the decimal place as an integer. e.g 1.10 = 10
-         * @param e Suppressed exponent for scientific and compact notation
+         * @param e Suppressed exponent for scientific notation
+         * @param c Currently: an alias for param `e`
          */
         @Deprecated
-        public FixedDecimal(double n, int v, long f, int e) {
+        public FixedDecimal(double n, int v, long f, int e, int c) {
             isNegative = n < 0;
             source = isNegative ? -n : n;
             visibleDecimalDigitCount = v;
@@ -668,7 +682,11 @@
             integerValue = n > MAX
                     ? MAX
                             : (long)n;
-            exponent = e;
+            int initExpVal = e;
+            if (initExpVal == 0) {
+                initExpVal = c;
+            }
+            exponent = initExpVal;
             hasIntegerValue = source == integerValue;
             // check values. TODO make into unit test.
             //
@@ -704,6 +722,15 @@
          * @deprecated This API is ICU internal only.
          */
         @Deprecated
+        public FixedDecimal(double n, int v, long f, int e) {
+            this(n, v, f, e, e);
+        }
+
+        /**
+         * @internal CLDR
+         * @deprecated This API is ICU internal only.
+         */
+        @Deprecated
         public FixedDecimal(double n, int v, long f) {
             this(n, v, f, 0);
         }
@@ -848,8 +875,11 @@
          */
         @Deprecated
         private static FixedDecimal parseDecimalSampleRangeNumString(String num) {
-            if (num.contains("e")) {
+            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);
@@ -890,6 +920,7 @@
             case v: return visibleDecimalDigitCount;
             case w: return visibleDecimalDigitCountWithoutTrailingZeros;
             case e: return exponent;
+            case c: return exponent;
             default: return source;
             }
         }
@@ -970,10 +1001,10 @@
         @Override
         public String toString() {
             String baseString = String.format(Locale.ROOT, "%." + visibleDecimalDigitCount + "f", source);
-            if (exponent == 0) {
-                return baseString;
-            } else {
+            if (exponent != 0) {
                 return baseString + "e" + exponent;
+            } else {
+                return baseString;
             }
         }
 
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 bca6fc9..b08f452 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
@@ -219,6 +219,37 @@
                 new FixedDecimal(2.0, 1));
     }
 
+    /**
+     * This test is for the support of X.YcZ compactnotation of numbers in
+     * the plural sample string.
+     */
+    @Test
+    public void testSamplesWithCompactNotation() {
+        String description = "one: i = 0,1 @integer 0, 1, 1c5 @decimal 0.0~1.5, 1.1c5; "
+                + "many: c = 0 and i != 0 and i % 1000000 = 0 and v = 0 or c != 0..5"
+                + " @integer 1000000, 2c6, 3c6, 4c6, 5c6, 6c6, 7c6, … @decimal 2.1c6, 3.1c6, 4.1c6, 5.1c6, 6.1c6, 7.1c6, …; "
+                + "other:  @integer 2~17, 100, 1000, 10000, 100000, 2c5, 3c5, 4c5, 5c5, 6c5, 7c5, …"
+                + " @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, …"
+                ;
+        // Creating the PluralRules object means being able to parse numbers
+        // like 1c5 and 1.1c5.
+        // 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));
+    }
+
     public void checkOldSamples(String description, PluralRules rules, String keyword, SampleType sampleType,
             Double... expected) {
         Collection<Double> oldSamples = rules.getSamples(keyword, sampleType);
@@ -713,7 +744,7 @@
         }
         for (ULocale locale : uniqueRuleSet) {
             if (locale.getLanguage().equals("fr") &&
-                    logKnownIssue("21299", "PluralRules::getSamples cannot distinguish 1e5 from 100000")) {
+                    logKnownIssue("21322", "PluralRules::getSamples cannot distinguish 1e5 from 100000")) {
                 continue;
             }
             PluralRules rules = factory.forLocale(locale);
@@ -968,12 +999,61 @@
         }
     }
 
+    // For the time being, the compact notation exponent operand `c` is an alias
+    // for the scientific exponent operand `e` and compact notation.
+    @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 " +
+                "e != 0 .. 5;  other:  @integer 2~17, 100, 1000, 10000, 100000, 1000000, @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …");
+        ULocale locale = new ULocale("fr-FR");
 
+        Object[][] casesData = {
+                // unlocalized formatter skeleton, input, string output, plural rule keyword
+                {"",           0, "0", "one"},
+                {"scientific", 0, "0", "one"},
+
+                {"",           1, "1", "one"},
+                {"scientific", 1, "1", "one"},
+
+                {"",           2, "2", "other"},
+                {"scientific", 2, "2", "other"},
+
+                {"",           1000000, "1 000 000", "many"},
+                {"scientific", 1000000, "1 million", "many"},
+
+                {"",           1000001, "1 000 001", "other"},
+                {"scientific", 1000001, "1 million", "many"},
+
+                {"",           120000, "1 200 000", "other"},
+                {"scientific", 1200000, "1,2 millions", "many"},
+
+                {"",           1200001, "1 200 001", "other"},
+                {"scientific", 1200001, "1,2 millions", "many"},
+
+                {"",           2000000, "2 000 000", "many"},
+                {"scientific", 2000000, "2 millions", "many"},
+        };
+
+        for (Object[] caseDatum : casesData) {
+            String skeleton = (String) caseDatum[0];
+            int input = (int) caseDatum[1];
+            // String expectedString = (String) caseDatum[2];
+            String expectPluralRuleKeyword = (String) caseDatum[3];
+
+            String actualPluralRuleKeyword =
+                    getPluralKeyword(rules, locale, input, skeleton);
+
+            assertEquals(
+                    String.format("PluralRules select %s: %d", skeleton, input),
+                    expectPluralRuleKeyword,
+                    actualPluralRuleKeyword);
+        }
+    }
 
     @Test
     public void testCompactDecimalPluralKeyword() {
-        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 " +
-                "e != 0 .. 5;  other:  @integer 2~17, 100, 1000, 10000, 100000, 1000000, @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …");
+        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 " +
+                "c != 0 .. 5;  other:  @integer 2~17, 100, 1000, 10000, 100000, 1000000, @decimal 2.0~3.5, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, …");
         ULocale locale = new ULocale("fr-FR");
 
         Object[][] casesData = {
diff --git a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/number/DecimalQuantityTest.java b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/number/DecimalQuantityTest.java
index 9131382..ec2d598 100644
--- a/icu4j/main/tests/core/src/com/ibm/icu/dev/test/number/DecimalQuantityTest.java
+++ b/icu4j/main/tests/core/src/com/ibm/icu/dev/test/number/DecimalQuantityTest.java
@@ -609,55 +609,57 @@
     }
 
     @Test
-    public void testCompactDecimalSuppressedExponent() {
+    public void testScientificAndCompactSuppressedExponent() {
         ULocale locale = new ULocale("fr-FR");
 
         Object[][] casesData = {
-                // unlocalized formatter skeleton, input, string output, long output, double output, BigDecimal output, plain string, suppressed exponent
-                {"",              123456789, "123 456 789",  123456789L, 123456789.0, new BigDecimal("123456789"), "123456789", 0},
-                {"compact-long",  123456789, "123 millions", 123000000L, 123000000.0, new BigDecimal("123000000"), "123000000", 6},
-                {"compact-short", 123456789, "123 M",        123000000L, 123000000.0, new BigDecimal("123000000"), "123000000", 6},
-                {"scientific",    123456789, "1,234568E8",   123456800L, 123456800.0, new BigDecimal("123456800"), "123456800", 8},
+                // unlocalized formatter skeleton, input, string output, long output,
+                // double output, BigDecimal output, plain string,
+                // suppressed scientific exponent, suppressed compact exponent
+                {"",              123456789, "123 456 789",  123456789L, 123456789.0, new BigDecimal("123456789"), "123456789", 0, 0},
+                {"compact-long",  123456789, "123 millions", 123000000L, 123000000.0, new BigDecimal("123000000"), "123000000", 6, 6},
+                {"compact-short", 123456789, "123 M",        123000000L, 123000000.0, new BigDecimal("123000000"), "123000000", 6, 6},
+                {"scientific",    123456789, "1,234568E8",   123456800L, 123456800.0, new BigDecimal("123456800"), "123456800", 8, 8},
 
-                {"",              1234567, "1 234 567",   1234567L, 1234567.0, new BigDecimal("1234567"), "1234567", 0},
-                {"compact-long",  1234567, "1,2 million", 1200000L, 1200000.0, new BigDecimal("1200000"), "1200000", 6},
-                {"compact-short", 1234567, "1,2 M",       1200000L, 1200000.0, new BigDecimal("1200000"), "1200000", 6},
-                {"scientific",    1234567, "1,234567E6",  1234567L, 1234567.0, new BigDecimal("1234567"), "1234567", 6},
+                {"",              1234567, "1 234 567",   1234567L, 1234567.0, new BigDecimal("1234567"), "1234567", 0, 0},
+                {"compact-long",  1234567, "1,2 million", 1200000L, 1200000.0, new BigDecimal("1200000"), "1200000", 6, 6},
+                {"compact-short", 1234567, "1,2 M",       1200000L, 1200000.0, new BigDecimal("1200000"), "1200000", 6, 6},
+                {"scientific",    1234567, "1,234567E6",  1234567L, 1234567.0, new BigDecimal("1234567"), "1234567", 6, 6},
 
-                {"",              123456, "123 456",   123456L, 123456.0, new BigDecimal("123456"), "123456", 0},
-                {"compact-long",  123456, "123 mille", 123000L, 123000.0, new BigDecimal("123000"), "123000", 3},
-                {"compact-short", 123456, "123 k",     123000L, 123000.0, new BigDecimal("123000"), "123000", 3},
-                {"scientific",    123456, "1,23456E5", 123456L, 123456.0, new BigDecimal("123456"), "123456", 5},
+                {"",              123456, "123 456",   123456L, 123456.0, new BigDecimal("123456"), "123456", 0, 0},
+                {"compact-long",  123456, "123 mille", 123000L, 123000.0, new BigDecimal("123000"), "123000", 3, 3},
+                {"compact-short", 123456, "123 k",     123000L, 123000.0, new BigDecimal("123000"), "123000", 3, 3},
+                {"scientific",    123456, "1,23456E5", 123456L, 123456.0, new BigDecimal("123456"), "123456", 5, 5},
 
-                {"",              123, "123",    123L, 123.0, new BigDecimal("123"), "123", 0},
-                {"compact-long",  123, "123",    123L, 123.0, new BigDecimal("123"), "123", 0},
-                {"compact-short", 123, "123",    123L, 123.0, new BigDecimal("123"), "123", 0},
-                {"scientific",    123, "1,23E2", 123L, 123.0, new BigDecimal("123"), "123", 2},
+                {"",              123, "123",    123L, 123.0, new BigDecimal("123"), "123", 0, 0},
+                {"compact-long",  123, "123",    123L, 123.0, new BigDecimal("123"), "123", 0, 0},
+                {"compact-short", 123, "123",    123L, 123.0, new BigDecimal("123"), "123", 0, 0},
+                {"scientific",    123, "1,23E2", 123L, 123.0, new BigDecimal("123"), "123", 2, 2},
 
-                {"",              1.2, "1,2",   1L, 1.2, new BigDecimal("1.2"), "1.2", 0},
-                {"compact-long",  1.2, "1,2",   1L, 1.2, new BigDecimal("1.2"), "1.2", 0},
-                {"compact-short", 1.2, "1,2",   1L, 1.2, new BigDecimal("1.2"), "1.2", 0},
-                {"scientific",    1.2, "1,2E0", 1L, 1.2, new BigDecimal("1.2"), "1.2", 0},
+                {"",              1.2, "1,2",   1L, 1.2, new BigDecimal("1.2"), "1.2", 0, 0},
+                {"compact-long",  1.2, "1,2",   1L, 1.2, new BigDecimal("1.2"), "1.2", 0, 0},
+                {"compact-short", 1.2, "1,2",   1L, 1.2, new BigDecimal("1.2"), "1.2", 0, 0},
+                {"scientific",    1.2, "1,2E0", 1L, 1.2, new BigDecimal("1.2"), "1.2", 0, 0},
 
-                {"",              0.12, "0,12",   0L, 0.12, new BigDecimal("0.12"), "0.12", 0},
-                {"compact-long",  0.12, "0,12",   0L, 0.12, new BigDecimal("0.12"), "0.12", 0},
-                {"compact-short", 0.12, "0,12",   0L, 0.12, new BigDecimal("0.12"), "0.12", 0},
-                {"scientific",    0.12, "1,2E-1", 0L, 0.12, new BigDecimal("0.12"), "0.12", -1},
+                {"",              0.12, "0,12",   0L, 0.12, new BigDecimal("0.12"), "0.12",  0,  0},
+                {"compact-long",  0.12, "0,12",   0L, 0.12, new BigDecimal("0.12"), "0.12",  0,  0},
+                {"compact-short", 0.12, "0,12",   0L, 0.12, new BigDecimal("0.12"), "0.12",  0,  0},
+                {"scientific",    0.12, "1,2E-1", 0L, 0.12, new BigDecimal("0.12"), "0.12", -1, -1},
 
-                {"",              0.012, "0,012",   0L, 0.012, new BigDecimal("0.012"), "0.012", 0},
-                {"compact-long",  0.012, "0,012",   0L, 0.012, new BigDecimal("0.012"), "0.012", 0},
-                {"compact-short", 0.012, "0,012",   0L, 0.012, new BigDecimal("0.012"), "0.012", 0},
-                {"scientific",    0.012, "1,2E-2",  0L, 0.012, new BigDecimal("0.012"), "0.012", -2},
+                {"",              0.012, "0,012",   0L, 0.012, new BigDecimal("0.012"), "0.012",  0,  0},
+                {"compact-long",  0.012, "0,012",   0L, 0.012, new BigDecimal("0.012"), "0.012",  0,  0},
+                {"compact-short", 0.012, "0,012",   0L, 0.012, new BigDecimal("0.012"), "0.012",  0,  0},
+                {"scientific",    0.012, "1,2E-2",  0L, 0.012, new BigDecimal("0.012"), "0.012", -2, -2},
 
-                {"",              999.9, "999,9",     999L,  999.9,  new BigDecimal("999.9"), "999.9", 0},
-                {"compact-long",  999.9, "1 millier", 1000L, 1000.0, new BigDecimal("1000"),  "1000",  3},
-                {"compact-short", 999.9, "1 k",       1000L, 1000.0, new BigDecimal("1000"),  "1000",  3},
-                {"scientific",    999.9, "9,999E2",   999L,  999.9,  new BigDecimal("999.9"), "999.9", 2},
+                {"",              999.9, "999,9",     999L,  999.9,  new BigDecimal("999.9"), "999.9", 0, 0},
+                {"compact-long",  999.9, "1 millier", 1000L, 1000.0, new BigDecimal("1000"),  "1000",  3, 3},
+                {"compact-short", 999.9, "1 k",       1000L, 1000.0, new BigDecimal("1000"),  "1000",  3, 3},
+                {"scientific",    999.9, "9,999E2",   999L,  999.9,  new BigDecimal("999.9"), "999.9", 2, 2},
 
-                {"",              1000.0, "1 000",     1000L, 1000.0, new BigDecimal("1000"), "1000", 0},
-                {"compact-long",  1000.0, "1 millier", 1000L, 1000.0, new BigDecimal("1000"), "1000", 3},
-                {"compact-short", 1000.0, "1 k",       1000L, 1000.0, new BigDecimal("1000"), "1000", 3},
-                {"scientific",    1000.0, "1E3",       1000L, 1000.0, new BigDecimal("1000"), "1000", 3},
+                {"",              1000.0, "1 000",     1000L, 1000.0, new BigDecimal("1000"), "1000", 0, 0},
+                {"compact-long",  1000.0, "1 millier", 1000L, 1000.0, new BigDecimal("1000"), "1000", 3, 3},
+                {"compact-short", 1000.0, "1 k",       1000L, 1000.0, new BigDecimal("1000"), "1000", 3, 3},
+                {"scientific",    1000.0, "1E3",       1000L, 1000.0, new BigDecimal("1000"), "1000", 3, 3},
         };
 
         for (Object[] caseDatum : casesData) {
@@ -673,7 +675,8 @@
             double expectedDouble = (double) caseDatum[4];
             BigDecimal expectedBigDecimal = (BigDecimal) caseDatum[5];
             String expectedPlainString = (String) caseDatum[6];
-            int expectedSuppressedExponent = (int) caseDatum[7];
+            int expectedSuppressedScientificExponent = (int) caseDatum[7];
+            int expectedSuppressedCompactExponent = (int) caseDatum[8];
 
             FormattedNumber fn = formatter.format(input);
             DecimalQuantity_DualStorageBCD dq = (DecimalQuantity_DualStorageBCD)
@@ -683,22 +686,23 @@
             double actualDouble = dq.toDouble();
             BigDecimal actualBigDecimal = dq.toBigDecimal();
             String actualPlainString = dq.toPlainString();
-            int actualSuppressedExponent = dq.getExponent();
+            int actualSuppressedScientificExponent = dq.getExponent();
+            int actualSuppressedCompactExponent = dq.getExponent();
 
             assertEquals(
                     String.format("formatted number %s toString: %f", skeleton, input),
                     expectedString,
                     actualString);
             assertEquals(
-                    String.format("compact decimal %s toLong: %f", skeleton, input),
+                    String.format("formatted number %s toLong: %f", skeleton, input),
                     expectedLong,
                     actualLong);
             assertDoubleEquals(
-                    String.format("compact decimal %s toDouble: %f", skeleton, input),
+                    String.format("formatted number %s toDouble: %f", skeleton, input),
                     expectedDouble,
                     actualDouble);
             assertBigDecimalEquals(
-                    String.format("compact decimal %s toBigDecimal: %f", skeleton, input),
+                    String.format("formatted number %s toBigDecimal: %f", skeleton, input),
                     expectedBigDecimal,
                     actualBigDecimal);
             assertEquals(
@@ -706,35 +710,45 @@
                     expectedPlainString,
                     actualPlainString);
             assertEquals(
-                    String.format("compact decimal %s suppressed exponent: %f", skeleton, input),
-                    expectedSuppressedExponent,
-                    actualSuppressedExponent);
+                    String.format("formatted number %s suppressed scientific exponent: %f", skeleton, input),
+                    expectedSuppressedScientificExponent,
+                    actualSuppressedScientificExponent);
+            assertEquals(
+                    String.format("formatted number %s suppressed compact exponent: %f", skeleton, input),
+                    expectedSuppressedCompactExponent,
+                    actualSuppressedCompactExponent);
 
             // test the actual computed values of the plural operands
 
             double expectedNOperand = expectedDouble;
             double expectedIOperand = expectedLong;
-            double expectedEOperand = expectedSuppressedExponent;
+            double expectedEOperand = expectedSuppressedScientificExponent;
+            double expectedCOperand = expectedSuppressedCompactExponent;
             double actualNOperand = dq.getPluralOperand(Operand.n);
             double actualIOperand = dq.getPluralOperand(Operand.i);
             double actualEOperand = dq.getPluralOperand(Operand.e);
+            double actualCOperand = dq.getPluralOperand(Operand.c);
 
             assertEquals(
                     String.format("formatted number %s toString: %s", skeleton, input),
                     expectedString,
                     actualString);
             assertDoubleEquals(
-                    String.format("compact decimal %s n operand: %f", skeleton, input),
+                    String.format("formatted number %s n operand: %f", skeleton, input),
                     expectedNOperand,
                     actualNOperand);
             assertDoubleEquals(
-                    String.format("compact decimal %s i operand: %f", skeleton, input),
+                    String.format("formatted number %s i operand: %f", skeleton, input),
                     expectedIOperand,
                     actualIOperand);
             assertDoubleEquals(
-                    String.format("compact decimal %s e operand: %f", skeleton, input),
+                    String.format("formatted number %s e operand: %f", skeleton, input),
                     expectedEOperand,
                     actualEOperand);
+            assertDoubleEquals(
+                    String.format("formatted number %s c operand: %f", skeleton, input),
+                    expectedCOperand,
+                    actualCOperand);
         }
     }
 
@@ -760,6 +774,7 @@
         double expectedVOperand = 2;
         double expectedWOperand = 1;
         double expectedEOperand = 3;
+        double expectedCOperand = 3;
         String expectedString = "1,23450 millier";
         double actualNOperand = dq.getPluralOperand(Operand.n);
         double actualIOperand = dq.getPluralOperand(Operand.i);
@@ -768,6 +783,7 @@
         double actualVOperand = dq.getPluralOperand(Operand.v);
         double actualWOperand = dq.getPluralOperand(Operand.w);
         double actualEOperand = dq.getPluralOperand(Operand.e);
+        double actualCOperand = dq.getPluralOperand(Operand.c);
         String actualString = fn.toString();
 
         assertDoubleEquals(
@@ -798,6 +814,10 @@
                 String.format("compact decimal fraction e operand: %f", inputVal),
                 expectedEOperand,
                 actualEOperand);
+        assertDoubleEquals(
+                String.format("compact decimal fraction c operand: %f", inputVal),
+                expectedCOperand,
+                actualCOperand);
         assertEquals(
                 String.format("compact decimal fraction toString: %f", inputVal),
                 expectedString,
@@ -815,11 +835,12 @@
 
         Object[][] casesData = {
                 // input, compact long string output,
-                // compact n operand, compact i operand, compact e operand
-                {123456789, "123 millions", 123000000.0, 123000000.0, 6.0},
-                {1234567,   "1,2 million",  1200000.0,   1200000.0,   6.0},
-                {123456,    "123 mille",    123000.0,    123000.0,    3.0},
-                {123,       "123",          123.0,       123.0,       0.0},
+                // compact n operand, compact i operand, compact e operand,
+                // compact c operand
+                {123456789, "123 millions", 123000000.0, 123000000.0, 6.0, 6.0},
+                {1234567,   "1,2 million",  1200000.0,   1200000.0,   6.0, 6.0},
+                {123456,    "123 mille",    123000.0,    123000.0,    3.0, 3.0},
+                {123,       "123",          123.0,       123.0,       0.0, 0.0},
         };
 
         for (Object[] caseDatum : casesData) {
@@ -828,11 +849,12 @@
             double expectedNOperand = (double) caseDatum[2];
             double expectedIOperand = (double) caseDatum[3];
             double expectedEOperand = (double) caseDatum[4];
+            double expectedCOperand = (double) caseDatum[5];
 
             FormattedNumber fnCompactScaled = compactScaled.format(input);
             DecimalQuantity_DualStorageBCD dqCompactScaled =
                     (DecimalQuantity_DualStorageBCD) fnCompactScaled.getFixedDecimal();
-            double compactScaledEOperand = dqCompactScaled.getPluralOperand(Operand.e);
+            double compactScaledCOperand = dqCompactScaled.getPluralOperand(Operand.c);
 
             FormattedNumber fnCompact = compactLong.format(input);
             DecimalQuantity_DualStorageBCD dqCompact =
@@ -841,6 +863,7 @@
             double compactNOperand = dqCompact.getPluralOperand(Operand.n);
             double compactIOperand = dqCompact.getPluralOperand(Operand.i);
             double compactEOperand = dqCompact.getPluralOperand(Operand.e);
+            double compactCOperand = dqCompact.getPluralOperand(Operand.c);
             assertEquals(
                     String.format("formatted number compactLong toString: %s", input),
                     expectedString,
@@ -857,14 +880,18 @@
                     String.format("compact decimal %d, e operand vs. expected", input),
                     expectedEOperand,
                     compactEOperand);
+            assertDoubleEquals(
+                    String.format("compact decimal %d, c operand vs. expected", input),
+                    expectedCOperand,
+                    compactCOperand);
 
             // By scaling by 10^3 in a locale that has words / compact notation
             // based on powers of 10^3, we guarantee that the suppressed
             // exponent will differ by 3.
             assertDoubleEquals(
-                    String.format("decimal %d, e operand for compact vs. compact scaled", input),
-                    compactEOperand + 3,
-                    compactScaledEOperand);
+                    String.format("decimal %d, c operand for compact vs. compact scaled", input),
+                    compactCOperand + 3,
+                    compactScaledCOperand);
         }
     }