diff --git a/.gitattributes b/.gitattributes
index d82af5085b6..f4b0a7d36b4 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -76,8 +76,10 @@ icu4c/source/extra/uconv/uconv.vcxproj -text
 icu4c/source/extra/uconv/uconv.vcxproj.filters -text
 icu4c/source/i18n/i18n.vcxproj -text
 icu4c/source/i18n/i18n.vcxproj.filters -text
+icu4c/source/i18n/scientificnumberformatter.cpp -text
 icu4c/source/i18n/shareddatefmt.h -text
 icu4c/source/i18n/shareddatetimepatterngenerator.h -text
+icu4c/source/i18n/unicode/scientificnumberformatter.h -text
 icu4c/source/io/io.vcxproj -text
 icu4c/source/io/io.vcxproj.filters -text
 icu4c/source/layout/layout.vcxproj -text
@@ -147,6 +149,7 @@ icu4c/source/test/depstest/icu-dependencies-mode.el -text
 icu4c/source/test/intltest/intltest.vcxproj -text
 icu4c/source/test/intltest/intltest.vcxproj.filters -text
 icu4c/source/test/intltest/quantityformattertest.cpp -text
+icu4c/source/test/intltest/scientificnumberformattertest.cpp -text
 icu4c/source/test/iotest/iotest.vcxproj -text
 icu4c/source/test/iotest/iotest.vcxproj.filters -text
 icu4c/source/test/letest/cletest.vcxproj -text
diff --git a/icu4c/source/i18n/Makefile.in b/icu4c/source/i18n/Makefile.in
index 3dc5b5ffdda..f2b89535b7e 100644
--- a/icu4c/source/i18n/Makefile.in
+++ b/icu4c/source/i18n/Makefile.in
@@ -94,7 +94,8 @@ uspoof.o uspoof_impl.o uspoof_build.o uspoof_conf.o uspoof_wsconf.o decfmtst.o s
 ztrans.o zrule.o vzone.o fphdlimp.o fpositer.o locdspnm.o \
 decNumber.o decContext.o alphaindex.o tznames.o tznames_impl.o tzgnames.o \
 tzfmt.o compactdecimalformat.o gender.o region.o scriptset.o identifier_info.o \
