docs: function render() {
  			var axisTitleOptions = options.title,
  				stackLabelOptions = options.stackLabels,
  				alternateGridColor = options.alternateGridColor,
  				lineWidth = options.lineWidth,
  				lineLeft,
  				lineTop,
  				linePath,
  				hasRendered = chart.hasRendered,
  				slideInTicks = hasRendered && defined(oldMin) && !isNaN(oldMin),
  				hasData = associatedSeries.length && defined(min) && defined(max);
  
  			// update metrics
  			axisLength = horiz ? plotWidth : plotHeight;
  			transA = axisLength / ((max - min) || 1);
  			transB = horiz ? plotLeft : marginBottom; // translation addend
  
  			// If the series has data draw the ticks. Else only the line and title
  			if (hasData || isLinked) {
  
  				// minor ticks
  				if (minorTickInterval && !categories) {
  					var pos = min + (tickPositions[0] - min) % minorTickInterval;
  					for (; pos <= max; pos += minorTickInterval) {
  						if (!minorTicks[pos]) {
  							minorTicks[pos] = new Tick(pos, true);
  						}
  
  						// render new ticks in old position
  						if (slideInTicks && minorTicks[pos].isNew) {
  							minorTicks[pos].render(null, true);
  						}
  
  
  						minorTicks[pos].isActive = true;
  						minorTicks[pos].render();
  					}
  				}
  
  				// major ticks
  				each(tickPositions, function (pos, i) {
  					// linked axes need an extra check to find out if
  					if (!isLinked || (pos >= min && pos <= max)) {
  
  						// render new ticks in old position
  						if (slideInTicks && ticks[pos].isNew) {
  							ticks[pos].render(i, true);
  						}
  
  						ticks[pos].isActive = true;
  						ticks[pos].render(i);
  					}
  				});
  
  				// alternate grid color
  				if (alternateGridColor) {
  					each(tickPositions, function (pos, i) {
  						if (i % 2 === 0 && pos < max) {
  							/*plotLinesAndBands.push(new PlotLineOrBand({
  								from: pos,
  								to: tickPositions[i + 1] !== UNDEFINED ? tickPositions[i + 1] : max,
  								color: alternateGridColor
  							}));*/
  
  							if (!alternateBands[pos]) {
  								alternateBands[pos] = new PlotLineOrBand();
  							}
  							alternateBands[pos].options = {
  								from: pos,
  								to: tickPositions[i + 1] !== UNDEFINED ? tickPositions[i + 1] : max,
  								color: alternateGridColor
  							};
  							alternateBands[pos].render();
  							alternateBands[pos].isActive = true;
  						}
  					});
  				}
  
  				// custom plot bands (behind grid lines)
  				/*if (!hasRendered) { // only first time
  					each(options.plotBands || [], function(plotBandOptions) {
  						plotLinesAndBands.push(new PlotLineOrBand(
  							extend({ zIndex: 1 }, plotBandOptions)
  						).render());
  					});
  				}*/
  
  
  
  
  				// custom plot lines and bands
  				if (!hasRendered) { // only first time
  					each((options.plotLines || []).concat(options.plotBands || []), function (plotLineOptions) {
  						plotLinesAndBands.push(new PlotLineOrBand(plotLineOptions).render());
  					});
  				}
  
  
  
  			} // end if hasData
  
  			// remove inactive ticks
  			each([ticks, minorTicks, alternateBands], function (coll) {
  				var pos;
  				for (pos in coll) {
  					if (!coll[pos].isActive) {
  						coll[pos].destroy();
  						delete coll[pos];
  					} else {
  						coll[pos].isActive = false; // reset
  					}
  				}
  			});
  
  
  
  
  			// Static items. As the axis group is cleared on subsequent calls
  			// to render, these items are added outside the group.
  			// axis line
  			if (lineWidth) {
  				lineLeft = plotLeft + (opposite ? plotWidth : 0) + offset;
  				lineTop = chartHeight - marginBottom - (opposite ? plotHeight : 0) + offset;
  
  				linePath = renderer.crispLine([
  						M,
  						horiz ?
  							plotLeft :
  							lineLeft,
  						horiz ?
  							lineTop :
  							plotTop,
  						L,
  						horiz ?
  							chartWidth - marginRight :
  							lineLeft,
  						horiz ?
  							lineTop :
  							chartHeight - marginBottom
  					], lineWidth);
  				if (!axisLine) {
  					axisLine = renderer.path(linePath)
  						.attr({
  							stroke: options.lineColor,
  							'stroke-width': lineWidth,
  							zIndex: 7
  						})
  						.add();
  				} else {
  					axisLine.animate({ d: linePath });
  				}
  
  			}
  
  			if (axisTitle) {
  				// compute anchor points for each of the title align options
  				var margin = horiz ? plotLeft : plotTop,
  					fontSize = pInt(axisTitleOptions.style.fontSize || 12),
  				// the position in the length direction of the axis
  				alongAxis = {
  					low: margin + (horiz ? 0 : axisLength),
  					middle: margin + axisLength / 2,
  					high: margin + (horiz ? axisLength : 0)
  				}[axisTitleOptions.align],
  
  				// the position in the perpendicular direction of the axis
  				offAxis = (horiz ? plotTop + plotHeight : plotLeft) +
  					(horiz ? 1 : -1) * // horizontal axis reverses the margin
  					(opposite ? -1 : 1) * // so does opposite axes
  					axisTitleMargin +
  					//(isIE ? fontSize / 3 : 0)+ // preliminary fix for vml's centerline
  					(side === 2 ? fontSize : 0);
  
  				axisTitle[axisTitle.isNew ? 'attr' : 'animate']({
  					x: horiz ?
  						alongAxis :
  						offAxis + (opposite ? plotWidth : 0) + offset +
  							(axisTitleOptions.x || 0), // x
  					y: horiz ?
  						offAxis - (opposite ? plotHeight : 0) + offset :
  						alongAxis + (axisTitleOptions.y || 0) // y
  				});
  				axisTitle.isNew = false;
  			}
  
  			// Stacked totals:
  			if (stackLabelOptions && stackLabelOptions.enabled) {
  				var stackKey, oneStack, stackCategory,
  					stackTotalGroup = axis.stackTotalGroup;
  
  				// Create a separate group for the stack total labels
  				if (!stackTotalGroup) {
  					axis.stackTotalGroup = stackTotalGroup =
  						renderer.g('stack-labels')
  							.attr({
  								visibility: VISIBLE,
  								zIndex: 6
  							})
  							.translate(plotLeft, plotTop)
  							.add();
  				}
  
  				// Render each stack total
  				for (stackKey in stacks) {
  					oneStack = stacks[stackKey];
  					for (stackCategory in oneStack) {
  						oneStack[stackCategory].render(stackTotalGroup);
  					}
  				}
  			}
  			// End stacked totals
  
  			axis.isDirty = false;
  		}