Roll Observatory deps (charted -> ^0.3.0)

packages/charted/lib/core/scales.dart

 //
 // Copyright 2014 Google Inc. All rights reserved.
 //
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file or at
 // https://developers.google.com/open-source/licenses/bsd
 //
 
 /// Collection of scales for use by charts. The role of scales is to map the
 /// input domain to an output range.
@@ skipping 88 matching lines @@
   /// Maps each value on the domain to a band in the output range.  When a
   /// non-zero value is specified, [padding] space is left between each bands
   /// and [outerPadding] space is left unused at both ends of the range.
   void rangeBands(Iterable range, [double padding, double outerPadding]);
 
   /// Similar to [rangeBands] but ensures that each band starts and ends on a
   /// pixel boundary - helps avoid anti-aliasing artifacts.
   void rangeRoundBands(Iterable range, [double padding, double outerPadding]);
 }
 
-class RoundingFunctions extends Pair<RoundFunction,RoundFunction> {
+class RoundingFunctions extends Pair<RoundFunction, RoundFunction> {
   RoundingFunctions(RoundFunction floor, RoundFunction ceil)
       : super(floor, ceil);
 
   factory RoundingFunctions.defaults() =>
       new RoundingFunctions((x) => x.floor(), (x) => x.ceil());
 
   factory RoundingFunctions.identity() =>
       new RoundingFunctions(identityFunction, identityFunction);
 
   RoundFunction get floor => super.first;
   RoundFunction get ceil => super.last;
 }
 
 /// Namespacing container for utilities used by scales.
 abstract class ScaleUtils {
   /// Utility to return extent of sorted [values].
-  static Extent extent(Iterable values) =>
-      values.first < values.last
-          ? new Extent(values.first, values.last)
-          : new Extent(values.last, values.first);
+  static Extent extent(Iterable values) => values.first < values.last
+      ? new Extent(values.first, values.last)
+      : new Extent(values.last, values.first);
 
   /// Extends [values] to round numbers based on the given pair of
   /// floor and ceil functions.  [functions] is a pair of rounding function
   /// among which the first is used to compute floor of a number and the
   /// second for ceil of the number.
   static List nice(List values, RoundingFunctions functions) {
     if (values.last >= values.first) {
       values[0] = functions.floor(values.first);
       values[values.length - 1] = functions.ceil(values.last);
     } else {
       values[values.length - 1] = functions.floor(values.last);
       values[0] = functions.ceil(values.first);
     }
     return values;
   }
 
   static RoundingFunctions niceStep(num step) => (step > 0)
       ? new RoundingFunctions(
           (x) => (x < step) ? x.floor() : (x / step).floor() * step,
           (x) => (x < step) ? x.ceil() : (x / step).ceil() * step)
       : new RoundingFunctions.identity();
 
   /// Returns a Function that given a value x on the domain, returns the
   /// corresponding value on the range on a bilinear scale.
   ///
   /// @param domain         The domain of the scale.
   /// @param range          The range of the scale.
   /// @param uninterpolator The uninterpolator for domain values.
   /// @param interpolator   The interpolator for range values.
-  static Function bilinearScale(List domain, List range,
-      Function uninterpolator, Function interpolator) {
+  static Function bilinearScale(
+      List domain, List range, Function uninterpolator, Function interpolator) {
     var u = uninterpolator(domain[0], domain[1]),
         i = interpolator(range[0], range[1]);
     return (x) => i(u(x));
   }
 
   /// Returns a Function that given a value x on the domain, returns the
   /// corresponding value on the range on a polylinear scale.
   ///
   /// @param domain         The domain of the scale.
   /// @param range          The range of the scale.
   /// @param uninterpolator The uninterpolator for domain values.
   /// @param interpolator   The interpolator for range values.
-  static Function polylinearScale(List domain, List range,
-      Function uninterpolator, Function interpolator) {
-    var u = [],
-        i = [],
-        j = 0,
-        k = math.min(domain.length, range.length) - 1;
+  static Function polylinearScale(
+      List domain, List range, Function uninterpolator, Function interpolator) {
+    var u = [], i = [], j = 0, k = math.min(domain.length, range.length) - 1;
 
     // Handle descending domains.
     if (domain[k] < domain[0]) {
       domain = domain.reversed.toList();
       range = range.reversed.toList();
     }
 
     while (++j <= k) {
       u.add(uninterpolator(domain[j - 1], domain[j]));
       i.add(interpolator(range[j - 1], range[j]));
@@ skipping 36 matching lines @@
         hi = mid;
       } else {
         lo = mid + 1;
       }
     }
     return lo;
   }
 
   static Function bisect = bisectRight;
 }