-uregion.o reldatefmt.o quantityformatter.o measunit.o filteredbrk.o scientificformathelper.o sharedbreakiterator.o
+uregion.o reldatefmt.o quantityformatter.o measunit.o filteredbrk.o \
+scientificformathelper.o sharedbreakiterator.o scientificnumberformatter.o
 
 ## Header files to install
 HEADERS = $(srcdir)/unicode/*.h
diff --git a/icu4c/source/i18n/scientificformathelper.cpp b/icu4c/source/i18n/scientificformathelper.cpp
index 5a3a2bc0c61..988f7f035cf 100644
--- a/icu4c/source/i18n/scientificformathelper.cpp
+++ b/icu4c/source/i18n/scientificformathelper.cpp
@@ -9,29 +9,18 @@
 #if !UCONFIG_NO_FORMATTING
 
 #include "unicode/scientificformathelper.h"
-#include "unicode/dcfmtsym.h"
-#include "unicode/fpositer.h"
-#include "unicode/utf16.h"
-#include "unicode/uniset.h"
+#include "unicode/scientificnumberformatter.h"
 #include "decfmtst.h"
 
 U_NAMESPACE_BEGIN
 
-static const UChar kSuperscriptDigits[] = {0x2070, 0xB9, 0xB2, 0xB3, 0x2074, 0x2075, 0x2076, 0x2077, 0x2078, 0x2079};
-
-static const UChar kSuperscriptPlusSign = 0x207A;
-static const UChar kSuperscriptMinusSign = 0x207B;
-
 ScientificFormatHelper::ScientificFormatHelper(
         const DecimalFormatSymbols &dfs, UErrorCode &status)
         : fPreExponent(), fStaticSets(NULL) {
     if (U_FAILURE(status)) {
         return;
     }
-    fPreExponent.append(dfs.getConstSymbol(
-            DecimalFormatSymbols::kExponentMultiplicationSymbol));
-    fPreExponent.append(dfs.getSymbol(DecimalFormatSymbols::kOneDigitSymbol));
-    fPreExponent.append(dfs.getSymbol(DecimalFormatSymbols::kZeroDigitSymbol));
+    ScientificNumberFormatter::getPreExponent(dfs, fPreExponent);
     fStaticSets = DecimalFormatStaticSets::getStaticSets(status);
 }
 
@@ -64,57 +53,14 @@ UnicodeString &ScientificFormatHelper::insertMarkup(
     if (U_FAILURE(status)) {
         return result;
     }
-    FieldPosition fp;
-    int32_t copyFromOffset = 0;
-    UBool exponentSymbolFieldPresent = FALSE;
-    UBool exponentFieldPresent = FALSE;
-    while (fpi.next(fp)) {
-        switch (fp.getField()) {
-        case UNUM_EXPONENT_SYMBOL_FIELD:
-            exponentSymbolFieldPresent = TRUE;
-            result.append(s, copyFromOffset, fp.getBeginIndex() - copyFromOffset);
-            copyFromOffset = fp.getEndIndex();
-            result.append(fPreExponent);
-            result.append(beginMarkup);
-            break;
-        case UNUM_EXPONENT_FIELD:
-            exponentFieldPresent = TRUE;
-            result.append(s, copyFromOffset, fp.getEndIndex() - copyFromOffset);
-            copyFromOffset = fp.getEndIndex();
-            result.append(endMarkup);
-            break;
-        default:
-            break;
-        }
-    }
-    if (!exponentSymbolFieldPresent || !exponentFieldPresent) {
-      status = U_ILLEGAL_ARGUMENT_ERROR;
-      return result;
-    }
-    result.append(s, copyFromOffset, s.length() - copyFromOffset);
-    return result;
-}
-
-static UBool copyAsSuperscript(
-        const UnicodeString &s,
-        int32_t beginIndex,
-        int32_t endIndex,
-        UnicodeString &result,
-        UErrorCode &status) {
-    if (U_FAILURE(status)) {
-        return FALSE;
-    }
-    for (int32_t i = beginIndex; i < endIndex;) {
-        UChar32 c = s.char32At(i);
-        int32_t digit = u_charDigitValue(c);
-        if (digit < 0) {
-            status = U_INVALID_CHAR_FOUND;
-            return FALSE;
-        }
-        result.append(kSuperscriptDigits[digit]);
-        i += U16_LENGTH(c);
-    }
-    return TRUE;
+    ScientificNumberFormatter::MarkupStyle style(beginMarkup, endMarkup);
+    return style.format(
+            s,
+            fpi,
+            fPreExponent,
+            *fStaticSets,
+            result,
+            status);
 }
 
 UnicodeString &ScientificFormatHelper::toSuperscriptExponentDigits(
@@ -125,55 +71,14 @@ UnicodeString &ScientificFormatHelper::toSuperscriptExponentDigits(
     if (U_FAILURE(status)) {
       return result;
     }
-    FieldPosition fp;
-    int32_t copyFromOffset = 0;
-    UBool exponentSymbolFieldPresent = FALSE;
-    UBool exponentFieldPresent = FALSE;
-    while (fpi.next(fp)) {
-        switch (fp.getField()) {
-        case UNUM_EXPONENT_SYMBOL_FIELD:
-            exponentSymbolFieldPresent = TRUE;
-            result.append(s, copyFromOffset, fp.getBeginIndex() - copyFromOffset);
-            copyFromOffset = fp.getEndIndex();
-            result.append(fPreExponent);
-            break;
-        case UNUM_EXPONENT_SIGN_FIELD:
-            {
-                int32_t beginIndex = fp.getBeginIndex();
-                int32_t endIndex = fp.getEndIndex();
-                UChar32 aChar = s.char32At(beginIndex);
-                if (fStaticSets->fMinusSigns->contains(aChar)) {
-                    result.append(s, copyFromOffset, beginIndex - copyFromOffset);
-                    result.append(kSuperscriptMinusSign);
-                } else if (fStaticSets->fPlusSigns->contains(aChar)) {
-                    result.append(s, copyFromOffset, beginIndex - copyFromOffset);
-                    result.append(kSuperscriptPlusSign);
-                } else {
-                    status = U_INVALID_CHAR_FOUND;
-                    return result;
-                }
-                copyFromOffset = endIndex;
-            }
-            break;
-        case UNUM_EXPONENT_FIELD:
-            exponentFieldPresent = TRUE;
-            result.append(s, copyFromOffset, fp.getBeginIndex() - copyFromOffset);
-            if (!copyAsSuperscript(
-                    s, fp.getBeginIndex(), fp.getEndIndex(), result, status)) {
-              return result;
-            }
-            copyFromOffset = fp.getEndIndex();
-            break;
-        default:
-            break;
-        }
-    }
-    if (!exponentSymbolFieldPresent || !exponentFieldPresent) {
-      status = U_ILLEGAL_ARGUMENT_ERROR;
-      return result;
-    }
-    result.append(s, copyFromOffset, s.length() - copyFromOffset);
-    return result;
+    ScientificNumberFormatter::SuperscriptStyle style;
+    return style.format(
+            s,
+            fpi,
+            fPreExponent,
+            *fStaticSets,
+            result,
+            status);
 }
 
 U_NAMESPACE_END
diff --git a/icu4c/source/i18n/scientificnumberformatter.cpp b/icu4c/source/i18n/scientificnumberformatter.cpp
new file mode 100644
index 00000000000..f53189b1b6a
--- /dev/null
+++ b/icu4c/source/i18n/scientificnumberformatter.cpp
@@ -0,0 +1,308 @@
+/*
+**********************************************************************
+* Copyright (c) 2014, International Business Machines
+* Corporation and others.  All Rights Reserved.
+**********************************************************************
+*/
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "unicode/scientificnumberformatter.h"
+#include "unicode/dcfmtsym.h"
+#include "unicode/fpositer.h"
+#include "unicode/utf16.h"
+#include "unicode/uniset.h"
+#include "decfmtst.h"
+#include "unicode/decimfmt.h"
+
+U_NAMESPACE_BEGIN
+
+static const UChar kSuperscriptDigits[] = {
+        0x2070,
+        0xB9,
+        0xB2,
+        0xB3,
+        0x2074,
+        0x2075,
+        0x2076,
+        0x2077,
+        0x2078,
+        0x2079};
+
+static const UChar kSuperscriptPlusSign = 0x207A;
+static const UChar kSuperscriptMinusSign = 0x207B;
+
+static UBool copyAsSuperscript(
+        const UnicodeString &s,
+        int32_t beginIndex,
+        int32_t endIndex,
+        UnicodeString &result,
+        UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return FALSE;
+    }
+    for (int32_t i = beginIndex; i < endIndex;) {
+        UChar32 c = s.char32At(i);
+        int32_t digit = u_charDigitValue(c);
+        if (digit < 0) {
+            status = U_INVALID_CHAR_FOUND;
+            return FALSE;
+        }
+        result.append(kSuperscriptDigits[digit]);
+        i += U16_LENGTH(c);
+    }
+    return TRUE;
+}
+
+ScientificNumberFormatter *ScientificNumberFormatter::createSuperscriptInstance(
+            DecimalFormat *fmtToAdopt, UErrorCode &status) {
+    return createInstance(fmtToAdopt, new SuperscriptStyle(), status);
+}
+
+ScientificNumberFormatter *ScientificNumberFormatter::createSuperscriptInstance(
+            const Locale &locale, UErrorCode &status) {
+    return createInstance(
+            static_cast<DecimalFormat *>(
+                    DecimalFormat::createScientificInstance(locale, status)),
+            new SuperscriptStyle(),
+            status);
+}
+
+ScientificNumberFormatter *ScientificNumberFormatter::createMarkupInstance(
+        DecimalFormat *fmtToAdopt,
+        const UnicodeString &beginMarkup,
+        const UnicodeString &endMarkup,
+        UErrorCode &status) {
+    return createInstance(
+            fmtToAdopt,
+            new MarkupStyle(beginMarkup, endMarkup),
+            status);
+}
+
+ScientificNumberFormatter *ScientificNumberFormatter::createMarkupInstance(
+        const Locale &locale,
+        const UnicodeString &beginMarkup,
+        const UnicodeString &endMarkup,
+        UErrorCode &status) {
+    return createInstance(
+            static_cast<DecimalFormat *>(
+                    DecimalFormat::createScientificInstance(locale, status)),
+            new MarkupStyle(beginMarkup, endMarkup),
+            status);
+}
+
+ScientificNumberFormatter *ScientificNumberFormatter::createInstance(
+            DecimalFormat *fmtToAdopt,
+            Style *styleToAdopt,
+            UErrorCode &status) {
+    LocalPointer<DecimalFormat> fmt(fmtToAdopt);
+    LocalPointer<Style> style(styleToAdopt);
+    if (U_FAILURE(status)) {
+        return NULL;
+    }
+    ScientificNumberFormatter *result =
+            new ScientificNumberFormatter(
+                    fmt.getAlias(),
+                    style.getAlias(),
+                    status);
+    if (result == NULL) {
+        status = U_MEMORY_ALLOCATION_ERROR;
+        return NULL;
+    }
+    fmt.orphan();
+    style.orphan();
+    if (U_FAILURE(status)) {
+        delete result;
+        return NULL;
+    }
+    return result;
+}
+
+ScientificNumberFormatter::Style *ScientificNumberFormatter::SuperscriptStyle::clone() const {
+    return new ScientificNumberFormatter::SuperscriptStyle(*this);
+}
+
+UnicodeString &ScientificNumberFormatter::SuperscriptStyle::format(
+        const UnicodeString &original,
+        FieldPositionIterator &fpi,
+        const UnicodeString &preExponent,
+        const DecimalFormatStaticSets &staticSets,
+        UnicodeString &appendTo,
+        UErrorCode &status) const {
+    if (U_FAILURE(status)) {
+        return appendTo;
+    }
+    FieldPosition fp;
+    int32_t copyFromOffset = 0;
+    while (fpi.next(fp)) {
+        switch (fp.getField()) {
+        case UNUM_EXPONENT_SYMBOL_FIELD:
+            appendTo.append(
+                    original,
+                    copyFromOffset,
+                    fp.getBeginIndex() - copyFromOffset);
+            copyFromOffset = fp.getEndIndex();
+            appendTo.append(preExponent);
+            break;
+        case UNUM_EXPONENT_SIGN_FIELD:
+            {
+                int32_t beginIndex = fp.getBeginIndex();
+                int32_t endIndex = fp.getEndIndex();
+                UChar32 aChar = original.char32At(beginIndex);
+                if (staticSets.fMinusSigns->contains(aChar)) {
+                    appendTo.append(
+                            original,
+                            copyFromOffset,
+                            beginIndex - copyFromOffset);
+                    appendTo.append(kSuperscriptMinusSign);
+                } else if (staticSets.fPlusSigns->contains(aChar)) {
+                    appendTo.append(
+                           original,
+                           copyFromOffset,
+                           beginIndex - copyFromOffset);
+                    appendTo.append(kSuperscriptPlusSign);
+                } else {
+                    status = U_INVALID_CHAR_FOUND;
+                    return appendTo;
+                }
+                copyFromOffset = endIndex;
+            }
+            break;
+        case UNUM_EXPONENT_FIELD:
+            appendTo.append(
+                    original,
+                    copyFromOffset,
+                    fp.getBeginIndex() - copyFromOffset);
+            if (!copyAsSuperscript(
+                    original,
+                    fp.getBeginIndex(),
+                    fp.getEndIndex(),
+                    appendTo,
+                    status)) {
+              return appendTo;
+            }
+            copyFromOffset = fp.getEndIndex();
+            break;
+        default:
+            break;
+        }
+    }
+    appendTo.append(
+            original, copyFromOffset, original.length() - copyFromOffset);
+    return appendTo;
+}
+
+ScientificNumberFormatter::Style *ScientificNumberFormatter::MarkupStyle::clone() const {
+    return new ScientificNumberFormatter::MarkupStyle(*this);
+}
+
+UnicodeString &ScientificNumberFormatter::MarkupStyle::format(
+        const UnicodeString &original,
+        FieldPositionIterator &fpi,
+        const UnicodeString &preExponent,
+        const DecimalFormatStaticSets &decimalFormatSets,
+        UnicodeString &appendTo,
+        UErrorCode &status) const {
+    if (U_FAILURE(status)) {
+        return appendTo;
+    }
+    FieldPosition fp;
+    int32_t copyFromOffset = 0;
+    while (fpi.next(fp)) {
+        switch (fp.getField()) {
+        case UNUM_EXPONENT_SYMBOL_FIELD:
+            appendTo.append(
+                    original,
+                    copyFromOffset,
+                    fp.getBeginIndex() - copyFromOffset);
+            copyFromOffset = fp.getEndIndex();
+            appendTo.append(preExponent);
+            appendTo.append(fBeginMarkup);
+            break;
+        case UNUM_EXPONENT_FIELD:
+            appendTo.append(
+                    original,
+                    copyFromOffset,
+                    fp.getEndIndex() - copyFromOffset);
+            copyFromOffset = fp.getEndIndex();
+            appendTo.append(fEndMarkup);
+            break;
+        default:
+            break;
+        }
+    }
+    appendTo.append(
+            original, copyFromOffset, original.length() - copyFromOffset);
+    return appendTo;
+}
+
+ScientificNumberFormatter::ScientificNumberFormatter(
+        DecimalFormat *fmtToAdopt, Style *styleToAdopt, UErrorCode &status)
+        : fPreExponent(),
+          fDecimalFormat(fmtToAdopt),
+          fStyle(styleToAdopt),
+          fStaticSets(NULL) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+    if (fDecimalFormat == NULL || fStyle == NULL) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return;
+    }
+    const DecimalFormatSymbols *sym = fDecimalFormat->getDecimalFormatSymbols();
+    if (sym == NULL) {
+        status = U_ILLEGAL_ARGUMENT_ERROR;
+        return;
+    }
+    getPreExponent(*sym, fPreExponent);
+    fStaticSets = DecimalFormatStaticSets::getStaticSets(status);
+}
+
+ScientificNumberFormatter::ScientificNumberFormatter(
+        const ScientificNumberFormatter &other)
+        : UObject(other),
+          fPreExponent(other.fPreExponent),
+          fDecimalFormat(NULL),
+          fStyle(NULL),
+          fStaticSets(other.fStaticSets) {
+    fDecimalFormat = static_cast<DecimalFormat *>(
+            other.fDecimalFormat->clone());
+    fStyle = other.fStyle->clone();
+}
+
+ScientificNumberFormatter::~ScientificNumberFormatter() {
+    delete fDecimalFormat;
+    delete fStyle;
+}
+
+UnicodeString &ScientificNumberFormatter::format(
+        const Formattable &number,
+        UnicodeString &appendTo,
+        UErrorCode &status) const {
+    if (U_FAILURE(status)) {
+        return appendTo;
+    }
+    UnicodeString original;
+    FieldPositionIterator fpi;
+    fDecimalFormat->format(number, original, &fpi, status);
+    return fStyle->format(
+            original,
+            fpi,
+            fPreExponent,
+            *fStaticSets,
+            appendTo,
+            status);
+}
+
+void ScientificNumberFormatter::getPreExponent(
+        const DecimalFormatSymbols &dfs, UnicodeString &preExponent) {
+    preExponent.append(dfs.getConstSymbol(
+            DecimalFormatSymbols::kExponentMultiplicationSymbol));
+    preExponent.append(dfs.getConstSymbol(DecimalFormatSymbols::kOneDigitSymbol));
+    preExponent.append(dfs.getConstSymbol(DecimalFormatSymbols::kZeroDigitSymbol));
+}
+
+U_NAMESPACE_END
+
+#endif /* !UCONFIG_NO_FORMATTING */
diff --git a/icu4c/source/i18n/unicode/scientificnumberformatter.h b/icu4c/source/i18n/unicode/scientificnumberformatter.h
new file mode 100644
index 00000000000..29e03032d53
--- /dev/null
+++ b/icu4c/source/i18n/unicode/scientificnumberformatter.h
@@ -0,0 +1,226 @@
+/*
+**********************************************************************
+* Copyright (c) 2014, International Business Machines
+* Corporation and others.  All Rights Reserved.
+**********************************************************************
+*/
+#ifndef SCINUMBERFORMATTER_H
+#define SCINUMBERFORMATTER_H
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#ifndef U_HIDE_DRAFT_API
+
+#include "unicode/unistr.h"
+
+/**
+ * \file 
+ * \brief C++ API: Formats in scientific notation.
+ */
+
+U_NAMESPACE_BEGIN
+
+class FieldPositionIterator;
+class DecimalFormatStaticSets;
+class DecimalFormatSymbols;
+class DecimalFormat;
+class Formattable;
+
+/**
+ * A formatter that formats numbers in user-friendly scientific notation.
+ *
+ * Sample code:
+ * <pre>
+ * UErrorCode status = U_ZERO_ERROR;
+ * LocalPointer<ScientificNumberFormatter> fmt(
+ *         ScientificNumberFormatter::createMarkupInstance(
+ *                 "en", "<sup>", "</sup>", status));
+ * if (U_FAILURE(status)) {
+ *     return;
+ * }
+ * UnicodeString appendTo;
+ * // appendTo = "1.23456x10<sup>-78</sup>"
+ * fmt->format(1.23456e-78, appendTo, status);
+ * </pre>
+ *
+ * @draft ICU 55
+ */
+class U_I18N_API ScientificNumberFormatter : public UObject {
+public:
+
+    /**
+     * Creates a ScientificNumberFormatter instance that uses
+     * superscript characters for exponents.
+     * @param fmtToAdopt The DecimalFormat which must be configured for
+     *   scientific notation.
+     * @param status error returned here.
+     * @return The new ScientificNumberFormatter instance.
+     *
+     * @draft ICU 55
+     */
+    static ScientificNumberFormatter *createSuperscriptInstance(
+            DecimalFormat *fmtToAdopt, UErrorCode &status);
+
+    /**
+     * Creates a ScientificNumberFormatter instance that uses
+     * superscript characters for exponents for this locale.
+     * @param locale The locale
+     * @param status error returned here.
+     * @return The ScientificNumberFormatter instance.
+     *
+     * @draft ICU 55
+     */
+    static ScientificNumberFormatter *createSuperscriptInstance(
+            const Locale &locale, UErrorCode &status);
+
+
+    /**
+     * Creates a ScientificNumberFormatter instance that uses
+     * markup for exponents.
+     * @param fmtToAdopt The DecimalFormat which must be configured for
+     *   scientific notation.
+     * @param beginMarkup the markup to start superscript.
+     * @param endMarkup the markup to end superscript.
+     * @param status error returned here.
+     * @return The new ScientificNumberFormatter instance.
+     *
+     * @draft ICU 55
+     */
+    static ScientificNumberFormatter *createMarkupInstance(
+            DecimalFormat *fmtToAdopt,
+            const UnicodeString &beginMarkup,
+            const UnicodeString &endMarkup,
+            UErrorCode &status);
+
+    /**
+     * Creates a ScientificNumberFormatter instance that uses
+     * markup for exponents for this locale.
+     * @param locale The locale
+     * @param beginMarkup the markup to start superscript.
+     * @param endMarkup the markup to end superscript.
+     * @param status error returned here.
+     * @return The ScientificNumberFormatter instance.
+     *
+     * @draft ICU 55
+     */
+    static ScientificNumberFormatter *createMarkupInstance(
+            const Locale &locale,
+            const UnicodeString &beginMarkup,
+            const UnicodeString &endMarkup,
+            UErrorCode &status);
+
+
+    /**
+     * Returns a copy of this object. Caller must free returned copy.
+     * @draft ICU 55
+     */
+    ScientificNumberFormatter *clone() const {
+        return new ScientificNumberFormatter(*this);
+    }
+
+    /**
+     * Destructor.
+     * @draft ICU 55
+     */
+    virtual ~ScientificNumberFormatter();
+
+    /**
+     * Formats a number into user friendly scientific notation.
+     *
+     * @param number the number to format.
+     * @param appendTo formatted string appended here.
+     * @param status any error returned here.
+     * @return appendTo
+     *
+     * @draft ICU 55
+     */
+    UnicodeString &format(
+            const Formattable &number,
+            UnicodeString &appendTo,
+            UErrorCode &status) const;
+ private:
+    class U_I18N_API Style : public UObject {
+    public:
+        virtual Style *clone() const = 0;
+    protected:
+        virtual UnicodeString &format(
+                const UnicodeString &original,
+                FieldPositionIterator &fpi,
+                const UnicodeString &preExponent,
+                const DecimalFormatStaticSets &decimalFormatSets,
+                UnicodeString &appendTo,
+                UErrorCode &status) const = 0;
+    private:
+        friend class ScientificNumberFormatter;
+    };
+
+    class U_I18N_API SuperscriptStyle : public Style {
+    public:
+        virtual Style *clone() const;
+    protected:
+        virtual UnicodeString &format(
+                const UnicodeString &original,
+                FieldPositionIterator &fpi,
+                const UnicodeString &preExponent,
+                const DecimalFormatStaticSets &decimalFormatSets,
+                UnicodeString &appendTo,
+                UErrorCode &status) const;
+    private:
+        friend class ScientificFormatHelper;
+    };
+
+    class U_I18N_API MarkupStyle : public Style {
+    public:
+        MarkupStyle(
+                const UnicodeString &beginMarkup,
+                const UnicodeString &endMarkup)
+                : Style(),
+                  fBeginMarkup(beginMarkup),
+                  fEndMarkup(endMarkup) { }
+        virtual Style *clone() const;
+    protected:
+        virtual UnicodeString &format(
+                const UnicodeString &original,
+                FieldPositionIterator &fpi,
+                const UnicodeString &preExponent,
+                const DecimalFormatStaticSets &decimalFormatSets,
+                UnicodeString &appendTo,
+                UErrorCode &status) const;
+    private:
+        UnicodeString fBeginMarkup;
+        UnicodeString fEndMarkup;
+        friend class ScientificFormatHelper;
+    };
+
+    ScientificNumberFormatter(
+            DecimalFormat *fmtToAdopt,
+            Style *styleToAdopt,
+            UErrorCode &status);
+
+    ScientificNumberFormatter(const ScientificNumberFormatter &other);
+    ScientificNumberFormatter &operator=(const ScientificNumberFormatter &);
+
+    static void getPreExponent(
+            const DecimalFormatSymbols &dfs, UnicodeString &preExponent);
+
+    static ScientificNumberFormatter *createInstance(
+            DecimalFormat *fmtToAdopt,
+            Style *styleToAdopt,
+            UErrorCode &status);
+
+    UnicodeString fPreExponent;
+    DecimalFormat *fDecimalFormat;
+    Style *fStyle;
+    const DecimalFormatStaticSets *fStaticSets;
+
+    friend class ScientificFormatHelper;
+};
+
+U_NAMESPACE_END
+
+#endif /* U_HIDE_DRAFT_API */
+
+#endif /* !UCONFIG_NO_FORMATTING */
+#endif 
diff --git a/icu4c/source/test/intltest/Makefile.in b/icu4c/source/test/intltest/Makefile.in
index 0e2c3fc21c5..ac7b9a96412 100644
--- a/icu4c/source/test/intltest/Makefile.in
+++ b/icu4c/source/test/intltest/Makefile.in
@@ -57,7 +57,8 @@ uobjtest.o idnaref.o idnaconf.o nptrans.o punyref.o testidn.o testidna.o uts46te
 incaltst.o calcasts.o v32test.o uvectest.o textfile.o tokiter.o utxttest.o \
 windttst.o winnmtst.o winutil.o csdetest.o tzrulets.o tzoffloc.o tzfmttst.o ssearch.o dtifmtts.o \
 tufmtts.o itspoof.o simplethread.o bidiconf.o locnmtst.o dcfmtest.o alphaindextst.o listformattertest.o genderinfotest.o compactdecimalformattest.o regiontst.o \
