Improve double implementation.

dart/frog/leg/lib/js_helper.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('js_helper');
 
 #import('coreimpl.dart');
 
 /**
   * Returns true if both arguments are numbers.
@@ skipping 64 matching lines @@
       return result - b;
     } else {
       return result + b;
     }
   }
   return UNINTERCEPTED(a % b);
 }
 
 tdiv(var a, var b) {
   if (checkNumbers(a, b, "num~/ expects a number as second operand.")) {
-    var tmp = a / b;
-    // TODO(ngeoffray): Use tmp.floor and tmp.ceil when
-    // we can handle them.
-    if (tmp < 0) {
-      return JS("num", @"Math.ceil($0)", tmp);
-    } else {
-      return JS("num", @"Math.floor($0)", tmp);
-    }
+    return (a / b).truncate();
   }
   return UNINTERCEPTED(a ~/ b);
 }
 
 eq(var a, var b) {
   if (JS("bool", @"typeof $0 === 'object'", a)) {
     if (JS_HAS_EQUALS(a)) {
       return UNINTERCEPTED(a == b) === true;
     } else {
       return JS("bool", @"$0 === $1", a, b);
@@ skipping 547 matching lines @@
   checkNull(receiver);
   if (!isJSArray(receiver)) return UNINTERCEPTED(receiver.sort(compare));
 
   DualPivotQuicksort.sort(receiver, compare);
 }
 
 checkNull(object) {
   if (object === null) throw new NullPointerException();
 }
 
+checkNum(value) {
+  checkNull(value);
+  if (value is !num) throw new IllegalArgumentException(value);
+  return value;
+}
+
 builtin$isNegative$0(receiver) {
   checkNull(receiver);
   if (receiver is num) {
     return (receiver === 0) ? (1 / receiver) < 0 : receiver < 0;
   } else {
     return UNINTERCEPTED(receiver.isNegative());
   }
 }
 
 builtin$isNaN$0(receiver) {
   checkNull(receiver);
   if (receiver is num) {
     return JS("bool", @"isNaN($0)", receiver);
   } else {
     return UNINTERCEPTED(receiver.isNegative());
   }
 }
 
 builtin$remainder$1(a, b) {
   checkNull(a);
   if (checkNumbers(a, b, "num.remainder expects a number as second operand.")) {
-    throw new NotImplementedException();
+    return JS("num", @"$0 % $1", a, b);
   } else {
     return UNINTERCEPTED(a.remainder(b));
   }
 }
 
 builtin$abs$0(receiver) {
   checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.abs());
 
-  throw new NotImplementedException();
+  return JS("num", @"Math.abs($0)", receiver);
 }
 
 builtin$toInt$0(receiver) {
   checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.toInt());
 
-  throw new NotImplementedException();
+  if (receiver.isNaN()) throw new BadNumberFormatException("NaN");
+
+  if (receiver.isInfinite()) throw new BadNumberFormatException("Infinity");
+
+  var truncated = receiver.truncate();
+  return JS("bool", @"$0 == -0.0", truncated) ? 0 : truncated;
 }
 
 builtin$ceil$0(receiver) {
   checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.ceil());
 
-  throw new NotImplementedException();
+  return JS("num", @"Math.ceil($0)", receiver);
 }
 
 builtin$floor$0(receiver) {
   checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.floor());
 
-  throw new NotImplementedException();
+  return JS("num", @"Math.floor($0)", receiver);
 }
 
 builtin$isInfinite$0(receiver) {
   checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.isInfinite());
 
-  throw new NotImplementedException();
+  return JS("bool", @"$0 == Infinity", receiver)
+    || JS("bool", @"$0 == -Infinity", receiver);
 }
 
 builtin$negate$0(receiver) {
   checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.negate());
 
-  throw new NotImplementedException();
+  return JS("num", @"-$0", receiver);
 }
 
 builtin$round$0(receiver) {
   checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.round());
 
-  throw new NotImplementedException();
+  return JS("num", @"Math.round($0)", receiver);
 }
 
 builtin$toDouble$0(receiver) {
   checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.toDouble());
 
-  throw new NotImplementedException();
+  // TODO(ahe): Just return receiver?
+  return JS("double", @"$0 + 0", receiver);

[kasperl, 2012/02/21 07:29:02]

If you're going for a ToNumber conversion here, maybe simply emit +$0?

[floitsch, 2012/02/21 13:34:02]

There is an is !num check just above. No need to do anything else. Just return
the receiver.
'+$0' is not free and we shouldn't need it here.

[ahe, 2012/04/20 10:51:03]

Follow-up in https://chromiumcodereview.appspot.com/10134004

 }
 
 builtin$truncate$0(receiver) {
   checkNull(receiver);
   if (receiver is !num) return UNINTERCEPTED(receiver.truncate());
 
-  throw new NotImplementedException();
+  return receiver < 0 ? receiver.ceil() : receiver.floor();
 }
 
-
 builtin$toStringAsFixed$1(receiver, fractionDigits) {
   checkNull(receiver);
   if (receiver is !num) {
     return UNINTERCEPTED(receiver.toStringAsFixed(fractionDigits));
   }
 
-  throw new NotImplementedException();
+  return JS("String", @"$0.toFixed($1)", receiver, fractionDigits);
 }
 
 builtin$allMatches$1(receiver, str) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.allMatches(str));
 
   throw new NotImplementedException();
 }
 
 builtin$concat$1(receiver, other) {
@@ skipping 85 matching lines @@
 
   throw new NotImplementedException();
 }
 
 builtin$trim$0(receiver) {
   checkNull(receiver);
   if (receiver is !String) return UNINTERCEPTED(receiver.trim());
 
   throw new NotImplementedException();
 }
+
+class MathNatives {
+  static int parseInt(String str) {
+    throw 'MathNatives.parseInt is not implemented';
+  }
+
+  static double parseDouble(String str) {
+    throw 'MathNatives.parseDouble is not implemented';
+  }
+
+  static double sqrt(num value)
+    => JS("double", @"Math.sqrt($0)", checkNum(value));
+
+  static double sin(num value)
+    => JS("double", @"Math.sin($0)", checkNum(value));
+
+  static double cos(num value)
+    => JS("double", @"Math.cos($0)", checkNum(value));
+
+  static double tan(num value)
+    => JS("double", @"Math.tan($0)", checkNum(value));
+
+  static double acos(num value)
+    => JS("double", @"Math.acos($0)", checkNum(value));
+
+  static double asin(num value)
+    => JS("double", @"Math.asin($0)", checkNum(value));
+
+  static double atan(num value)
+    => JS("double", @"Math.atan($0)", checkNum(value));
+
+  static double atan2(num a, num b)
+    => JS("double", @"Math.atan2($0)", checkNum(value));
+
+  static double exp(num value)
+    => JS("double", @"Math.exp($0)", checkNum(value));
+
+  static double log(num value)
+    => JS("double", @"Math.log($0)", checkNum(value));
+
+  static num pow(num value, num exponent) {
+    checkNum(value);
+    checkNum(exponent);
+    return JS("num", @"Math.pow($0, $1)", value, exponent);
+  }
+
+  static double random() => JS("double", "Math.random()");
+}