Better documentation on Sets and Maps, and more.

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;
 
 /**
  * All numbers in dart are instances of [num].
  */
 abstract class num implements Comparable<num> {
   /** Addition operator. */
   num operator +(num other);
 
   /** Subtraction operator. */
   num operator -(num other);
 
   /** Multiplication operator. */
   num operator *(num other);
 
   /**
    * Euclidean modulo operator.
    *
    * Returns the remainder of the euclidean division. The euclidean division of
    * two integers `a` and `b` yields two integers `q` and `r` such that
-   * `a = b*q + r` and `0 <= r < |a|`.
+   * `a == b*q + r` and `0 <= r < a.abs()`.
    *
    * The euclidean division is only defined for integers, but can be easily
    * extended to work with doubles. In that case `r` may have a non-integer
    * value, but it still verifies `0 <= r < |a|`.
    *
    * 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);
 
   /**
    * 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.
    */
   int operator ~/(num other);
 
   /** Negate operator. */
   num operator -();
 
-  /**
-   * Return the remainder of the truncating division of `this` by [other].
+ /**
+   * Returns the remainder of the truncating division of `this` by [other].
    *
-   * The result `r` of this operation satisfies: `this = this ~/ other + r`.
+   * The result `r` of this operation satisfies: `this == this ~/ other + r`.
    * As a consequence the remainder `r` has the same sign as the dividend
    * `this`.
    */
   num remainder(num other);
 
   /** Relational less than operator. */
   bool operator <(num other);
 
   /** Relational less than or equal operator. */
   bool operator <=(num other);
@@ skipping 90 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();
 
   /**
-   * Converts [this] to a string representation with [fractionDigits] digits
-   * after the decimal point.
+   * Converts [this] to a [double] and then gives string representation with
+   * [fractionDigits] digits after the decimal point.
    *
    * The parameter [fractionDigits] must be an integer satisfying:
    * [:0 <= fractionDigits <= 20:].
    */
   String toStringAsFixed(int fractionDigits);
 
   /**
-   * Converts [this] to a string in decimal exponential notation with
-   * [fractionDigits] digits after the decimal point.
+   * Converts [this] to a [double] and then gives a string in decimal
+   * exponential notation with [fractionDigits] digits after the decimal point.
    *
    * If [fractionDigits] is given then it must be an integer satisfying:
    * [:0 <= fractionDigits <= 20:]. Without the parameter the returned string
    * uses the shortest number of digits that accurately represent [this].
    */
   String toStringAsExponential([int fractionDigits]);
 
   /**
-   * Converts [this] to a string representation with [precision] significant
-   * digits.
+   * Converts [this] to a double and gives a string representation with
+   * [precision] significant digits.
    *
    * The parameter [precision] must be an integer satisfying:
    * [:1 <= precision <= 21:].
    */
   String toStringAsPrecision(int precision);
-
-
 }