First iteration on number formatting

pkg/i18n/number_format.dart

+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#library("number_format");
+
+#import("intl.dart");
+#import("number_symbols.dart");
+#import("number_symbols_data.dart");
+
+class NumberFormat {
+  /** Variables to determine how number printing behaves. */
+  String _negativePrefix = '-';
+  String _positivePrefix = '';
+  String _negativeSuffix = '';
+  String _positiveSuffix = '';
+  /** How many numbers in a group when using punctuation to group digits in
+   * large numbers. e.g. in en_US: "1,000,000" has a grouping size of 3 digits
+   * between commas.
+   */
+  int _groupingSize = 3;
+  bool _decimalSeparatorAlwaysShown = false;
+  bool _useExponentialNotation = false;
+  int _maximumIntegerDigits = 40;
+  int _minimumIntegerDigits = 1;
+  int _maximumFractionDigits = 3; // invariant, >= minFractionDigits
+  int _minimumFractionDigits = 0;
+  int _minimumExponentDigits = 0;
+  bool _useSignForPositiveExponent = false;
+
+  /** The locale in which we print numbers. */
+  String _locale;
+
+  /** Caches the symbols used for our locale. */
+  NumberSymbols _symbols;
+
+  /**
+   * Transient internal state in which to build up the result of the format
+   * operation. We can have this be just an instance variable because Dart is
+   * single-threaded and unless we do an asynchronous operation in the process
+   * of formatting then there will only ever be one number being formatted
+   * at a time. In languages with threads we'd need to pass this on the stack.
+   */
+  StringBuffer _buffer;
+
+  /**
+   * Create a number format that prints in [newPattern] as it applies in
+   * [locale].
+   */
+  NumberFormat([String newPattern, String locale]) {
+    // TODO(alanknight): There will need to be some kind of async setup
+    // operations so as not to bring along every locale in every program.
+    _locale = Intl.verifiedLocale(locale);
+    _setPattern(newPattern);
+  }
+
+  /**
+   * Return the locale code in which we operate, e.g. 'en_US' or 'pt'.
+   */
+  String get locale() => _locale;
+
+  /**
+   * Return the symbols which are used in our locale. Cache them to avoid
+   * repeated lookup.
+   */
+  NumberSymbols get symbols() {
+    if (_symbols == null) _symbols = numberFormatSymbols[locale];
+    return _symbols;
+  }
+
+  // TODO(alanknight): Actually use the pattern and locale.
+  _setPattern(String x) {}
+
+  /**
+   * Format [number] according to our pattern and return the formatted string.
+   */
+  String format(num number) {
+    // TODO(alanknight): Do we have to do anything for printing numbers bidi?
+    // Or are they always printed left to right?
+    if (number.isNaN()) return symbols.NAN;
+    if (number.isInfinite()) return "${_signPrefix(number)}${symbols.INFINITY}";
+
+    _newBuffer();
+    _add(_signPrefix(number));
+    _formatNumber(number.abs());
+    _add(_signSuffix(number));
+
+    var result = _buffer.toString();
+    _buffer = null;
+    return result;
+  }
+
+  /**
+   * Format the main part of the number in the form dictated by the pattern.
+   */
+  void _formatNumber(num number) {
+    if (_useExponentialNotation) {
+      _formatExponential(number);
+    } else {
+      _formatFixed(number);
+    }
+  }
+
+  /** Format the number in exponential notation. */
+  _formatExponential(num number) {
+    if (number == 0.0) {
+      _formatFixed(number);
+      _formatExponent(0);
+      return;
+    }
+
+    var exponent = (Math.log(number) / Math.log(10)).floor();
+    var mantissa = number / Math.pow(10, exponent);
+
+    if (_minimumIntegerDigits < 1) {
+      exponent++;
+      mantissa /= 10;
+    } else {
+      exponent -= _minimumIntegerDigits - 1;
+      mantissa *= Math.pow(10, _minimumIntegerDigits - 1);
+    }
+    _formatFixed(number);
+    _formatExponent(exponent);
+  }
+
+  /**
+   * Format the exponent portion, e.g. in "1.3e-5" the "e-5".
+   */
+  void _formatExponent(num exponent) {
+    _add(symbols.EXP_SYMBOL);
+    if (exponent < 0) {
+      exponent = -exponent;
+      _add(symbols.MINUS_SIGN);
+    } else if (_useSignForPositiveExponent) {
+      _add(symbols.PLUS_SIGN);
+    }
+    _pad(_minimumExponentDigits, exponent.toString());
+  }
+
+  /**
+   * Format the basic number portion, inluding the fractional digits.
+   */
+  void _formatFixed(num number) {
+    // Round the number.
+    var power = Math.pow(10, _maximumFractionDigits);
+    var intValue = number.truncate().toInt();
+    var multiplied = (number * power).round();
+    var fracValue = (multiplied - intValue * power).floor().toInt();
+    var fractionPresent = _minimumFractionDigits > 0 || fracValue > 0;
+
+    // On dartj2s the integer part may be large enough to be a floating
+    // point value, in which case we reduce it until it is small enough
+    // to be printed as an integer and pad the remainder with zeros.
+    var paddingDigits = new StringBuffer();
+    while (intValue is! int) {
+      paddingDigits.add(symbols.ZERO_DIGIT);
+      intValue = (intValue / 10).toInt();
+    }
+    var integerDigits = "${intValue}${paddingDigits}".charCodes();
+    var digitLength = integerDigits.length;
+
+    if (_hasPrintableIntegerPart(intValue)) {
+      _pad(_minimumIntegerDigits - digitLength);
+      for (var i = 0; i < digitLength; i++) {
+        _addDigit(integerDigits[i]);
+        _group(digitLength, i);
+      }
+    } else if (!fractionPresent) {
+      // If neither fraction nor integer part exists, just print zero.
+      _addZero();
+    }
+
+    _decimalSeparator(fractionPresent);
+    _formatFractionPart((fracValue + power).toString());
+  }
+
+  /**
+   * Format the part after the decimal place in a fixed point number.
+   */
+  void _formatFractionPart(String fractionPart) {
+    var fractionCodes = fractionPart.charCodes();
+    var fractionLength = fractionPart.length;
+    while (fractionPart[fractionLength - 1] == '0' &&
+           fractionLength > _minimumFractionDigits + 1) {
+      fractionLength--;
+    }
+    for (var i = 1; i < fractionLength; i++) {
+      _addDigit(fractionCodes[i]);
+    }
+  }
+
+  /** Print the decimal separator if appropriate. */
+  void _decimalSeparator(bool fractionPresent) {
+    if (_decimalSeparatorAlwaysShown || fractionPresent) {
+      _add(symbols.DECIMAL_SEP);
+    }
+  }
+
+  /**
+   * Return true if we have a main integer part which is printable, either
+   * because we have digits left of the decimal point, or because there are
+   * a minimum number of printable digits greater than 1.
+   */
+  bool _hasPrintableIntegerPart(int intValue) {
+    return intValue > 0 || _minimumIntegerDigits > 0;
+  }
+
+  /**
+   * Create a new empty buffer. See comment on [_buffer] variable for why
+   * we have it as an instance variable rather than passing it on the stack.
+   */
+  void _newBuffer() { _buffer = new StringBuffer(); }
+
+  /** A group of methods that provide support for writing digits and other
+   * required characters into [_buffer] easily.
+   */
+  void _add(String x) { _buffer.add(x);}
+  void _addCharCode(int x) { _buffer.addCharCode(x); }
+  void _addZero() { _buffer.add(symbols.ZERO_DIGIT); }
+  void _addDigit(int x) { _buffer.addCharCode(_localeZero + x - _zero); }
+
+  /** Print padding up to [numberOfDigits] above what's included in [basic]. */
+  void _pad(int numberOfDigits, [String basic = '']) {
+    for (var i = 0; i < numberOfDigits - basic.length; i++) {
+      _add(symbols.ZERO_DIGIT);
+    }
+    for (var x in basic.charCodes()) {
+      _addDigit(x);
+    }
+  }
+
+  /**
+   * We are printing the digits of the number from left to right. We may need
+   * to print a thousands separator or other grouping character as appropriate
+   * to the locale. So we find how many places we are from the end of the number
+   * by subtracting our current [position] from the [totalLength] and print
+   * the separator character every [_groupingSize] digits.
+   */
+  void _group(int totalLength, int position) {
+    var distanceFromEnd = totalLength - position;
+    if (distanceFromEnd <=1 || _groupingSize <= 0) return;

[Emily Fortuna, 2012/08/16 00:10:24]

spacing:
distanceFromEnd <= 1 

[Alan Knight, 2012/08/16 16:41:50]

Done.

+    if (distanceFromEnd % _groupingSize == 1) {
+      _add(symbols.GROUP_SEP);
+    }
+  }
+
+  /** Returns the code point for the character '0'. */
+  int get _zero() => '0'.charCodes()[0];
+
+  /** Returns the code point for the locale's zero digit. */
+  int get _localeZero() => symbols.ZERO_DIGIT.charCodeAt(0);
+
+  /**
+   * Returns the prefix for [x] based on whether it's positive or negative.
+   * In en_US this would be '' and '-' respectively.
+   */
+  String _signPrefix(num x) {
+    return x.isNegative() ? _negativePrefix : _positivePrefix;
+  }
+
+  /**
+   * Returns the suffix for [x] based on wether it's positive or negative.
+   * In en_US there are no suffixes for positive or negative.
+   */
+  String _signSuffix(num x) {
+    return x.isNegative() ? _negativeSuffix : _positiveSuffix;
+  }
+}