<!--

function runConversion() 
{
	var metric = false; 
	var VO2max = -1;
	var time = 0; 		// race time in seconds. 
	var rlength = 0;	// race length in meters. 
	var speed;			// speed in meters / min. 
	var moderateWalkSpeedKm		= 0.001525;
	var moderateWalkSpeedMile	= 0.000947590775;
	var walkSpeedDiffKm			= 15; // seconds
	var walkSpeedDiffMile		= 25; // seconds
	var m2kmConversion 			= 1.609344;
	var km2mConversion			= 0.62137119;

	var moderateWalkSpeed = 0;
	var walkSpeedDiff = 0;
	if (document.controls.paceType.options[0].selected) {
		metric = false;
		moderateWalkSpeed = moderateWalkSpeedMile;
		walkSpeedDiff = walkSpeedDiffMile;
	}
	else {
		metric = true;
		moderateWalkSpeed = moderateWalkSpeedKm;
		walkSpeedDiff = walkSpeedDiffKm;
	}
	time += document.time.hours.value * 60; 
	time += document.time.minutes.value * 1; 
	time += document.time.seconds.value / 60; 
	
	var timeSeconds = (document.time.hours.value * 60 * 60) + (document.time.minutes.value * 60) + (document.time.seconds.value * 1);

	if (time <= 0 || isNaN(time)) {
        alert("Please input a valid time"); 
        return; 
	}
	
	rlength += document.leng.number.value * 1; 
	if (rlength <= 0 || isNaN(rlength)) { 
        alert("Please input a valid race length."); 
        return;
	}
	
	var distance = rlength;
	
	if (document.leng.units.options[0].selected) {
		rlength *= 1000; 

		// convert distance to imperial if showing mile splits 
		if (!metric)
			distance *= km2mConversion;
	}
	else {
		rlength *= (m2kmConversion * 1000);
		
		// convert distance to metric if showing metric splits 
		if (metric)
			distance *= m2kmConversion;
	}

	speed = rlength / time; 
	VO2Max  = velToVO2(speed) / timeToPercentVO2Max(time) ;
                
	if (VO2Max <= 0) return; 
	        
	var velEasy		= VO2ToVel(VO2Max * .7); 
	var velTempo	= VO2ToVel(VO2Max * .80);
	var velMaximum	= VO2ToVel(VO2Max);
	var velSpeed	= VO2ToVel(VO2Max * .95);
	var velLong		= VO2ToVel(VO2Max * .6);
	var velRace		= speed;
	
	var toAppend = metric ? " min/km" : " min/mile" ;  
	
	var paceEasy	= "" + timeConvert(velEasy,metric)		+ toAppend;
	var paceTempo	= "" + timeConvert(velTempo,metric)		+ toAppend; 
	var paceMaximum	= "" + timeConvert(velMaximum,metric)	+ toAppend;
	var paceSpeed	= "" + timeConvert(velSpeed,metric)		+ toAppend;
	var paceLong	= "" + timeConvert(velEasy,metric) 		+ " - ";
	paceLong		+= "" + timeConvert(velLong,metric) 	+ toAppend;
	var paceRace	= "" + timeConvert(velRace,metric)		+ toAppend;
	var paceWalkSec	= getTimeAt(1, distance, moderateWalkSpeed, timeSeconds, velToTime(velRace, metric), walkSpeedDiff);
	var paceWalk	= "" + showTime(paceWalkSec) 			+ toAppend;

	// document.output.Maximum.value	= paceMaximum; 
	document.output.Easy.value		= paceEasy;
	document.output.Tempo.value		= paceTempo; 
	document.output.Speed.value		= paceSpeed; 
	document.output.Long.value		= paceLong; 
	document.output.Race.value		= paceRace;
	document.output.Walk.value		= paceWalk;
}
        
// Takes a velocity and converts it to a VO2 level.     
function velToVO2 (vel) {
	return (-4.60 + 0.182258 * vel + 0.000104 * vel * vel);
}
        
// Takes a VO2 measurement and converts it to a velocity. 
function  VO2ToVel (VO2) {
	return (29.54 + 5.000663 * VO2 - 0.007546 * VO2 * VO2);
}

// Takes a time in minutes and uses EQ 2 to convert it to a percent of VO2 maximum.     
function timeToPercentVO2Max (minutes) {
	return (.8 + 0.1894393 * Math.exp(-.012778 * minutes) 
		+ 0.2989558 * Math.exp(-.1932695 * minutes)); 
}

