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

runtime/lib/double.cc

 // Copyright (c) 2011, 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.
 
 #include "vm/bootstrap_natives.h"
 
 #include "platform/math.h"
 
 #include "vm/code_generator.h"  // DartModulo.
 #include "vm/dart_entry.h"
@@ skipping 11 matching lines @@
 DEFINE_NATIVE_ENTRY(Double_doubleFromInteger, 2) {
   ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull());
   const Integer& value = Integer::CheckedHandle(arguments->NativeArgAt(1));
   if (FLAG_trace_intrinsified_natives) {
     OS::Print("Double_doubleFromInteger %s\n", value.ToCString());
   }
   return Double::New(value.AsDoubleValue());
 }
 
 
+DEFINE_NATIVE_ENTRY(Double_doubleFromFraction, 2) {
+  const Integer& numerator = Integer::CheckedHandle(arguments->NativeArgAt(0));
+  const Integer& denominator =
+      Integer::CheckedHandle(arguments->NativeArgAt(1));
+  return Double::New(numerator.AsDoubleValue() / denominator.AsDoubleValue());
+}
+
+
 DEFINE_NATIVE_ENTRY(Double_add, 2) {
   double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value();
   GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1));
   double right = right_object.value();
   if (FLAG_trace_intrinsified_natives) {
     OS::Print("Double_add %f + %f\n", left, right);
   }
   return Double::New(left + right);
 }
 
@@ skipping 62 matching lines @@
   if (exponent == 0) {
     // The double fits in a Smi or Mint.
     return Integer::New(ival);
   }
   Integer& result = Integer::Handle();
   result = Bigint::NewFromShiftedInt64(ival, exponent);
   return result.AsValidInteger();
 }
 
 
+static void DoubleToFraction(
+    double val, const Array& fract, const char* error_msg) {
+  if (isinf(val) || isnan(val)) {
+    const Array& args = Array::Handle(Array::New(1));
+    args.SetAt(0, String::Handle(String::New(error_msg)));
+    Exceptions::ThrowByType(Exceptions::kUnsupported, args);
+  }
+  // TODO(regis): Convert inf and nan to fraction.
+  // Now that we have a C++ Fraction class, this call should return the
+  // fraction instance, rather than set the array elements.
+  DoubleInternals internals = DoubleInternals(val);
+  ASSERT(!internals.IsSpecial());  // Only Infinity and NaN are special.
+  uint64_t significand = internals.Significand();
+  intptr_t exponent = internals.Exponent();
+  Integer& denominator = Integer::Handle();
+  if (exponent < 0) {
+    if (exponent > -63) {
+      // The denominator fits in a Smi or Mint.
+      denominator = Integer::New(1LL << -exponent);
+    } else {
+      denominator = Bigint::NewFromShiftedInt64(1, -exponent);
+    }
+    exponent = 0;
+  } else {
+    denominator = Integer::New(1);
+    if (exponent <= 10) {
+      // A double significand has at most 53 bits. The following shift will
+      // hence not overflow, and yield an integer of at most 63 bits.
+      significand <<= exponent;
+      exponent = 0;
+    }
+  }
+  // A significand has at most 63 bits (after the shift above).
+  // The cast to int64_t is hence safe.
+  int64_t ival = static_cast<int64_t>(significand);
+  if (internals.Sign() < 0) {
+    ival = -ival;
+  }
+  Integer& numerator = Integer::Handle();
+  if (exponent == 0) {
+    // The numerator fits in a Smi or Mint.
+    numerator = Integer::New(ival);
+  } else {
+    numerator = Bigint::NewFromShiftedInt64(ival, exponent);
+    numerator = numerator.AsValidInteger();  // May fit in a Smi or Mint.
+  }
+  fract.SetAt(0, numerator);
+  fract.SetAt(1, denominator);
+}
+
+
 DEFINE_NATIVE_ENTRY(Double_trunc_div, 2) {
   double left = Double::CheckedHandle(arguments->NativeArgAt(0)).value();
   GET_NON_NULL_NATIVE_ARGUMENT(Double, right_object, arguments->NativeArgAt(1));
   double right = right_object.value();
   if (FLAG_trace_intrinsified_natives) {
     OS::Print("Double_trunc_div %f ~/ %f\n", left, right);
   }
   return DoubleToInteger(trunc(left / right),
                          "Result of truncating division is Infinity or NaN");
 }
@@ skipping 79 matching lines @@
 // MAC OSX math library produces old style cast warning.
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #endif
 
 DEFINE_NATIVE_ENTRY(Double_toInt, 1) {
   const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0));
   return DoubleToInteger(arg.value(), "Infinity or NaN toInt");
 }
 
 
+DEFINE_NATIVE_ENTRY(Double_toFraction, 2) {
+  const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0));
+  const Array& fract = Array::CheckedHandle(arguments->NativeArgAt(1));
+  ASSERT(fract.Length() == 2);
+  DoubleToFraction(arg.value(), fract, "Infinity or NaN toFraction");
+  return Object::null();  // Result in fract[0] and fract[1].
+}
+
+
 DEFINE_NATIVE_ENTRY(Double_parse, 3) {
   GET_NON_NULL_NATIVE_ARGUMENT(String, value, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Integer, startValue, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(Integer, endValue, arguments->NativeArgAt(2));
 
   const intptr_t start = startValue.AsTruncatedUint32Value();
   const intptr_t end = endValue.AsTruncatedUint32Value();
   const intptr_t len = value.Length();
 
   // Indices should be inside the string, and 0 <= start < end <= len.
@@ skipping 87 matching lines @@
 DEFINE_NATIVE_ENTRY(Double_flipSignBit, 1) {
   const Double& arg = Double::CheckedHandle(arguments->NativeArgAt(0));
   const double in_val = arg.value();
   const int64_t bits = bit_cast<int64_t, double>(in_val) ^ kSignBitDouble;
   return Double::New(bit_cast<double, int64_t>(bits));
 }
 
 // Add here only functions using/referring to old-style casts.
 
 }  // namespace dart