Merge branch 'master' of https://github.com/flooey/dygraphs

[dygraphs.git] / dygraph.js

diff --git a/dygraph.js b/dygraph.js
index bbb3302..6bdb143 100644 (file)
--- a/dygraph.js
+++ b/dygraph.js
@@ -24,7 +24,6 @@
 
  If the 'errorBars' option is set in the constructor, the input should be of
  the form
 
  If the 'errorBars' option is set in the constructor, the input should be of
  the form

-

    Date,SeriesA,SeriesB,...
    YYYYMMDD,A1,sigmaA1,B1,sigmaB1,...
    YYYYMMDD,A2,sigmaA2,B2,sigmaB2,...
    Date,SeriesA,SeriesB,...
    YYYYMMDD,A1,sigmaA1,B1,sigmaB1,...
    YYYYMMDD,A2,sigmaA2,B2,sigmaB2,...


@@ -79,6 +78,11 @@ Dygraph.DEFAULT_WIDTH = 480;
 Dygraph.DEFAULT_HEIGHT = 320;
 Dygraph.AXIS_LINE_WIDTH = 0.3;
 
 Dygraph.DEFAULT_HEIGHT = 320;
 Dygraph.AXIS_LINE_WIDTH = 0.3;
 

+Dygraph.LOG_SCALE = 10;
+Dygraph.LN_TEN = Math.log(Dygraph.LOG_SCALE);
+Dygraph.log10 = function(x) {
+  return Math.log(x) / Dygraph.LN_TEN;
+}

 
 // Default attribute values.
 Dygraph.DEFAULT_ATTRS = {
 
 // Default attribute values.
 Dygraph.DEFAULT_ATTRS = {


@@ -96,9 +100,7 @@ Dygraph.DEFAULT_ATTRS = {
   labelsKMG2: false,
   showLabelsOnHighlight: true,
 
   labelsKMG2: false,
   showLabelsOnHighlight: true,
 

-  yValueFormatter: function(x, opt_numDigits) {
-    return x.toPrecision(opt_numDigits || 2);
-  },
+  yValueFormatter: function(x) { return Dygraph.round_(x, 2); },

 
   strokeWidth: 1.0,
 
 
   strokeWidth: 1.0,
 


@@ -116,7 +118,6 @@ Dygraph.DEFAULT_ATTRS = {
 
   delimiter: ',',
 
 
   delimiter: ',',
 

-  logScale: false,

   sigma: 2.0,
   errorBars: false,
   fractions: false,
   sigma: 2.0,
   errorBars: false,
   fractions: false,


@@ -196,7 +197,6 @@ Dygraph.prototype.__init__ = function(div, file, attrs) {
   this.wilsonInterval_ = attrs.wilsonInterval || true;
   this.is_initial_draw_ = true;
   this.annotations_ = [];
   this.wilsonInterval_ = attrs.wilsonInterval || true;
   this.is_initial_draw_ = true;
   this.annotations_ = [];

-  this.numDigits_ = 2;

 
   // Clear the div. This ensure that, if multiple dygraphs are passed the same
   // div, then only one will be drawn.
 
   // Clear the div. This ensure that, if multiple dygraphs are passed the same
   // div, then only one will be drawn.


@@ -306,7 +306,7 @@ Dygraph.prototype.error = function(message) {
 
 /**
  * Returns the current rolling period, as set by the user or an option.
 
 /**
  * Returns the current rolling period, as set by the user or an option.

- * @return {Number} The number of points in the rolling window
+ * @return {Number} The number of days in the rolling window

  */
 Dygraph.prototype.rollPeriod = function() {
   return this.rollPeriod_;
  */
 Dygraph.prototype.rollPeriod = function() {
   return this.rollPeriod_;


@@ -359,44 +359,152 @@ Dygraph.prototype.yAxisRanges = function() {
  * If specified, do this conversion for the coordinate system of a particular
  * axis. Uses the first axis by default.
  * Returns a two-element array: [X, Y]
  * If specified, do this conversion for the coordinate system of a particular
  * axis. Uses the first axis by default.
  * Returns a two-element array: [X, Y]

+ *
+ * Note: use toDomXCoord instead of toDomCoords(x, null) and use toDomYCoord
+ * instead of toDomCoords(null, y, axis).

  */
 Dygraph.prototype.toDomCoords = function(x, y, axis) {
  */
 Dygraph.prototype.toDomCoords = function(x, y, axis) {

-  var ret = [null, null];
+  return [ this.toDomXCoord(x), this.toDomYCoord(y, axis) ];
+};
+
+/**
+ * Convert from data x coordinates to canvas/div X coordinate.
+ * If specified, do this conversion for the coordinate system of a particular
+ * axis.
+ * Returns a single value or null if x is null.
+ */
+Dygraph.prototype.toDomXCoord = function(x) {
+  if (x == null) {
+    return null;
+  };
+

   var area = this.plotter_.area;
   var area = this.plotter_.area;

-  if (x !== null) {
-    var xRange = this.xAxisRange();
-    ret[0] = area.x + (x - xRange[0]) / (xRange[1] - xRange[0]) * area.w;
-  }
+  var xRange = this.xAxisRange();
+  return area.x + (x - xRange[0]) / (xRange[1] - xRange[0]) * area.w;
+}

 
 

-  if (y !== null) {
-    var yRange = this.yAxisRange(axis);
-    ret[1] = area.y + (yRange[1] - y) / (yRange[1] - yRange[0]) * area.h;
-  }
+/**
+ * Convert from data x coordinates to canvas/div Y coordinate and optional
+ * axis. Uses the first axis by default.
+ *
+ * returns a single value or null if y is null.
+ */
+Dygraph.prototype.toDomYCoord = function(y, axis) {
+  var pct = this.toPercentYCoord(y, axis);

 
 

-  return ret;
-};
+  if (pct == null) {
+    return null;
+  }
+  var area = this.plotter_.area;
+  return area.y + pct * area.h;
+}

 
 /**
  * Convert from canvas/div coords to data coordinates.
  * If specified, do this conversion for the coordinate system of a particular
  * axis. Uses the first axis by default.
 
 /**
  * Convert from canvas/div coords to data coordinates.
  * If specified, do this conversion for the coordinate system of a particular
  * axis. Uses the first axis by default.

- * Returns a two-element array: [X, Y]
+ * Returns a two-element array: [X, Y].
+ *
+ * Note: use toDataXCoord instead of toDataCoords(x, null) and use toDataYCoord
+ * instead of toDataCoords(null, y, axis).

  */
 Dygraph.prototype.toDataCoords = function(x, y, axis) {
  */
 Dygraph.prototype.toDataCoords = function(x, y, axis) {

-  var ret = [null, null];
+  return [ this.toDataXCoord(x), this.toDataYCoord(y, axis) ];
+};
+
+/**
+ * Convert from canvas/div x coordinate to data coordinate.
+ *
+ * If x is null, this returns null.
+ */
+Dygraph.prototype.toDataXCoord = function(x) {
+  if (x == null) {
+    return null;
+  }
+

   var area = this.plotter_.area;
   var area = this.plotter_.area;

-  if (x !== null) {
-    var xRange = this.xAxisRange();
-    ret[0] = xRange[0] + (x - area.x) / area.w * (xRange[1] - xRange[0]);
+  var xRange = this.xAxisRange();
+  return xRange[0] + (x - area.x) / area.w * (xRange[1] - xRange[0]);
+};
+
+/**
+ * Convert from canvas/div y coord to value.
+ *
+ * If y is null, this returns null.
+ * if axis is null, this uses the first axis.
+ */
+Dygraph.prototype.toDataYCoord = function(y, axis) {
+  if (y == null) {
+    return null;

   }
 
   }
 

-  if (y !== null) {
-    var yRange = this.yAxisRange(axis);
-    ret[1] = yRange[0] + (area.h - y) / area.h * (yRange[1] - yRange[0]);
+  var area = this.plotter_.area;
+  var yRange = this.yAxisRange(axis);
+
+  if (typeof(axis) == "undefined") axis = 0;
+  if (!this.axes_[axis].logscale) {
+    return yRange[0] + (area.h - y) / area.h * (yRange[1] - yRange[0]);
+  } else {
+    // Computing the inverse of toDomCoord.
+    var pct = (y - area.y) / area.h
+
+    // Computing the inverse of toPercentYCoord. The function was arrived at with
+    // the following steps:
+    //
+    // Original calcuation:
+    // pct = (logr1 - Dygraph.log10(y)) / (logr1 - Dygraph.log10(yRange[0]));
+    //
+    // Move denominator to both sides:
+    // pct * (logr1 - Dygraph.log10(yRange[0])) = logr1 - Dygraph.log10(y);
+    //
+    // subtract logr1, and take the negative value.
+    // logr1 - (pct * (logr1 - Dygraph.log10(yRange[0]))) = Dygraph.log10(y);
+    //
+    // Swap both sides of the equation, and we can compute the log of the
+    // return value. Which means we just need to use that as the exponent in
+    // e^exponent.
+    // Dygraph.log10(y) = logr1 - (pct * (logr1 - Dygraph.log10(yRange[0])));
+
+    var logr1 = Dygraph.log10(yRange[1]);
+    var exponent = logr1 - (pct * (logr1 - Dygraph.log10(yRange[0])));
+    var value = Math.pow(Dygraph.LOG_SCALE, exponent);
+    return value;
+  }
+};
+
+/**
+ * Converts a y for an axis to a percentage from the top to the
+ * bottom of the div.
+ *
+ * If the coordinate represents a value visible on the canvas, then
+ * the value will be between 0 and 1, where 0 is the top of the canvas.
+ * However, this method will return values outside the range, as
+ * values can fall outside the canvas.
+ *
+ * If y is null, this returns null.
+ * if axis is null, this uses the first axis.
+ */
+Dygraph.prototype.toPercentYCoord = function(y, axis) {
+  if (y == null) {
+    return null;

   }
   }

+  if (typeof(axis) == "undefined") axis = 0;

 
 

-  return ret;
-};
+  var area = this.plotter_.area;
+  var yRange = this.yAxisRange(axis);
+
+  var pct;
+  if (!this.axes_[axis].logscale) {
+    // yrange[1] - y is unit distance from the bottom.
+    // yrange[1] - yrange[0] is the scale of the range.
+    // (yRange[1] - y) / (yRange[1] - yRange[0]) is the % from the bottom.
+    pct = (yRange[1] - y) / (yRange[1] - yRange[0]);
+  } else {
+    var logr1 = Dygraph.log10(yRange[1]);
+    pct = (logr1 - Dygraph.log10(y)) / (logr1 - Dygraph.log10(yRange[0]));
+  }
+  return pct;
+}

 
 /**
  * Returns the number of columns (including the independent variable).
 
 /**
  * Returns the number of columns (including the independent variable).


@@ -801,22 +909,11 @@ Dygraph.prototype.dragGetY_ = function(e, context) {
 // panning behavior.
 //
 Dygraph.startPan = function(event, g, context) {
 // panning behavior.
 //
 Dygraph.startPan = function(event, g, context) {

-  // have to be zoomed in to pan.
-  // TODO(konigsberg): Let's loosen this zoom-to-pan restriction, also
-  // perhaps create panning boundaries? A more flexible pan would make it,
-  // ahem, 'pan-useful'.
-  var zoomedY = false;
-  for (var i = 0; i < g.axes_.length; i++) {
-    if (g.axes_[i].valueWindow || g.axes_[i].valueRange) {
-      zoomedY = true;
-      break;
-    }
-  }
-  if (!g.dateWindow_ && !zoomedY) return;
-

   context.isPanning = true;
   var xRange = g.xAxisRange();
   context.dateRange = xRange[1] - xRange[0];
   context.isPanning = true;
   var xRange = g.xAxisRange();
   context.dateRange = xRange[1] - xRange[0];

+  context.initialLeftmostDate = xRange[0];
+  context.xUnitsPerPixel = context.dateRange / (g.plotter_.area.w - 1);

 
   // Record the range of each y-axis at the start of the drag.
   // If any axis has a valueRange or valueWindow, then we want a 2D pan.
 
   // Record the range of each y-axis at the start of the drag.
   // If any axis has a valueRange or valueWindow, then we want a 2D pan.


@@ -824,15 +921,20 @@ Dygraph.startPan = function(event, g, context) {
   for (var i = 0; i < g.axes_.length; i++) {
     var axis = g.axes_[i];
     var yRange = g.yAxisRange(i);
   for (var i = 0; i < g.axes_.length; i++) {
     var axis = g.axes_[i];
     var yRange = g.yAxisRange(i);

-    axis.dragValueRange = yRange[1] - yRange[0];
-    var r = g.toDataCoords(null, context.dragStartY, i);
-    axis.draggingValue = r[1];
+    // TODO(konigsberg): These values should be in |context|.
+    // In log scale, initialTopValue, dragValueRange and unitsPerPixel are log scale.
+    if (axis.logscale) {
+      axis.initialTopValue = Dygraph.log10(yRange[1]);
+      axis.dragValueRange = Dygraph.log10(yRange[1]) - Dygraph.log10(yRange[0]);
+    } else {
+      axis.initialTopValue = yRange[1];
+      axis.dragValueRange = yRange[1] - yRange[0];
+    }
+    axis.unitsPerPixel = axis.dragValueRange / (g.plotter_.area.h - 1);
+
+    // While calculating axes, set 2dpan.

     if (axis.valueWindow || axis.valueRange) context.is2DPan = true;
   }
     if (axis.valueWindow || axis.valueRange) context.is2DPan = true;
   }

-
-  // TODO(konigsberg): Switch from all this math to toDataCoords?
-  // Seems to work for the dragging value.
-  context.draggingDate = (context.dragStartX / g.width_) * context.dateRange + xRange[0];

 };
 
 // Called in response to an interaction model operation that
 };
 
 // Called in response to an interaction model operation that


@@ -846,26 +948,29 @@ Dygraph.movePan = function(event, g, context) {
   context.dragEndX = g.dragGetX_(event, context);
   context.dragEndY = g.dragGetY_(event, context);
 
   context.dragEndX = g.dragGetX_(event, context);
   context.dragEndY = g.dragGetY_(event, context);
 

-  // TODO(danvk): update this comment
-  // Want to have it so that:
-  // 1. draggingDate appears at dragEndX, draggingValue appears at dragEndY.
-  // 2. daterange = (dateWindow_[1] - dateWindow_[0]) is unaltered.
-  // 3. draggingValue appears at dragEndY.
-  // 4. valueRange is unaltered.
-
-  var minDate = context.draggingDate - (context.dragEndX / g.width_) * context.dateRange;
+  var minDate = context.initialLeftmostDate -
+    (context.dragEndX - context.dragStartX) * context.xUnitsPerPixel;

   var maxDate = minDate + context.dateRange;
   g.dateWindow_ = [minDate, maxDate];
 
   // y-axis scaling is automatic unless this is a full 2D pan.
   if (context.is2DPan) {
     // Adjust each axis appropriately.
   var maxDate = minDate + context.dateRange;
   g.dateWindow_ = [minDate, maxDate];
 
   // y-axis scaling is automatic unless this is a full 2D pan.
   if (context.is2DPan) {
     // Adjust each axis appropriately.

-    var y_frac = context.dragEndY / g.height_;

     for (var i = 0; i < g.axes_.length; i++) {
       var axis = g.axes_[i];
     for (var i = 0; i < g.axes_.length; i++) {
       var axis = g.axes_[i];

-      var maxValue = axis.draggingValue + y_frac * axis.dragValueRange;
+
+      var pixelsDragged = context.dragEndY - context.dragStartY;
+      var unitsDragged = pixelsDragged * axis.unitsPerPixel;
+
+      // In log scale, maxValue and minValue are the logs of those values.
+      var maxValue = axis.initialTopValue + unitsDragged;

       var minValue = maxValue - axis.dragValueRange;
       var minValue = maxValue - axis.dragValueRange;

-      axis.valueWindow = [ minValue, maxValue ];
+      if (axis.logscale) {
+        axis.valueWindow = [ Math.pow(Dygraph.LOG_SCALE, minValue),
+                             Math.pow(Dygraph.LOG_SCALE, maxValue) ];
+      } else {
+        axis.valueWindow = [ minValue, maxValue ];
+      }

     }
   }
 
     }
   }
 


@@ -880,9 +985,12 @@ Dygraph.movePan = function(event, g, context) {
 // panning behavior.
 //
 Dygraph.endPan = function(event, g, context) {
 // panning behavior.
 //
 Dygraph.endPan = function(event, g, context) {

+  // TODO(konigsberg): Clear the context data from the axis.
+  // TODO(konigsberg): mouseup should just delete the
+  // context object, and mousedown should create a new one.

   context.isPanning = false;
   context.is2DPan = false;
   context.isPanning = false;
   context.is2DPan = false;

-  context.draggingDate = null;
+  context.initialLeftmostDate = null;

   context.dateRange = null;
   context.valueRange = null;
 }
   context.dateRange = null;
   context.valueRange = null;
 }


@@ -1058,12 +1166,12 @@ Dygraph.prototype.createDragInterface_ = function() {
     prevEndY: null,
     prevDragDirection: null,
 
     prevEndY: null,
     prevDragDirection: null,
 

-    // TODO(danvk): update this comment
-    // draggingDate and draggingValue represent the [date,value] point on the
-    // graph at which the mouse was pressed. As the mouse moves while panning,
-    // the viewport must pan so that the mouse position points to
-    // [draggingDate, draggingValue]
-    draggingDate: null,
+    // The value on the left side of the graph when a pan operation starts.
+    initialLeftmostDate: null,
+
+    // The number of units each pixel spans. (This won't be valid for log
+    // scales)
+    xUnitsPerPixel: null,

 
     // TODO(danvk): update this comment
     // The range in second/value units that the viewport encompasses during a
 
     // TODO(danvk): update this comment
     // The range in second/value units that the viewport encompasses during a


@@ -1194,10 +1302,8 @@ Dygraph.prototype.drawZoomRect_ = function(direction, startX, endX, startY, endY
 Dygraph.prototype.doZoomX_ = function(lowX, highX) {
   // Find the earliest and latest dates contained in this canvasx range.
   // Convert the call to date ranges of the raw data.
 Dygraph.prototype.doZoomX_ = function(lowX, highX) {
   // Find the earliest and latest dates contained in this canvasx range.
   // Convert the call to date ranges of the raw data.

-  var r = this.toDataCoords(lowX, null);
-  var minDate = r[0];
-  r = this.toDataCoords(highX, null);
-  var maxDate = r[0];
+  var minDate = this.toDataXCoord(lowX);
+  var maxDate = this.toDataXCoord(highX);

   this.doZoomXDates_(minDate, maxDate);
 };
 
   this.doZoomXDates_(minDate, maxDate);
 };
 


@@ -1233,10 +1339,10 @@ Dygraph.prototype.doZoomY_ = function(lowY, highY) {
   // coordinates increase as you go up the screen.
   var valueRanges = [];
   for (var i = 0; i < this.axes_.length; i++) {
   // coordinates increase as you go up the screen.
   var valueRanges = [];
   for (var i = 0; i < this.axes_.length; i++) {

-    var hi = this.toDataCoords(null, lowY, i);
-    var low = this.toDataCoords(null, highY, i);
-    this.axes_[i].valueWindow = [low[1], hi[1]];
-    valueRanges.push([low[1], hi[1]]);
+    var hi = this.toDataYCoord(lowY, i);
+    var low = this.toDataYCoord(highY, i);
+    this.axes_[i].valueWindow = [low, hi];
+    valueRanges.push([low, hi]);

   }
 
   this.drawGraph_();
   }
 
   this.drawGraph_();


@@ -1305,10 +1411,6 @@ Dygraph.prototype.mouseMove_ = function(event) {
     idx = i;
   }
   if (idx >= 0) lastx = points[idx].xval;
     idx = i;
   }
   if (idx >= 0) lastx = points[idx].xval;

-  // Check that you can really highlight the last day's data
-  var last = points[points.length-1];
-  if (last != null && canvasx > last.canvasx)
-    lastx = points[points.length-1].xval;

 
   // Extract the points we've selected
   this.selPoints_ = [];
 
   // Extract the points we've selected
   this.selPoints_ = [];


@@ -1409,7 +1511,7 @@ Dygraph.prototype.updateSelection_ = function() {
         }
         var point = this.selPoints_[i];
         var c = new RGBColor(this.plotter_.colors[point.name]);
         }
         var point = this.selPoints_[i];
         var c = new RGBColor(this.plotter_.colors[point.name]);

-        var yval = fmtFunc(point.yval, this.numDigits_ + 1);  // In tenths.
+        var yval = fmtFunc(point.yval);

         replace += " <b><font color='" + c.toHex() + "'>"
                 + point.name + "</font></b>:"
                 + yval;
         replace += " <b><font color='" + c.toHex() + "'>"
                 + point.name + "</font></b>:"
                 + yval;


@@ -1592,6 +1694,18 @@ Dygraph.dateString_ = function(date, self) {
 };
 
 /**
 };
 
 /**

+ * Round a number to the specified number of digits past the decimal point.
+ * @param {Number} num The number to round
+ * @param {Number} places The number of decimals to which to round
+ * @return {Number} The rounded number
+ * @private
+ */
+Dygraph.round_ = function(num, places) {
+  var shift = Math.pow(10, places);
+  return Math.round(num * shift)/shift;
+};
+
+/**

  * Fires when there's data available to be graphed.
  * @param {String} data Raw CSV data to be plotted
  * @private
  * Fires when there's data available to be graphed.
  * @param {String} data Raw CSV data to be plotted
  * @private


@@ -1620,12 +1734,8 @@ Dygraph.prototype.addXTicks_ = function() {
     endDate   = this.rawData_[this.rawData_.length - 1][0];
   }
 
     endDate   = this.rawData_[this.rawData_.length - 1][0];
   }
 

-  var ret = this.attr_('xTicker')(startDate, endDate, this);
-  if (ret.ticks !== undefined) {  // Used numericTicks()?
-    this.layout_.updateOptions({xTicks: ret.ticks});
-  } else {  // Used dateTicker() instead.
-    this.layout_.updateOptions({xTicks: ret});
-  }
+  var xTicks = this.attr_('xTicker')(startDate, endDate, this);
+  this.layout_.updateOptions({xTicks: xTicks});

 };
 
 // Time granularity enumeration
 };
 
 // Time granularity enumeration


@@ -1808,47 +1918,75 @@ Dygraph.dateTicker = function(startDate, endDate, self) {
   }
 };
 
   }
 };
 

-/**
- * Determine the number of significant figures in a Number up to the specified
- * precision.  Note that there is no way to determine if a trailing '0' is
- * significant or not, so by convention we return 1 for all of the following
- * inputs: 1, 1.0, 1.00, 1.000 etc.
- * @param {Number} x The input value.
- * @param {Number} opt_maxPrecision Optional maximum precision to consider.
- *                                  Default and maximum allowed value is 13.
- * @return {Number} The number of significant figures which is >= 1.
- */
-Dygraph.significantFigures = function(x, opt_maxPrecision) {
-  var precision = Math.max(opt_maxPrecision || 13, 13);
-
-  // Convert the number to it's exponential notation form and work backwards,
-  // ignoring the 'e+xx' bit.  This may seem like a hack, but doing a loop and
-  // dividing by 10 leads to roundoff errors.  By using toExponential(), we let
-  // the JavaScript interpreter handle the low level bits of the Number for us.
-  var s = x.toExponential(precision);
-  var ePos = s.lastIndexOf('e');  // -1 case handled by return below.
-
-  for (var i = ePos - 1; i >= 0; i--) {
-    if (s[i] == '.') {
-      // Got to the decimal place.  We'll call this 1 digit of precision because
-      // we can't know for sure how many trailing 0s are significant.
-      return 1;
-    } else if (s[i] != '0') {
-      // Found the first non-zero digit.  Return the number of characters
-      // except for the '.'.
-      return i;  // This is i - 1 + 1 (-1 is for '.', +1 is for 0 based index).
+// This is a list of human-friendly values at which to show tick marks on a log
+// scale. It is k * 10^n, where k=1..9 and n=-39..+39, so:
+// ..., 1, 2, 3, 4, 5, ..., 9, 10, 20, 30, ..., 90, 100, 200, 300, ...
+// NOTE: this assumes that Dygraph.LOG_SCALE = 10.
+Dygraph.PREFERRED_LOG_TICK_VALUES = function() {
+  var vals = [];
+  for (var power = -39; power <= 39; power++) {
+    var range = Math.pow(10, power);
+    for (var mult = 1; mult <= 9; mult++) {
+      var val = range * mult;
+      vals.push(val);

     }
   }
     }
   }

+  return vals;
+}();

 
 

-  // Occurs if toExponential() doesn't return a string containing 'e', which
-  // should never happen.
-  return 1;
+// val is the value to search for
+// arry is the value over which to search
+// if abs > 0, find the lowest entry greater than val
+// if abs < 0, find the highest entry less than val
+// if abs == 0, find the entry that equals val.
+// Currently does not work when val is outside the range of arry's values.
+Dygraph.binarySearch = function(val, arry, abs, low, high) {
+  if (low == null || high == null) {
+    low = 0;
+    high = arry.length - 1;
+  }
+  if (low > high) {
+    return -1;
+  }
+  if (abs == null) {
+    abs = 0;
+  }
+  var validIndex = function(idx) {
+    return idx >= 0 && idx < arry.length;
+  }
+  var mid = parseInt((low + high) / 2);
+  var element = arry[mid];
+  if (element == val) {
+    return mid;
+  }
+  if (element > val) {
+    if (abs > 0) {
+      // Accept if element > val, but also if prior element < val.
+      var idx = mid - 1;
+      if (validIndex(idx) && arry[idx] < val) {
+        return mid;
+      }
+    }
+    return Dygraph.binarySearch(val, arry, abs, low, mid - 1);
+  }
+  if (element < val) {
+    if (abs < 0) {
+      // Accept if element < val, but also if prior element > val.
+      var idx = mid + 1;
+      if (validIndex(idx) && arry[idx] > val) {
+        return mid;
+      }
+    }
+    return Dygraph.binarySearch(val, arry, abs, mid + 1, high);
+  }

 };
 
 /**
  * Add ticks when the x axis has numbers on it (instead of dates)
 };
 
 /**
  * Add ticks when the x axis has numbers on it (instead of dates)

- * @param {Number} startDate Start of the date window (millis since epoch)
- * @param {Number} endDate End of the date window (millis since epoch)
+ * TODO(konigsberg): Update comment.
+ *
+ * @param {Number} minV minimum value
+ * @param {Number} maxV maximum value

  * @param self
  * @param {function} attribute accessor function.
  * @return {Array.<Object>} Array of {label, value} tuples.
  * @param self
  * @param {function} attribute accessor function.
  * @return {Array.<Object>} Array of {label, value} tuples.


@@ -1863,46 +2001,92 @@ Dygraph.numericTicks = function(minV, maxV, self, axis_props, vals) {
   var ticks = [];
   if (vals) {
     for (var i = 0; i < vals.length; i++) {
   var ticks = [];
   if (vals) {
     for (var i = 0; i < vals.length; i++) {

-      ticks[i] = {v: vals[i]};
+      ticks.push({v: vals[i]});

     }
   } else {
     }
   } else {

-    // Basic idea:
-    // Try labels every 1, 2, 5, 10, 20, 50, 100, etc.
-    // Calculate the resulting tick spacing (i.e. this.height_ / nTicks).
-    // The first spacing greater than pixelsPerYLabel is what we use.
-    // TODO(danvk): version that works on a log scale.
-    if (attr("labelsKMG2")) {
-      var mults = [1, 2, 4, 8];
-    } else {
-      var mults = [1, 2, 5];
+    if (axis_props && attr("logscale")) {
+      var pixelsPerTick = attr('pixelsPerYLabel');
+      // NOTE(konigsberg): Dan, should self.height_ be self.plotter_.area.h?
+      var nTicks  = Math.floor(self.height_ / pixelsPerTick);
+      var minIdx = Dygraph.binarySearch(minV, Dygraph.PREFERRED_LOG_TICK_VALUES, 1);
+      var maxIdx = Dygraph.binarySearch(maxV, Dygraph.PREFERRED_LOG_TICK_VALUES, -1);
+      if (minIdx == -1) {
+        minIdx = 0;
+      }
+      if (maxIdx == -1) {
+        maxIdx = Dygraph.PREFERRED_LOG_TICK_VALUES.length - 1;
+      }
+      // Count the number of tick values would appear, if we can get at least
+      // nTicks / 4 accept them.
+      var lastDisplayed = null;
+      if (maxIdx - minIdx >= nTicks / 4) {
+        var axisId = axis_props.yAxisId;
+        for (var idx = maxIdx; idx >= minIdx; idx--) {
+          var tickValue = Dygraph.PREFERRED_LOG_TICK_VALUES[idx];
+          var domCoord = axis_props.g.toDomYCoord(tickValue, axisId);
+          var tick = { v: tickValue };
+          if (lastDisplayed == null) {
+            lastDisplayed = {
+              tickValue : tickValue,
+              domCoord : domCoord
+            };
+          } else {
+            if (domCoord - lastDisplayed.domCoord >= pixelsPerTick) {
+              lastDisplayed = {
+                tickValue : tickValue,
+                domCoord : domCoord
+              };
+            } else {
+              tick.label = "";
+            }
+          }
+          ticks.push(tick);
+        }
+        // Since we went in backwards order.
+        ticks.reverse();
+      }

     }
     }

-    var scale, low_val, high_val, nTicks;
-    // TODO(danvk): make it possible to set this for x- and y-axes independently.
-    var pixelsPerTick = attr('pixelsPerYLabel');
-    for (var i = -10; i < 50; i++) {
+
+    // ticks.length won't be 0 if the log scale function finds values to insert.
+    if (ticks.length == 0) {
+      // Basic idea:
+      // Try labels every 1, 2, 5, 10, 20, 50, 100, etc.
+      // Calculate the resulting tick spacing (i.e. this.height_ / nTicks).
+      // The first spacing greater than pixelsPerYLabel is what we use.
+      // TODO(danvk): version that works on a log scale.

       if (attr("labelsKMG2")) {
       if (attr("labelsKMG2")) {

-        var base_scale = Math.pow(16, i);
+        var mults = [1, 2, 4, 8];

       } else {
       } else {

-        var base_scale = Math.pow(10, i);
+        var mults = [1, 2, 5];

       }
       }

-      for (var j = 0; j < mults.length; j++) {
-        scale = base_scale * mults[j];
-        low_val = Math.floor(minV / scale) * scale;
-        high_val = Math.ceil(maxV / scale) * scale;
-        nTicks = Math.abs(high_val - low_val) / scale;
-        var spacing = self.height_ / nTicks;
-        // wish I could break out of both loops at once...
+      var scale, low_val, high_val, nTicks;
+      // TODO(danvk): make it possible to set this for x- and y-axes independently.
+      var pixelsPerTick = attr('pixelsPerYLabel');
+      for (var i = -10; i < 50; i++) {
+        if (attr("labelsKMG2")) {
+          var base_scale = Math.pow(16, i);
+        } else {
+          var base_scale = Math.pow(10, i);
+        }
+        for (var j = 0; j < mults.length; j++) {
+          scale = base_scale * mults[j];
+          low_val = Math.floor(minV / scale) * scale;
+          high_val = Math.ceil(maxV / scale) * scale;
+          nTicks = Math.abs(high_val - low_val) / scale;
+          var spacing = self.height_ / nTicks;
+          // wish I could break out of both loops at once...
+          if (spacing > pixelsPerTick) break;
+        }

         if (spacing > pixelsPerTick) break;
       }
         if (spacing > pixelsPerTick) break;
       }

-      if (spacing > pixelsPerTick) break;
-    }

 
 

-    // Construct the set of ticks.
-    // Allow reverse y-axis if it's explicitly requested.
-    if (low_val > high_val) scale *= -1;
-    for (var i = 0; i < nTicks; i++) {
-      var tickV = low_val + i * scale;
-      ticks[i] = {v: tickV};
+      // Construct the set of ticks.
+      // Allow reverse y-axis if it's explicitly requested.
+      if (low_val > high_val) scale *= -1;
+      for (var i = 0; i < nTicks; i++) {
+        var tickV = low_val + i * scale;
+        ticks.push( {v: tickV} );
+      }

     }
   }
 
     }
   }
 


@@ -1918,36 +2102,33 @@ Dygraph.numericTicks = function(minV, maxV, self, axis_props, vals) {
     k = 1024;
     k_labels = [ "k", "M", "G", "T" ];
   }
     k = 1024;
     k_labels = [ "k", "M", "G", "T" ];
   }

-  var formatter = attr('yAxisLabelFormatter') ?
-      attr('yAxisLabelFormatter') : attr('yValueFormatter');
+  var formatter = attr('yAxisLabelFormatter') ? attr('yAxisLabelFormatter') : attr('yValueFormatter'); 

 
 

-  // Determine the number of decimal places needed for the labels below by
-  // taking the maximum number of significant figures for any label.  We must
-  // take the max because we can't tell if trailing 0s are significant.
-  var numDigits = 0;
+  // Add labels to the ticks.

   for (var i = 0; i < ticks.length; i++) {
   for (var i = 0; i < ticks.length; i++) {

-    var tickV = ticks[i].v;
-    numDigits = Math.max(Dygraph.significantFigures(tickV), numDigits);
-  }
-
-  for (var i = 0; i < ticks.length; i++) {
-    var tickV = ticks[i].v;
-    var absTickV = Math.abs(tickV);
-    var label = (formatter !== undefined) ?
-        formatter(tickV, numDigits) : tickV.toPrecision(numDigits);
-    if (k_labels.length > 0) {
-      // Round up to an appropriate unit.
-      var n = k*k*k*k;
-      for (var j = 3; j >= 0; j--, n /= k) {
-        if (absTickV >= n) {
-          label = (tickV / n).toPrecision(numDigits) + k_labels[j];
-          break;
+    if (ticks[i].label == null) {
+      var tickV = ticks[i].v;
+      var absTickV = Math.abs(tickV);
+      var label;
+      if (formatter != undefined) {
+        label = formatter(tickV);
+      } else {
+        label = Dygraph.round_(tickV, 2);
+      }
+      if (k_labels.length) {
+        // Round up to an appropriate unit.
+        var n = k*k*k*k;
+        for (var j = 3; j >= 0; j--, n /= k) {
+          if (absTickV >= n) {
+            label = Dygraph.round_(tickV / n, 1) + k_labels[j];
+            break;
+          }

         }
       }
         }
       }

+      ticks[i].label = label;

     }
     }

-    ticks[i].label = label;

   }
   }

-  return {ticks: ticks, numDigits: numDigits};
+  return ticks;

 };
 
 // Computes the range of the data series (including confidence intervals).
 };
 
 // Computes the range of the data series (including confidence intervals).


@@ -2021,7 +2202,6 @@ Dygraph.prototype.predraw_ = function() {
 };
 
 /**
 };
 
 /**

-=======

  * Update the graph with new data. This method is called when the viewing area
  * has changed. If the underlying data or options have changed, predraw_ will
  * be called before drawGraph_ is called.
  * Update the graph with new data. This method is called when the viewing area
  * has changed. If the underlying data or options have changed, predraw_ will
  * be called before drawGraph_ is called.


@@ -2053,12 +2233,24 @@ Dygraph.prototype.drawGraph_ = function() {
 
     var seriesName = this.attr_("labels")[i];
     var connectSeparatedPoints = this.attr_('connectSeparatedPoints', i);
 
     var seriesName = this.attr_("labels")[i];
     var connectSeparatedPoints = this.attr_('connectSeparatedPoints', i);

+    var logScale = this.attr_('logscale', i);

 
     var series = [];
     for (var j = 0; j < data.length; j++) {
 
     var series = [];
     for (var j = 0; j < data.length; j++) {

-      if (data[j][i] != null || !connectSeparatedPoints) {
-        var date = data[j][0];
-        series.push([date, data[j][i]]);
+      var date = data[j][0];
+      var point = data[j][i];
+      if (logScale) {
+        // On the log scale, points less than zero do not exist.
+        // This will create a gap in the chart. Note that this ignores
+        // connectSeparatedPoints.
+        if (point < 0) {
+          point = null;
+        }
+        series.push([date, point]);
+      } else {
+        if (point != null || !connectSeparatedPoints) {
+          series.push([date, point]);
+        }

       }
     }
 
       }
     }
 


@@ -2138,9 +2330,12 @@ Dygraph.prototype.drawGraph_ = function() {
     this.layout_.addDataset(this.attr_("labels")[i], datasets[i]);
   }
 
     this.layout_.addDataset(this.attr_("labels")[i], datasets[i]);
   }
 

-  this.computeYAxisRanges_(extremes);
-  this.layout_.updateOptions( { yAxes: this.axes_,
-                                seriesToAxisMap: this.seriesToAxisMap_
+  // TODO(danvk): this method doesn't need to return anything.
+  var out = this.computeYAxisRanges_(extremes);
+  var axes = out[0];
+  var seriesToAxisMap = out[1];
+  this.layout_.updateOptions( { yAxes: axes,
+                                seriesToAxisMap: seriesToAxisMap

                               } );
 
   this.addXTicks_();
                               } );
 
   this.addXTicks_();


@@ -2169,7 +2364,7 @@ Dygraph.prototype.drawGraph_ = function() {
  *   indices are into the axes_ array.
  */
 Dygraph.prototype.computeYAxes_ = function() {
  *   indices are into the axes_ array.
  */
 Dygraph.prototype.computeYAxes_ = function() {

-  this.axes_ = [{}];  // always have at least one y-axis.
+  this.axes_ = [{ yAxisId : 0, g : this }];  // always have at least one y-axis.

   this.seriesToAxisMap_ = {};
 
   // Get a list of series names.
   this.seriesToAxisMap_ = {};
 
   // Get a list of series names.


@@ -2186,7 +2381,8 @@ Dygraph.prototype.computeYAxes_ = function() {
     'pixelsPerYLabel',
     'yAxisLabelWidth',
     'axisLabelFontSize',
     'pixelsPerYLabel',
     'yAxisLabelWidth',
     'axisLabelFontSize',

-    'axisTickSize'
+    'axisTickSize',
+    'logscale'

   ];
 
   // Copy global axis options over to the first axis.
   ];
 
   // Copy global axis options over to the first axis.


@@ -2209,9 +2405,12 @@ Dygraph.prototype.computeYAxes_ = function() {
       var opts = {};
       Dygraph.update(opts, this.axes_[0]);
       Dygraph.update(opts, { valueRange: null });  // shouldn't inherit this.
       var opts = {};
       Dygraph.update(opts, this.axes_[0]);
       Dygraph.update(opts, { valueRange: null });  // shouldn't inherit this.

+      var yAxisId = this.axes_.length;
+      opts.yAxisId = yAxisId;
+      opts.g = this;

       Dygraph.update(opts, axis);
       this.axes_.push(opts);
       Dygraph.update(opts, axis);
       this.axes_.push(opts);

-      this.seriesToAxisMap_[seriesName] = this.axes_.length - 1;
+      this.seriesToAxisMap_[seriesName] = yAxisId;

     }
   }
 
     }
   }
 


@@ -2298,18 +2497,26 @@ Dygraph.prototype.computeYAxisRanges_ = function(extremes) {
       var span = maxY - minY;
       // special case: if we have no sense of scale, use +/-10% of the sole value.
       if (span == 0) { span = maxY; }
       var span = maxY - minY;
       // special case: if we have no sense of scale, use +/-10% of the sole value.
       if (span == 0) { span = maxY; }

-      var maxAxisY = maxY + 0.1 * span;
-      var minAxisY = minY - 0.1 * span;

 
 

-      // Try to include zero and make it minAxisY (or maxAxisY) if it makes sense.
-      if (!this.attr_("avoidMinZero")) {
-        if (minAxisY < 0 && minY >= 0) minAxisY = 0;
-        if (maxAxisY > 0 && maxY <= 0) maxAxisY = 0;
-      }
+      var maxAxisY;
+      var minAxisY;
+      if (axis.logscale) {
+        var maxAxisY = maxY + 0.1 * span;
+        var minAxisY = minY;
+      } else {
+        var maxAxisY = maxY + 0.1 * span;
+        var minAxisY = minY - 0.1 * span;

 
 

-      if (this.attr_("includeZero")) {
-        if (maxY < 0) maxAxisY = 0;
-        if (minY > 0) minAxisY = 0;
+        // Try to include zero and make it minAxisY (or maxAxisY) if it makes sense.
+        if (!this.attr_("avoidMinZero")) {
+          if (minAxisY < 0 && minY >= 0) minAxisY = 0;
+          if (maxAxisY > 0 && maxY <= 0) maxAxisY = 0;
+        }
+
+        if (this.attr_("includeZero")) {
+          if (maxY < 0) maxAxisY = 0;
+          if (minY > 0) minAxisY = 0;
+        }

       }
 
       axis.computedValueRange = [minAxisY, maxAxisY];
       }
 
       axis.computedValueRange = [minAxisY, maxAxisY];


@@ -2319,13 +2526,11 @@ Dygraph.prototype.computeYAxisRanges_ = function(extremes) {
     // primary axis. However, if an axis is specifically marked as having
     // independent ticks, then that is permissible as well.
     if (i == 0 || axis.independentTicks) {
     // primary axis. However, if an axis is specifically marked as having
     // independent ticks, then that is permissible as well.
     if (i == 0 || axis.independentTicks) {

-      var ret =
+      axis.ticks =

         Dygraph.numericTicks(axis.computedValueRange[0],
                              axis.computedValueRange[1],
                              this,
                              axis);
         Dygraph.numericTicks(axis.computedValueRange[0],
                              axis.computedValueRange[1],
                              this,
                              axis);

-      axis.ticks = ret.ticks;
-      this.numDigits_ = ret.numDigits;

     } else {
       var p_axis = this.axes_[0];
       var p_ticks = p_axis.ticks;
     } else {
       var p_axis = this.axes_[0];
       var p_ticks = p_axis.ticks;


@@ -2338,14 +2543,14 @@ Dygraph.prototype.computeYAxisRanges_ = function(extremes) {
         tick_values.push(y_val);
       }
 
         tick_values.push(y_val);
       }
 

-      var ret =
+      axis.ticks =

         Dygraph.numericTicks(axis.computedValueRange[0],
                              axis.computedValueRange[1],
                              this, axis, tick_values);
         Dygraph.numericTicks(axis.computedValueRange[0],
                              axis.computedValueRange[1],
                              this, axis, tick_values);

-      axis.ticks = ret.ticks;
-      this.numDigits_ = ret.numDigits;

     }
   }
     }
   }

+
+  return [this.axes_, this.seriesToAxisMap_];

 };
  
 /**
 };
  
 /**


@@ -2357,8 +2562,7 @@ Dygraph.prototype.computeYAxisRanges_ = function(extremes) {
  * Note that this is where fractional input (i.e. '5/10') is converted into
  *   decimal values.
  * @param {Array} originalData The data in the appropriate format (see above)
  * Note that this is where fractional input (i.e. '5/10') is converted into
  *   decimal values.
  * @param {Array} originalData The data in the appropriate format (see above)

- * @param {Number} rollPeriod The number of points over which to average the
- *                            data
+ * @param {Number} rollPeriod The number of days over which to average the data

  */
 Dygraph.prototype.rollingAverage = function(originalData, rollPeriod) {
   if (originalData.length < 2)
  */
 Dygraph.prototype.rollingAverage = function(originalData, rollPeriod) {
   if (originalData.length < 2)


@@ -2435,7 +2639,7 @@ Dygraph.prototype.rollingAverage = function(originalData, rollPeriod) {
     }
   } else {
     // Calculate the rolling average for the first rollPeriod - 1 points where
     }
   } else {
     // Calculate the rolling average for the first rollPeriod - 1 points where

-    // there is not enough data to roll over the full number of points
+    // there is not enough data to roll over the full number of days

     var num_init_points = Math.min(rollPeriod - 1, originalData.length - 2);
     if (!this.attr_("errorBars")){
       if (rollPeriod == 1) {
     var num_init_points = Math.min(rollPeriod - 1, originalData.length - 2);
     if (!this.attr_("errorBars")){
       if (rollPeriod == 1) {


@@ -3007,9 +3211,9 @@ Dygraph.prototype.resize = function(width, height) {
 };
 
 /**
 };
 
 /**

- * Adjusts the number of points in the rolling average. Updates the graph to
+ * Adjusts the number of days in the rolling average. Updates the graph to

  * reflect the new averaging period.
  * reflect the new averaging period.

- * @param {Number} length Number of points over which to average the data.
+ * @param {Number} length Number of days over which to average the data.

  */
 Dygraph.prototype.adjustRoll = function(length) {
   this.rollPeriod_ = length;
  */
 Dygraph.prototype.adjustRoll = function(length) {
   this.rollPeriod_ = length;