// Takes a speed in meters / minute a converts it to a string representing a pace in 
// minutes per mile or km.      
function timeConvert (speed, metric) {
	var m2metresConversion = 1609.344;
	var ans; 
	if (!metric)
		ans = (1 / speed) * m2metresConversion;
	else
		ans = (1 / speed) * 1000; 
	minutes = Math.floor(ans);
	seconds = Math.round((ans - minutes) * 60);
	if (seconds >= 60)
	{
		minutes++;
		seconds -= 60;
	}
	if(seconds > 9) 
		return "" + minutes + ":" + seconds;
	else 
		return "" + minutes + ":0" + seconds;
}

function velToTime (vel, metric)
{
	var m2metresConversion = 1609.344;
	var totalSeconds = 0;
	var totalMinutes = 0;
	
	if (!metric)
		totalMinutes = (1 / vel) * m2metresConversion;
	else
		totalMinutes = (1 / vel) * 1000; 
	totalSeconds = Math.round(totalMinutes * 60);
	return totalSeconds;
}

function getTimeAt(distanceToFindTimeAt, totalDistance, walkingSpeed, totalTimeTaken, racePaceSeconds, walkAdjustedDiff)
{
	// constants
	// run 10 minutes then walk 1 minute
	var runningTime = 10 * 60;
	var walkingTime = 60;

	var timeTakenToCompleteOneInterval = walkingTime + runningTime;
	var totalNumberOfIntervals = Math.floor(totalTimeTaken / timeTakenToCompleteOneInterval);
	var timeLeftOver = totalTimeTaken - (totalNumberOfIntervals * timeTakenToCompleteOneInterval);
	var totalWalkingTime = totalNumberOfIntervals * walkingTime;
	var extraWalkingTime = timeLeftOver - runningTime;

	if (extraWalkingTime > 0)
		totalWalkingTime += extraWalkingTime;

	var totalRunningTime = totalTimeTaken - totalWalkingTime;

	var distanceCoveredWhileWalking = walkingSpeed * totalWalkingTime;
	var distanceCoveredWhileRunning = totalDistance - distanceCoveredWhileWalking;

	var runningSpeed = 0;
	if (totalRunningTime)
		runningSpeed = distanceCoveredWhileRunning / totalRunningTime;
	var distanceWalkedInOneInterval = walkingSpeed * walkingTime;
	var distanceRunInOneInterval = runningSpeed * runningTime;

	var totalDistanceCoveredInOneInterval = distanceWalkedInOneInterval + distanceRunInOneInterval;

	// find number of intervals needed for this distance
	var numberOfIntervalsRequired = Math.floor(distanceToFindTimeAt / totalDistanceCoveredInOneInterval);

	var distanceLeft = distanceToFindTimeAt - (numberOfIntervalsRequired * totalDistanceCoveredInOneInterval);

	var extraTimeRequired = 0;
	var totalTimeRequired = 0;

	if (numberOfIntervalsRequired > 0) {
		// hack to adjust for finishing times where the first interval includes walking - we want pure running time for the calculators
		// use Race Pace - 25 secs for miles, Race Pace - 15 secs for kms
		totalTimeRequired = racePaceSeconds - walkAdjustedDiff; 
		
/*		if (runningSpeed > 0) {
			totalDistanceRun = numberOfIntervalsRequired * distanceRunInOneInterval;
			totalTimeRequired =  totalDistanceRun / runningSpeed + (distanceToFindTimeAt - totalDistanceRun) / runningSpeed;
		}
		else
			numberOfIntervalsRequired * timeTakenToCompleteOneInterval
*/
	}
	else if (distanceLeft <= distanceRunInOneInterval) {
		if (runningSpeed > 0)
			extraTimeRequired = distanceLeft / runningSpeed;
		totalTimeRequired = numberOfIntervalsRequired * timeTakenToCompleteOneInterval + extraTimeRequired;
	} 
	else {
		distanceLeft -= distanceRunInOneInterval;
		totalTimeRequired = runningTime + distanceLeft / runningSpeed;
	}
	
	return totalTimeRequired;
}

function showTime(sec) 
{
	var hour = Math.floor(sec / 3600);
	sec	-= hour * 3600;
	var min	= Math.floor(sec / 60);
	sec	-= min * 60;
	sec	= Math.round(sec);
	var fullTime = "";
	if (hour > 0)
		fullTime = hour + ":";
	if (sec == 60) {
		min++;
		sec = 0;
	}
	if (min > 0) {
		if (fullTime == "")
			fullTime = min + ":";
		else
			fullTime += prefixZero(min) + ":";
	}
	fullTime += prefixZero(sec);

	return fullTime;
}

function prefixZero(num) 
{
	if (num < 10)
		return "0" + num;
	else
		return "" + num;
}

// -->