-reldatefmttest.o simplepatternformattertest.o measfmttest.o scientificformathelpertest.o numfmtspectest.o unifiedcachetest.o quantityformattertest.o
+reldatefmttest.o simplepatternformattertest.o measfmttest.o scientificformathelpertest.o numfmtspectest.o unifiedcachetest.o quantityformattertest.o \
+scientificnumberformattertest.o
 
 DEPS = $(OBJECTS:.o=.d)
 
diff --git a/icu4c/source/test/intltest/itformat.cpp b/icu4c/source/test/intltest/itformat.cpp
index e8dc872c17b..4329a6bea16 100644
--- a/icu4c/source/test/intltest/itformat.cpp
+++ b/icu4c/source/test/intltest/itformat.cpp
@@ -67,6 +67,7 @@ extern IntlTest *createRelativeDateTimeFormatterTest();
 extern IntlTest *createMeasureFormatTest();
 extern IntlTest *createScientificFormatHelperTest();
 extern IntlTest *createNumberFormatSpecificationTest();
+extern IntlTest *createScientificNumberFormatterTest();
 
 #define TESTCLASS(id, TestClass)          \
     case id:                              \
@@ -201,6 +202,15 @@ void IntlTestFormat::runIndexedTest( int32_t index, UBool exec, const char* &nam
             callTest(*test, par);
           }
           break;
