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

runtime/lib/double.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.
 
 class _Double implements double {
   factory _Double.fromInteger(int value)
       native "Double_doubleFromInteger";
 
+  factory _Double.fromFraction(fraction value) {
+    return _DoubleFromFraction(value._numerator, value._denominator);
+  }
+  static _Double _DoubleFromFraction(int numerator, int denominator)
+      native "Double_doubleFromFraction";
+
   Type get runtimeType => double;
 
   // TODO: Make a stared static method for hashCode and _identityHashCode
   //       when semantics are corrected as described in:
   //       https://github.com/dart-lang/sdk/issues/2884
   int get hashCode => (isNaN || isInfinite) ?  0 : toInt();
   int get _identityHashCode => (isNaN || isInfinite) ?  0 : toInt();
 
   double operator +(num other) {
     return _add(other.toDouble());
@@ skipping 31 matching lines @@
   double _remainder(double other) native "Double_remainder";
 
   double operator -() native "Double_flipSignBit";
 
   bool operator ==(other) {
     if (!(other is num)) return false;
     return _equal(other.toDouble());
   }
   bool _equal(double other) native "Double_equal";
   bool _equalToInteger(int other) native "Double_equalToInteger";
+  bool _equalToFraction(fraction other) => _equal(other.toDouble());
   bool operator <(num other) {
     return other > this;
   }
   bool operator >(num other) {
     return _greaterThan(other.toDouble());
   }
   bool _greaterThan(double other) native "Double_greaterThan";
   bool operator >=(num other) {
     return (this == other) || (this > other);
   }
@@ skipping 14 matching lines @@
   }
   double _moduloFromInteger(int other) {
     return new _Double.fromInteger(other)._modulo(this);
   }
   double _remainderFromInteger(int other) {
     return new _Double.fromInteger(other)._remainder(this);
   }
   bool _greaterThanFromInteger(int other)
       native "Double_greaterThanFromInteger";
 
+  double _addFromFraction(fraction other) {
+    return new _Double.fromFraction(other)._add(this);
+  }
+  double _subFromFraction(fraction other) {
+    return new _Double.fromFraction(other)._sub(this);
+  }
+  double _mulFromFraction(fraction other) {
+    return new _Double.fromFraction(other)._mul(this);
+  }
+  double _divFromFraction(fraction other) {
+    return new _Double.fromFraction(other)._div(this);
+  }
+  int _truncDivFromFraction(fraction other) {
+    return new _Double.fromFraction(other)._trunc_div(this);
+  }
+  double _moduloFromFraction(fraction other) {
+    return new _Double.fromFraction(other)._modulo(this);
+  }
+  double _remainderFromFraction(fraction other) {
+    return new _Double.fromFraction(other)._remainder(this);
+  }
+  bool _greaterThanFromFraction(fraction other) {
+    return new _Double.fromFraction(other)._greaterThan(this);
+  }
+
   bool get isNegative native "Double_getIsNegative";
   bool get isInfinite native "Double_getIsInfinite";
   bool get isNaN native "Double_getIsNaN";
   bool get isFinite => !isInfinite && !isNaN;  // Can be optimized.
 
   double abs() {
     // Handle negative 0.0.
     if (this == 0.0) return 0.0;
     return this < 0.0 ? -this : this;
   }
@@ skipping 25 matching lines @@
     if (lowerLimit.compareTo(upperLimit) > 0) {
       throw new ArgumentError(lowerLimit);
     }
     if (lowerLimit.isNaN) return lowerLimit;
     if (this.compareTo(lowerLimit) < 0) return lowerLimit;
     if (this.compareTo(upperLimit) > 0) return upperLimit;
     return this;
   }
 
   int toInt() native "Double_toInt";
-  num _toBigintOrDouble() { return this; }
+  num _toBigintIfInteger() { return this; }
+  num _toDoubleOrFraction() { return this; }
   double toDouble() { return this; }
 
+  fraction toFraction() {
+    var fract = new List(2);
+    _DoubleToFraction(fract);
+    return new _Fraction(fract[0], fract[1]);
+  }
+  void _DoubleToFraction(List fract) native "Double_toFraction";
+
+  fraction toPercent() {
+    return new _Fraction((this*100).toInt(), 100);
+  }
+
   static const int CACHE_SIZE_LOG2 = 3;
   static const int CACHE_LENGTH = 1 << (CACHE_SIZE_LOG2 + 1);
   static const int CACHE_MASK = CACHE_LENGTH - 1;
   // Each key (double) followed by its toString result.
   static final List _cache = new List(CACHE_LENGTH);
   static int _cacheEvictIndex = 0;
 
   String _toString() native "Double_toString";
 
   String toString() {
@@ skipping 119 matching lines @@
         return EQUAL;
       }
     } else if (isNaN) {
       return other.isNaN ? EQUAL : GREATER;
     } else {
       // Other is NaN.
       return LESS;
     }
   }
 }