function getNumberFromShortened(sValue, oLocaleData, bIndianCurrency) {
		var sNumber,
			iFactor = 1,
			iKey = 10,
			aPluralCategories = oLocaleData.getPluralCategories(),
			sCldrFormat,
			bestResult = {number: undefined,
				factor: iFactor},
			fnGetFactor = function(sPlural, iKey, sStyle) {
				sCldrFormat = oLocaleData.getCompactDecimalPattern(sStyle, iKey.toString(), sPlural);

				if (sCldrFormat) {
					// Note: CLDR uses a non-breaking space and right-to-left mark u+200f in the format string
					sCldrFormat = FormatUtils.normalize(sCldrFormat, true);
					//formatString may contain '.' (quoted to differentiate them decimal separator)
					//which must be replaced with .
					sCldrFormat = sCldrFormat.replace(/'.'/g, ".");
					var match = sCldrFormat.match(rNumPlaceHolder);
					if (match) {
						// determine unit -> may be on the beginning e.g. for he
						var sValueSubString = match[0];
						var sUnit = sCldrFormat.replace(sValueSubString, "");
						if (!sUnit) {
							// If there's no scale defined in the pattern, skip the pattern
							return;
						}
						var iIndex = sValue.indexOf(sUnit);
						if (iIndex >= 0) {
							// parse the number part like every other number and then use the factor to get the real number
							sNumber = sValue.replace(sUnit, "");
							iFactor = iKey;
							// spanish numbers e.g. for MRD in format for "one" is "00 MRD" therefore factor needs to be adjusted
							// german numbers e.g. for Mrd. in format for "one" is "0 Mrd." therefore number does not need to be adjusted
							//    "0" => magnitude = key
							//    "00"  => magnitude = key / 10
							//    "000" => magnitude = key / 100
							iFactor *= Math.pow(10, 1 - sValueSubString.length);

							// if best result has no number yet or the new number is smaller that the current one set the new number as best result
							if (bestResult.number === undefined || sNumber.length < bestResult.number.length) {
								bestResult.number = sNumber;
								bestResult.factor = iFactor;
							}
						}
					}
				}
			};
		// iterate over all formats. Max:  100 000 000 000 000
		// find best result as format can have multiple matches:
		// * value can be contained one in another (de-DE): "Million" and "Millionen"
		// * end with each other (es-ES): "mil millones" and "millones"
		["long", "short"].forEach(function(sStyle) {
			iKey = 10;
			while (iKey < 1e15) {
				for (var i = 0; i < aPluralCategories.length; i++) {
					var sPluralCategory = aPluralCategories[i];
					fnGetFactor(sPluralCategory, iKey, sStyle);
				}
				iKey = iKey * 10;
			}
		});

		// For india currencies try lakhs/crores
		if (bIndianCurrency && !sNumber) {
			iKey = 10;
			while (iKey < 1e15) {
				for (var i = 0; i < aPluralCategories.length; i++) {
					var sPluralCategory = aPluralCategories[i];
					fnGetFactor(sPluralCategory, iKey, "short-indian");
				}
				iKey = iKey * 10;
			}
		}

		if (!sNumber) {
			return;
		}

		return bestResult;

	}
Gets the compact decimal or currency format for the given value and parameters.

@param {number|string} vValue
  The value for which the shortened format is determined
@param {object} oOptions
  The options used for getting the compact pattern
@param {int} [oOptions.precision = 2]
  The maximum number of digits in the formatted representation of the number
@param {"long"|"short"} oOptions.style
  The style of the compact format
@param {boolean} [oOptions.trailingCurrencyCode]
  Whether the currency code is formatted after the amount; only relevant if type "currency" is used
@param {"integer"|"float"|"currency"|"unit"|"percent"} oOptions.type
  The number format type
@param {boolean} [bIndianCurrency]
  Whether to use the Indian currency format; only relevant if type "currency" is used

@returns {object|undefined}
  The compact decimal or currency format for the given value; or <code>undefined</code> if neither the "short"
  or the "long" style is used, or if there is no compact format for the given parameters; the returned object
  contains the following properties:
  <ul>
    <li><code>decimals</code>: The number of decimals used in the compact format pattern</li>
    <li><code>formatString</code>: The compact format pattern to use</li>
    <li><code>key</code>: The power of ten matching the given value</li>
    <li><code>magnitude</code>: The divisor to get the compact number to show from the given value</li>
    <li><code>valueSubString</code>: The number part of the format pattern</li>
 </ul>

@private