docs: function setDateTimeTickPositions() {
  			tickPositions = [];
  			var i,
  				useUTC = defaultOptions.global.useUTC,
  				oneSecond = 1000 / timeFactor,
  				oneMinute = 60000 / timeFactor,
  				oneHour = 3600000 / timeFactor,
  				oneDay = 24 * 3600000 / timeFactor,
  				oneWeek = 7 * 24 * 3600000 / timeFactor,
  				oneMonth = 30 * 24 * 3600000 / timeFactor,
  				oneYear = 31556952000 / timeFactor,
  
  				units = [[
  					'second',						// unit name
  					oneSecond,						// fixed incremental unit
  					[1, 2, 5, 10, 15, 30]			// allowed multiples
  				], [
  					'minute',						// unit name
  					oneMinute,						// fixed incremental unit
  					[1, 2, 5, 10, 15, 30]			// allowed multiples
  				], [
  					'hour',							// unit name
  					oneHour,						// fixed incremental unit
  					[1, 2, 3, 4, 6, 8, 12]			// allowed multiples
  				], [
  					'day',							// unit name
  					oneDay,							// fixed incremental unit
  					[1, 2]							// allowed multiples
  				], [
  					'week',							// unit name
  					oneWeek,						// fixed incremental unit
  					[1, 2]							// allowed multiples
  				], [
  					'month',
  					oneMonth,
  					[1, 2, 3, 4, 6]
  				], [
  					'year',
  					oneYear,
  					null
  				]],
  
  				unit = units[6], // default unit is years
  				interval = unit[1],
  				multiples = unit[2];
  
  			// loop through the units to find the one that best fits the tickInterval
  			for (i = 0; i < units.length; i++) {
  				unit = units[i];
  				interval = unit[1];
  				multiples = unit[2];
  
  
  				if (units[i + 1]) {
  					// lessThan is in the middle between the highest multiple and the next unit.
  					var lessThan = (interval * multiples[multiples.length - 1] +
  								units[i + 1][1]) / 2;
  
  					// break and keep the current unit
  					if (tickInterval <= lessThan) {
  						break;
  					}
  				}
  			}
  
  			// prevent 2.5 years intervals, though 25, 250 etc. are allowed
  			if (interval === oneYear && tickInterval < 5 * interval) {
  				multiples = [1, 2, 5];
  			}
  
  			// get the minimum value by flooring the date
  			var multitude = normalizeTickInterval(tickInterval / interval, multiples),
  				minYear, // used in months and years as a basis for Date.UTC()
  				minDate = new Date(min * timeFactor);
  
  			minDate.setMilliseconds(0);
  
  			if (interval >= oneSecond) { // second
  				minDate.setSeconds(interval >= oneMinute ? 0 :
  					multitude * mathFloor(minDate.getSeconds() / multitude));
  			}
  
  			if (interval >= oneMinute) { // minute
  				minDate[setMinutes](interval >= oneHour ? 0 :
  					multitude * mathFloor(minDate[getMinutes]() / multitude));
  			}
  
  			if (interval >= oneHour) { // hour
  				minDate[setHours](interval >= oneDay ? 0 :
  					multitude * mathFloor(minDate[getHours]() / multitude));
  			}
  
  			if (interval >= oneDay) { // day
  				minDate[setDate](interval >= oneMonth ? 1 :
  					multitude * mathFloor(minDate[getDate]() / multitude));
  			}
  
  			if (interval >= oneMonth) { // month
  				minDate[setMonth](interval >= oneYear ? 0 :
  					multitude * mathFloor(minDate[getMonth]() / multitude));
  				minYear = minDate[getFullYear]();
  			}
  
  			if (interval >= oneYear) { // year
  				minYear -= minYear % multitude;
  				minDate[setFullYear](minYear);
  			}
  
  			// week is a special case that runs outside the hierarchy
  			if (interval === oneWeek) {
  				// get start of current week, independent of multitude
  				minDate[setDate](minDate[getDate]() - minDate[getDay]() +
  					options.startOfWeek);
  			}
  
  
  			// get tick positions
  			i = 1; // prevent crash just in case
  			minYear = minDate[getFullYear]();
  			var time = minDate.getTime() / timeFactor,
  				minMonth = minDate[getMonth](),
  				minDateDate = minDate[getDate]();
  
  			// iterate and add tick positions at appropriate values
  			while (time < max && i < plotWidth) {
  				tickPositions.push(time);
  
  				// if the interval is years, use Date.UTC to increase years
  				if (interval === oneYear) {
  					time = makeTime(minYear + i * multitude, 0) / timeFactor;
  
  				// if the interval is months, use Date.UTC to increase months
  				} else if (interval === oneMonth) {
  					time = makeTime(minYear, minMonth + i * multitude) / timeFactor;
  
  				// if we're using global time, the interval is not fixed as it jumps
  				// one hour at the DST crossover
  				} else if (!useUTC && (interval === oneDay || interval === oneWeek)) {
  					time = makeTime(minYear, minMonth, minDateDate +
  						i * multitude * (interval === oneDay ? 1 : 7));
  
  				// else, the interval is fixed and we use simple addition
  				} else {
  					time += interval * multitude;
  				}
  
  				i++;
  			}
  			// push the last time
  			tickPositions.push(time);
  
  
  			// dynamic label formatter
  			dateTimeLabelFormat = options.dateTimeLabelFormats[unit[0]];
  		}