/**
  * Returns the pattern for this locale
  *
  * The pattern contains the placeholder "{{ widget }}" where the HTML tag should
  * be inserted
  */
 public function getPattern()
 {
     if (!$this->getOption('currency')) {
         return '{{ widget }}';
     }
     if (!isset(self::$patterns[$this->locale])) {
         self::$patterns[$this->locale] = array();
     }
     if (!isset(self::$patterns[$this->locale][$this->getOption('currency')])) {
         $format = new \NumberFormatter($this->locale, \NumberFormatter::CURRENCY);
         $pattern = $format->formatCurrency('123', $this->getOption('currency'));
         // the spacings between currency symbol and number are ignored, because
         // a single space leads to better readability in combination with input
         // fields
         // the regex also considers non-break spaces (0xC2 or 0xA0 in UTF-8)
         preg_match('/^([^\\s\\xc2\\xa0]*)[\\s\\xc2\\xa0]*123[,.]00[\\s\\xc2\\xa0]*([^\\s\\xc2\\xa0]*)$/', $pattern, $matches);
         if (!empty($matches[1])) {
             self::$patterns[$this->locale] = $matches[1] . ' {{ widget }}';
         } else {
             if (!empty($matches[2])) {
                 self::$patterns[$this->locale] = '{{ widget }} ' . $matches[2];
             } else {
                 self::$patterns[$this->locale] = '{{ widget }}';
             }
         }
     }
     return self::$patterns[$this->locale];
 }

 public function render(\Erebot\IntlInterface $translator)
 {
     $locale = $translator->getLocale(\Erebot\IntlInterface::LC_NUMERIC);
     $formatter = new \NumberFormatter($locale, \NumberFormatter::IGNORE);
     $result = (string) $formatter->format($this->value, \NumberFormatter::TYPE_INT32);
     return $result;
 }

 /**
  * Formatação de numero decimal
  * @param float/integer $value
  * @param integer $precision
  * @param string $language
  * @return float
  */
 public static function decimalNumber($value, $precision = 2, $language = 'pt_BR')
 {
     $valDecimal = new \NumberFormatter($language, \NumberFormatter::DECIMAL);
     $valDecimal->setAttribute(\NumberFormatter::MIN_FRACTION_DIGITS, $precision);
     $valDecimal->setAttribute(\NumberFormatter::MAX_FRACTION_DIGITS, $precision);
     return $valDecimal->format((double) $value, \NumberFormatter::TYPE_DOUBLE);
 }

 public function currencySymbolFunction($locale)
 {
     $locale = $locale == null ? \Locale::getDefault() : $locale;
     $formatter = new \NumberFormatter($locale, \NumberFormatter::CURRENCY);
     $symbol = $formatter->getSymbol(\NumberFormatter::CURRENCY_SYMBOL);
     return $symbol;
 }

 /**
  * @param FormView      $view
  * @param FormInterface $form
  * @param array         $options
  */
 public function buildView(FormView $view, FormInterface $form, array $options)
 {
     $dataType = self::DATA_INTEGER;
     if (isset($options['data_type'])) {
         $dataType = $options['data_type'];
     }
     $formatterOptions = array();
     switch ($dataType) {
         case self::PERCENT:
             $formatterOptions['decimals'] = 2;
             $formatterOptions['grouping'] = false;
             $formatterOptions['percent'] = true;
             break;
         case self::DATA_DECIMAL:
             $formatterOptions['decimals'] = 2;
             $formatterOptions['grouping'] = true;
             break;
         case self::DATA_INTEGER:
         default:
             $formatterOptions['decimals'] = 0;
             $formatterOptions['grouping'] = false;
     }
     $formatter = new \NumberFormatter(\Locale::getDefault(), \NumberFormatter::DECIMAL);
     $formatterOptions['orderSeparator'] = $formatterOptions['grouping'] ? $formatter->getSymbol(\NumberFormatter::GROUPING_SEPARATOR_SYMBOL) : '';
     $formatterOptions['decimalSeparator'] = $formatter->getSymbol(\NumberFormatter::DECIMAL_SEPARATOR_SYMBOL);
     $view->vars['formatter_options'] = array_merge($formatterOptions, $options['formatter_options']);
 }

 /**
  * Get price with currency only if data is not null
  * (if data is null and formatted by formatCurrency(), it will return 0)
  *
  * @param \NumberFormatter $numberFormatter
  * @param array            $price
  *
  * @return string
  */
 protected function getPrice(\NumberFormatter $numberFormatter, array $price)
 {
     if (!isset($price['data'])) {
         return '';
     }
     return $numberFormatter->formatCurrency($price['data'], $price['currency']);
 }

 public function notify(RequestVerifiedEvent $event)
 {
     $payment = $event->getPayment();
     $status = $event->getStatus()->getValue();
     switch ($status) {
         case GetHumanStatus::STATUS_AUTHORIZED:
         case GetHumanStatus::STATUS_CAPTURED:
         case GetHumanStatus::STATUS_REFUNDED:
             $this->repository->clearCart();
             $type = 'success';
             break;
         case GetHumanStatus::STATUS_CANCELED:
         case GetHumanStatus::STATUS_EXPIRED:
         case GetHumanStatus::STATUS_FAILED:
             $type = 'danger';
             break;
         case GetHumanStatus::STATUS_PENDING:
         case GetHumanStatus::STATUS_SUSPENDED:
             $this->repository->clearCart();
             $type = 'warning';
             break;
         case GetHumanStatus::STATUS_NEW:
         case GetHumanStatus::STATUS_UNKNOWN:
             $this->repository->clearCart();
             $type = 'info';
             break;
         default:
             throw new \RuntimeException('Unknown status ' . $status);
     }
     $formatter = new \NumberFormatter($this->translator->getLocale(), \NumberFormatter::CURRENCY);
     $this->session->getFlashBag()->add($type, $this->translator->trans('flash.payment.' . $type, ['%status%' => $this->translator->trans('meta.status.' . $status), '%amount%' => $formatter->formatCurrency($payment->getTotalAmount() / 100, $payment->getCurrencyCode())]));
 }

 public function currency($value, $currency = 'USD')
 {
     // use of NumberFormatter from extension package intl
     //
     $formatter = new \NumberFormatter('en_US', \NumberFormatter::CURRENCY);
     return $formatter->formatCurrency($value, $currency);
 }

 /**
  * \copydoc ::Erebot::Styling::VariableInterface::render()
  *
  * \note
  *      If no currency was passed to this class' constructor,
  *      the currency associated with the translator's locale
  *      is used.
  */
 public function render(\Erebot\IntlInterface $translator)
 {
     $locale = $translator->getLocale(\Erebot\IntlInterface::LC_MONETARY);
     $formatter = new \NumberFormatter($locale, \NumberFormatter::CURRENCY);
     $currency = $this->currency !== null ? $this->currency : $formatter->getSymbol(\NumberFormatter::INTL_CURRENCY_SYMBOL);
     return (string) $formatter->formatCurrency($this->value, $currency);
 }

 /**
  * Returns the pattern for this locale.
  *
  * The pattern contains the placeholder "{{ widget }}" where the HTML tag should
  * be inserted
  */
 protected static function getPattern($currency)
 {
     if (!$currency) {
         return '{{ widget }}';
     }
     $locale = \Locale::getDefault();
     if (!isset(self::$patterns[$locale])) {
         self::$patterns[$locale] = array();
     }
     if (!isset(self::$patterns[$locale][$currency])) {
         $format = new \NumberFormatter($locale, \NumberFormatter::CURRENCY);
         $pattern = $format->formatCurrency('123', $currency);
         // the spacings between currency symbol and number are ignored, because
         // a single space leads to better readability in combination with input
         // fields
         // the regex also considers non-break spaces (0xC2 or 0xA0 in UTF-8)
         preg_match('/^([^\\s\\xc2\\xa0]*)[\\s\\xc2\\xa0]*123(?:[,.]0+)?[\\s\\xc2\\xa0]*([^\\s\\xc2\\xa0]*)$/u', $pattern, $matches);
         if (!empty($matches[1])) {
             self::$patterns[$locale][$currency] = $matches[1] . ' {{ widget }}';
         } elseif (!empty($matches[2])) {
             self::$patterns[$locale][$currency] = '{{ widget }} ' . $matches[2];
         } else {
             self::$patterns[$locale][$currency] = '{{ widget }}';
         }
     }
     return self::$patterns[$locale][$currency];
 }

 /**
  * {@inheritdoc}
  */
 public function format($amount, $currency, $locale = 'en')
 {
     $formatter = new \NumberFormatter($locale, \NumberFormatter::CURRENCY);
     $result = $formatter->formatCurrency($amount / 100, $currency);
     Assert::notSame(false, $result, sprintf('The amount "%s" of type %s cannot be formatted to currency "%s".', $amount, gettype($amount), $currency));
     return $result;
 }

 public function bytesToHuman($bytes, $precision = 2)
 {
     $suffixes = ['bytes', 'kB', 'MB', 'GB', 'TB'];
     $formatter = new \NumberFormatter($this->translator->getLocale(), \NumberFormatter::PATTERN_DECIMAL, 0 === $precision ? '#' : '.' . str_repeat('#', $precision));
     $exp = floor(log($bytes, 1024));
     return $formatter->format($bytes / pow(1024, floor($exp))) . ' ' . $this->translator->trans($suffixes[$exp]);
 }

 /**
  * localized format for money with the NumberFormatter class in Currency mode
  * with currency symbol
  * like €1.234,56
  *
  * @param Money $money
  * @param null  $locale
  * @return bool|string
  */
 public function formatI18n(Money $money, $locale = null)
 {
     if ($locale === null) {
         $locale = $this->locale;
     }
     $formatter = new \NumberFormatter($locale, \NumberFormatter::CURRENCY);
     return $formatter->formatCurrency($money->getConvertedAmount(), $money->getCurrency()->getCurrencyCode());
 }

 /**
  * Retorna número por extenso
  * @param int $number 
  * @return string número por extenso
  */
 public function porExtenso($number)
 {
     if (!is_numeric($number)) {
         return false;
     }
     $fmt = new \NumberFormatter('br', \NumberFormatter::SPELLOUT);
     return $fmt->format($number);
 }

 /**
  * {@inheritDoc}
  */
 protected function getNumberFormatter()
 {
     $formatter = new \NumberFormatter(\Locale::getDefault(), \NumberFormatter::DECIMAL);
     if (null !== $this->precision) {
         $formatter->setAttribute(\NumberFormatter::FRACTION_DIGITS, $this->precision);
     }
     return $formatter;
 }

 /**
  * @todo This is the easiet way I could see to get a currency from a String such as 'GBP'
  * However it's not a very nice solution. This should probably be updated in the future.
  */
 public function currencySymbolFunction($currency = null, $locale = null)
 {
     $locale = $locale == null ? \Locale::getDefault() : $locale;
     $formatter = new \NumberFormatter($locale, \NumberFormatter::CURRENCY);
     $currency = $currency ?: $this->_defaultCurrency;
     $symbol = substr($formatter->formatCurrency(0, $currency), 0, -4);
     return $symbol;
 }

 /**
  * 数值转为中文拼读
  */
 public static function spell($number, $capital = false)
 {
     $formatter = new \NumberFormatter('zh_CN', \NumberFormatter::SPELLOUT);
     $sentence = $formatter->format($number);
     if ($capital) {
         $sentence = self::mbStrtr($sentence, self::$chars, self::$caps);
     }
     return $sentence;
 }

 public static function Repeat($times)
 {
     $list = new ArrayList();
     $formatter = new NumberFormatter('en-NZ', NumberFormatter::SPELLOUT);
     for ($i = 1; $i <= $times; $i++) {
         $list->push(array('Num' => $i, 'Word' => ucwords(strtolower($formatter->format($i)))));
     }
     return $list;
 }

 /**
  * @param  string|int|float|null                    $value
  * @param  Doctrine\DBAL\Platforms\AbstractPlatform $platform
  * @return mixed
  */
 public function convertToDatabaseValue($value, AbstractPlatform $platform)
 {
     if ($value === null) {
         return;
     }
     $formatter = new \NumberFormatter('pt_BR', \NumberFormatter::DECIMAL);
     $formatted = $formatter->parse($value);
     return $formatted;
 }

 public function render(\Erebot\IntlInterface $translator)
 {
     $locale = $translator->getLocale(\Erebot\IntlInterface::LC_NUMERIC);
     $formatter = new \NumberFormatter($locale, \NumberFormatter::DECIMAL);
     $formatter->setAttribute(\NumberFormatter::MIN_FRACTION_DIGITS, 0);
     $formatter->setAttribute(\NumberFormatter::MAX_FRACTION_DIGITS, 100);
     $result = (string) $formatter->format($this->value);
     return $result;
 }