Fraction class prototype and test (not to be committed).

sdk/lib/core/num.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.
 
 part of dart.core;
 
 /**
  * An integer or floating-point number.
  *
  * It is a compile-time error for any type other than [int] or [double]
@@ skipping 88 matching lines @@
    * extended to work with doubles. In that case `r` may have a non-integer
    * value, but it still verifies `0 <= r < |b|`.
    *
    * The sign of the returned value `r` is always positive.
    *
    * See [remainder] for the remainder of the truncating division.
    */
   num operator %(num other);
 
   /** Division operator. */
-  double operator /(num other);
+  num operator /(num other);
 
   /**
    * Truncating division operator.
    *
    * If either operand is a [double] then the result of the truncating division
    * `a ~/ b` is equivalent to `(a / b).truncate().toInt()`.
    *
    * If both operands are [int]s then `a ~/ b` performs the truncating
    * integer division.
    */
@@ skipping 184 matching lines @@
 
   /**
    * Return this [num] as a [double].
    *
    * If the number is not representable as a [double], an
    * approximation is returned. For numerically large integers, the
    * approximation may be infinite.
    */
   double toDouble();
 
+  /** Return this [num] as a [fraction].  */
+  fraction toFraction();
+
+  /** Return this [num] as a [fraction] with 100 as the
+   *  denominator. Precision loss may occur. Infinite and NaN
+   *  are not supported. */
+  fraction toPercent();
+
   /**
    * Returns a decimal-point string-representation of `this`.
    *
    * Converts `this` to a [double] before computing the string representation.
    *
    * If the absolute value of `this` is greater or equal to `10^21` then this
    * methods returns an exponential representation computed by
    * `this.toStringAsExponential()`. Otherwise the result
    * is the closest string representation with exactly [fractionDigits] digits
    * after the decimal point. If [fractionDigits] equals 0 then the decimal
@@ skipping 120 matching lines @@
     result = double.parse(source, _returnDoubleNull);
     if (result != null) return result;
     if (onError == null) throw new FormatException(input);
     return onError(input);
   }
 
   /** Helper functions for [parse]. */
   static int _returnIntNull(String _) => null;
   static double _returnDoubleNull(String _) => null;
 }