+       case 50:
+          name = "ScientificNumberFormatterTest";
+          if (exec) {
+            logln("ScientificNumberFormatterTest test---");
+            logln((UnicodeString)"");
+            LocalPointer<IntlTest> test(createScientificNumberFormatterTest());
+            callTest(*test, par);
+          }
+          break;
         default: name = ""; break; //needed to end loop
     }
     if (exec) {
diff --git a/icu4c/source/test/intltest/scientificformathelpertest.cpp b/icu4c/source/test/intltest/scientificformathelpertest.cpp
index dc6024921d0..ff163f98ded 100644
--- a/icu4c/source/test/intltest/scientificformathelpertest.cpp
+++ b/icu4c/source/test/intltest/scientificformathelpertest.cpp
@@ -158,9 +158,12 @@ void ScientificFormatHelperTest::TestFixedDecimalMarkup() {
     assertSuccess("", status);
     UnicodeString result;
     helper.insertMarkup(appendTo, fpositer, "<sup>", "</sup>", result, status);
-    if (status != U_ILLEGAL_ARGUMENT_ERROR) {
-        errln("Expected U_ILLEGAL_ARGUMENT_ERROR with fixed decimal number.");
-    }
+    const char *expected = "123,456";
+    assertEquals(
+            "",
+            UnicodeString(expected).unescape(),
+            result);
+    assertSuccess("", status);
 }
 
 void ScientificFormatHelperTest::TestFixedDecimalSuperscript() {
@@ -176,9 +179,12 @@ void ScientificFormatHelperTest::TestFixedDecimalSuperscript() {
     assertSuccess("", status);
     UnicodeString result;
     helper.toSuperscriptExponentDigits(appendTo, fpositer, result, status);
-    if (status != U_ILLEGAL_ARGUMENT_ERROR) {
-        errln("Expected U_ILLEGAL_ARGUMENT_ERROR with fixed decimal number.");
-    }
+    const char *expected = "123,456";
+    assertEquals(
+            "",
+            UnicodeString(expected).unescape(),
+            result);
+    assertSuccess("", status);
 }
 
 extern IntlTest *createScientificFormatHelperTest() {
diff --git a/icu4c/source/test/intltest/scientificnumberformattertest.cpp b/icu4c/source/test/intltest/scientificnumberformattertest.cpp
new file mode 100644
index 00000000000..5ec34c66bcf
--- /dev/null
+++ b/icu4c/source/test/intltest/scientificnumberformattertest.cpp
@@ -0,0 +1,218 @@
+/*
+*******************************************************************************
+* Copyright (C) 2014, International Business Machines Corporation and         *
+* others. All Rights Reserved.                                                *
+*******************************************************************************
+*
+* File SCINUMBERFORMATTERTEST.CPP
+*
+*******************************************************************************
+*/
+#include "unicode/utypes.h"
+
+#include "intltest.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "unicode/scientificnumberformatter.h"
+#include "unicode/numfmt.h"
+#include "unicode/decimfmt.h"
+#include "unicode/localpointer.h"
+
+class ScientificNumberFormatterTest : public IntlTest {
+public:
+    void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
+private:
+    void TestBasic();
+    void TestFarsi();
+    void TestPlusSignInExponentMarkup();
+    void TestPlusSignInExponentSuperscript();
+    void TestFixedDecimalMarkup();
+    void TestFixedDecimalSuperscript();
+};
+
+void ScientificNumberFormatterTest::runIndexedTest(
+        int32_t index, UBool exec, const char *&name, char *) {
+    if (exec) {
+        logln("TestSuite ScientificNumberFormatterTest: ");
+    }
+    TESTCASE_AUTO_BEGIN;
+    TESTCASE_AUTO(TestBasic);
+    TESTCASE_AUTO(TestFarsi);
+    TESTCASE_AUTO(TestPlusSignInExponentMarkup);
+    TESTCASE_AUTO(TestPlusSignInExponentSuperscript);
+    TESTCASE_AUTO(TestFixedDecimalMarkup);
+    TESTCASE_AUTO(TestFixedDecimalSuperscript);
+    TESTCASE_AUTO_END;
+}
+
+void ScientificNumberFormatterTest::TestBasic() {
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString prefix("String: ");
+    UnicodeString appendTo(prefix);
+    LocalPointer<ScientificNumberFormatter> fmt(
+            ScientificNumberFormatter::createMarkupInstance(
+                    "en" , "<sup>", "</sup>", status));
+    if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
+        return;
+    }
+    fmt->format(1.23456e-78, appendTo, status);
+    const char *expected = "String: 1.23456\\u00d710<sup>-78</sup>";
+    assertEquals(
+            "markup style",
+            UnicodeString(expected).unescape(),
+            appendTo);
+
+    // Test superscript style
+    fmt.adoptInstead(
+            ScientificNumberFormatter::createSuperscriptInstance(
+                    "en", status));
+    if (!assertSuccess("Can't create ScientificNumberFormatter2", status)) {
+        return;
+    }
+    appendTo = prefix;
+    fmt->format(1.23456e-78, appendTo, status);
+    expected = "String: 1.23456\\u00d710\\u207b\\u2077\\u2078";
+    assertEquals(
+            "superscript style",
+            UnicodeString(expected).unescape(),
+            appendTo);
+  
+    // Test clone
+    LocalPointer<ScientificNumberFormatter> fmt3(fmt->clone());
+    if (fmt3.isNull()) {
+       errln("Allocating clone failed.");
+       return;
+    }
+    appendTo = prefix;
+    fmt3->format(1.23456e-78, appendTo, status);
+    expected = "String: 1.23456\\u00d710\\u207b\\u2077\\u2078";
+    assertEquals(
+            "superscript style",
+            UnicodeString(expected).unescape(),
+            appendTo);
+    assertSuccess("", status);
+}
+
+void ScientificNumberFormatterTest::TestFarsi() {
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString prefix("String: ");
+    UnicodeString appendTo(prefix);
+    LocalPointer<ScientificNumberFormatter> fmt(
+            ScientificNumberFormatter::createMarkupInstance(
+                    "fa", "<sup>", "</sup>", status));
+    if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
+        return;
+    }
+    fmt->format(1.23456e-78, appendTo, status);
+    const char *expected = "String: \\u06F1\\u066B\\u06F2\\u06F3\\u06F4\\u06F5\\u06F6\\u00d7\\u06F1\\u06F0<sup>\\u200E\\u2212\\u06F7\\u06F8</sup>";
+    assertEquals(
+            "",
+            UnicodeString(expected).unescape(),
+            appendTo);
+    assertSuccess("", status);
+}
+
+void ScientificNumberFormatterTest::TestPlusSignInExponentMarkup() {
+    UErrorCode status = U_ZERO_ERROR;
+    LocalPointer<DecimalFormat> decfmt((DecimalFormat *) NumberFormat::createScientificInstance("en", status));
+    if (U_FAILURE(status)) {
+        dataerrln("Failed call NumberFormat::createScientificInstance(\"en\", status) - %s", u_errorName(status));
+        return;
+    }
+    decfmt->applyPattern("0.00E+0", status);
+    if (!assertSuccess("", status)) {
+        return;
+    }
+    UnicodeString appendTo;
+    LocalPointer<ScientificNumberFormatter> fmt(
+            ScientificNumberFormatter::createMarkupInstance(
+                    new DecimalFormat(*decfmt), "<sup>", "</sup>", status));
+    if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
+        return;
+    }
+    fmt->format(6.02e23, appendTo, status);
+    const char *expected = "6.02\\u00d710<sup>+23</sup>";
+    assertEquals(
+            "",
+            UnicodeString(expected).unescape(),
+            appendTo);
+    assertSuccess("", status);
+}
+
+void ScientificNumberFormatterTest::TestPlusSignInExponentSuperscript() {
+    UErrorCode status = U_ZERO_ERROR;
+    LocalPointer<DecimalFormat> decfmt((DecimalFormat *) NumberFormat::createScientificInstance("en", status));
+    if (U_FAILURE(status)) {
+        dataerrln("Failed call NumberFormat::createScientificInstance(\"en\", status) - %s", u_errorName(status));
+        return;
+    }
+    decfmt->applyPattern("0.00E+0", status);
+    if (!assertSuccess("", status)) {
+        return;
+    }
+    UnicodeString appendTo;
+    LocalPointer<ScientificNumberFormatter> fmt(
+            ScientificNumberFormatter::createSuperscriptInstance(
+                    new DecimalFormat(*decfmt), status));
+    if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
+        return;
+    }
+    fmt->format(6.02e23, appendTo, status);
+    const char *expected = "6.02\\u00d710\\u207a\\u00b2\\u00b3";
+    assertEquals(
+            "",
+            UnicodeString(expected).unescape(),
+            appendTo);
+    assertSuccess("", status);
+}
+
+void ScientificNumberFormatterTest::TestFixedDecimalMarkup() {
+    UErrorCode status = U_ZERO_ERROR;
+    LocalPointer<DecimalFormat> decfmt((DecimalFormat *) NumberFormat::createInstance("en", status));
+    if (assertSuccess("NumberFormat::createInstance", status, TRUE) == FALSE) {
+        return;
+    }
+    LocalPointer<ScientificNumberFormatter> fmt(
+            ScientificNumberFormatter::createMarkupInstance(
+                    new DecimalFormat(*decfmt), "<sup>", "</sup>", status));
+    if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
+        return;
+    }
+    UnicodeString appendTo;
+    fmt->format(123456.0, appendTo, status);
+    const char *expected = "123,456";
+    assertEquals(
+            "",
+            UnicodeString(expected).unescape(),
+            appendTo);
+    assertSuccess("", status);
+}
+
+void ScientificNumberFormatterTest::TestFixedDecimalSuperscript() {
+    UErrorCode status = U_ZERO_ERROR;
+    LocalPointer<DecimalFormat> decfmt((DecimalFormat *) NumberFormat::createInstance("en", status));
+    if (assertSuccess("NumberFormat::createInstance", status, TRUE) == FALSE) {
+        return;
+    }
+    LocalPointer<ScientificNumberFormatter> fmt(
+            ScientificNumberFormatter::createSuperscriptInstance(
+                    new DecimalFormat(*decfmt), status));
+    if (!assertSuccess("Can't create ScientificNumberFormatter", status)) {
+        return;
+    }
+    UnicodeString appendTo;
+    fmt->format(123456.0, appendTo, status);
+    const char *expected = "123,456";
+    assertEquals(
+            "",
+            UnicodeString(expected).unescape(),
+            appendTo);
+    assertSuccess("", status);
+}
+
+extern IntlTest *createScientificNumberFormatterTest() {
+    return new ScientificNumberFormatterTest();
+}
+
+#endif /* !UCONFIG_NO_FORMATTING */