Update charted to 0.4.8 and roll

packages/charted/lib/core/scales/linear_scale.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
 //
 part of charted.core.scales;
 
 class LinearScale implements Scale {
   static const defaultDomain = const [0, 1];
   static const defaultRange = const [0, 1];
 
   bool _rounded = false;
   Iterable _domain = defaultDomain;
   Iterable _range = defaultRange;
 
   int _ticksCount = 5;
+  int _forcedTicksCount = -1;
+
   bool _clamp = false;
   bool _nice = false;
-
   Function _invert;
   Function _scale;
 
   LinearScale();
 
   LinearScale._clone(LinearScale source)
       : _domain = source._domain.toList(),
         _range = source._range.toList(),
         _ticksCount = source._ticksCount,
         _clamp = source._clamp,
         _nice = source._nice,
         _rounded = source._rounded {
     _reset();
   }
 
   void _reset({bool nice: false}) {
     if (nice) {
       _domain = ScaleUtils.nice(
           _domain, ScaleUtils.niceStep(_linearTickRange().step));
+    } else {
+      if (_forcedTicksCount > 0) {
+        var tickRange = _linearTickRange();
+        _domain = [tickRange.first, tickRange.last];
+      }
     }
 
     Function linear = math.min(_domain.length, _range.length) > 2
         ? ScaleUtils.polylinearScale
         : ScaleUtils.bilinearScale;
 
     Function uninterpolator = clamp ? uninterpolateClamp : uninterpolateNumber;
     InterpolatorGenerator interpolator;
     if (rounded) {
       interpolator = createRoundedNumberInterpolator;
@@ skipping 41 matching lines @@
     assert(value != null);
     if (value != null && _ticksCount != value) {
       _ticksCount = value;
       _reset();
     }
   }
 
   @override
   int get ticksCount => _ticksCount;
 
+  set forcedTicksCount(int value) {
+    _forcedTicksCount = value;
+    _reset(nice: false);
+  }
+
+  get forcedTicksCount => _forcedTicksCount;
+
   @override
   Iterable get ticks => _linearTickRange();
 
   @override
   set clamp(bool value) {
     assert(value != null);
     if (value != null && _clamp != value) {
       _clamp = value;
       _reset();
     }
@@ skipping 24 matching lines @@
   invert(value) => _invert(value);
 
   Range _linearTickRange([Extent extent]) {
     if (extent == null) {
       extent = ScaleUtils.extent(_domain);
     }
     var span = extent.max - extent.min;
     if (span == 0) {
       span = 1.0; // [span / _ticksCount] should never be equal zero.
     }
-    var step = math.pow(10, (math.log(span / _ticksCount) / math.LN10).floor());
-    var err = _ticksCount / span * step;
 
-    // Filter ticks to get closer to the desired count.
-    if (err <= .15) {
-      step *= 10;
-    } else if (err <= .35) {
-      step *= 5;
-    } else if (err <= .75) {
-      step *= 2;
+    var step;
+    if (_forcedTicksCount > 0) {
+      // Find the factor (in power of 10) for the max and min of the extent and
+      // round the max up and min down to make sure the domain of the scale is
+      // of nicely rounded number and it contains the original domain.  This way
+      // when forcing the ticks count at least the two ends of the scale would
+      // look nice and has a high chance of having the intermediate tick values
+      // to be nice.
+      var maxFactor = extent.max == 0 ? 1
+          : math.pow(10, (math.log((extent.max as num).abs() / forcedTicksCount)
+              / math.LN10).floor());
+      var max = (extent.max / maxFactor).ceil() * maxFactor;
+      var minFactor = extent.min == 0 ? 1
+          : math.pow(10, (math.log((extent.min as num).abs() / forcedTicksCount)
+              / math.LN10).floor());
+      var min = (extent.min / minFactor).floor() * minFactor;
+      step = (max - min) / forcedTicksCount;
+      return new Range(min, max + step * 0.5, step);
+    } else {
+
+      step = math.pow(10, (math.log(span / _ticksCount) / math.LN10).floor());
+      var err = _ticksCount / span * step;
+
+      // Filter ticks to get closer to the desired count.
+      if (err <= .15) {
+        step *= 10;
+      } else if (err <= .35) {
+        step *= 5;
+      } else if (err <= .75) {
+        step *= 2;
+      }
     }
 
     return new Range((extent.min / step).ceil() * step,
         (extent.max / step).floor() * step + step * 0.5, step);
   }
 
   @override
   FormatFunction createTickFormatter([String formatStr]) {
     int precision(value) {
       return -(math.log(value) / math.LN10 + .01).floor();
     }
     Range tickRange = _linearTickRange();
     if (formatStr == null) {
       formatStr = ".${precision(tickRange.step)}f";
     }
     NumberFormat formatter = new NumberFormat(new EnUsLocale());
     return formatter.format(formatStr);
   }
 
   @override
   LinearScale clone() => new LinearScale._clone(this);
 }