docs: function getSeriesExtremes() {
  			var posStack = [],
  				negStack = [],
  				run;
  
  			// reset dataMin and dataMax in case we're redrawing
  			dataMin = dataMax = null;
  
  			// get an overview of what series are associated with this axis
  			associatedSeries = [];
  
  			each(series, function (serie) {
  				run = false;
  
  
  				// match this axis against the series' given or implicated axis
  				each(['xAxis', 'yAxis'], function (strAxis) {
  					if (
  						// the series is a cartesian type, and...
  						serie.isCartesian &&
  						// we're in the right x or y dimension, and...
  						((strAxis === 'xAxis' && isXAxis) || (strAxis === 'yAxis' && !isXAxis)) && (
  							// the axis number is given in the options and matches this axis index, or
  							(serie.options[strAxis] === options.index) ||
  							// the axis index is not given
  							(serie.options[strAxis] === UNDEFINED && options.index === 0)
  						)
  					) {
  						serie[strAxis] = axis;
  						associatedSeries.push(serie);
  
  						// the series is visible, run the min/max detection
  						run = true;
  					}
  				});
  				// ignore hidden series if opted
  				if (!serie.visible && optionsChart.ignoreHiddenSeries) {
  					run = false;
  				}
  
  				if (run) {
  
  					var stacking,
  						posPointStack,
  						negPointStack,
  						stackKey,
  						stackOption,
  						negKey;
  
  					if (!isXAxis) {
  						stacking = serie.options.stacking;
  						usePercentage = stacking === 'percent';
  
  						// create a stack for this particular series type
  						if (stacking) {
  							stackOption = serie.options.stack;
  							stackKey = serie.type + pick(stackOption, '');
  							negKey = '-' + stackKey;
  							serie.stackKey = stackKey; // used in translate
  
  							posPointStack = posStack[stackKey] || []; // contains the total values for each x
  							posStack[stackKey] = posPointStack;
  
  							negPointStack = negStack[negKey] || [];
  							negStack[negKey] = negPointStack;
  						}
  						if (usePercentage) {
  							dataMin = 0;
  							dataMax = 99;
  						}
  					}
  					if (serie.isCartesian) { // line, column etc. need axes, pie doesn't
  						each(serie.data, function (point) {
  							var pointX = point.x,
  								pointY = point.y,
  								isNegative = pointY < 0,
  								pointStack = isNegative ? negPointStack : posPointStack,
  								key = isNegative ? negKey : stackKey,
  								totalPos,
  								pointLow;
  
  							// initial values
  							if (dataMin === null) {
  
  								// start out with the first point
  								dataMin = dataMax = point[xOrY];
  							}
  
  							// x axis
  							if (isXAxis) {
  								if (pointX > dataMax) {
  									dataMax = pointX;
  								} else if (pointX < dataMin) {
  									dataMin = pointX;
  								}
  							} else if (defined(pointY)) { // y axis
  								if (stacking) {
  									pointStack[pointX] =
  										defined(pointStack[pointX]) ?
  										pointStack[pointX] + pointY : pointY;
  								}
  								totalPos = pointStack ? pointStack[pointX] : pointY;
  								pointLow = pick(point.low, totalPos);
  								if (!usePercentage) {
  									if (totalPos > dataMax) {
  										dataMax = totalPos;
  									} else if (pointLow < dataMin) {
  										dataMin = pointLow;
  									}
  								}
  								if (stacking) {
  									// add the series
  									if (!stacks[key]) {
  										stacks[key] = {};
  									}
  
  									// If the StackItem is there, just update the values,
  									// if not, create one first
  									if (!stacks[key][pointX]) {
  										stacks[key][pointX] = new StackItem(options.stackLabels, isNegative, pointX, stackOption);
  									}
  									stacks[key][pointX].setTotal(totalPos);
  								}
  							}
  						});
  
  
  						// For column, areas and bars, set the minimum automatically to zero
  						// and prevent that minPadding is added in setScale
  						if (/(area|column|bar)/.test(serie.type) && !isXAxis) {
  							var threshold = 0; // use series.options.threshold?
  							if (dataMin >= threshold) {
  								dataMin = threshold;
  								ignoreMinPadding = true;
  							} else if (dataMax < threshold) {
  								dataMax = threshold;
  								ignoreMaxPadding = true;
  							}
  						}
  					}
  				}
  			});
  
  		}