Interpolation formula.

• t is the value moving (could be time). It is your cursor. Or input value from 0 to c
• d is beginning range of your output
• b is the end of your range output
• c is the maximum of your input cursor

//linear interpolation
 function linearTween(t, d, b, c) {
 return c*t/d + b;
 };

// quadratic easing in - accelerating from zero velocity
 function easeInQuad(t, d, b, c) {
 t /= d;
 return c*t*t + b;
 };

// quadratic easing out - decelerating to zero velocity
 function easeOutQuad(t, d, b, c) {
 t /= d;
 return -c * t*(t-2) + b;
 };

// quadratic easing in/out - acceleration until halfway, then deceleration
 function easeInOutQuad(t, d, b, c) {
 t /= d/2;
 if (t < 1) return c/2*t*t + b;
 t--;
 return -c/2 * (t*(t-2) - 1) + b;
 };

// cubic easing in - accelerating from zero velocity
 function easeInCubic(t, d, b, c) {
 t /= d;
 return c*t*t*t + b;
 };

// cubic easing out - decelerating to zero velocity
 function easeOutCubic(t, d, b, c) {
 t /= d;
 t--;
 return c*(t*t*t + 1) + b;
 };

// cubic easing in/out - acceleration until halfway, then deceleration
 function easeInOutCubic(t, d, b, c) {
 t /= d/2;
 if (t < 1) return c/2*t*t*t + b;
 t -= 2;
 return c/2*(t*t*t + 2) + b;
 };

// quartic easing in - accelerating from zero velocity
 function easeInQuart(t, d, b, c) {
 t /= d;
 return c*t*t*t*t + b;
 };

// quartic easing out - decelerating to zero velocity
 function easeOutQuart(t, d, b, c) {
 t /= d;
 t--;
 return -c * (t*t*t*t - 1) + b;
 };

// quartic easing in/out - acceleration until halfway, then deceleration
 function easeInOutQuart(t, d, b, c) {
 t /= d/2;
 if (t < 1) return c/2*t*t*t*t + b;
 t -= 2;
 return -c/2 * (t*t*t*t - 2) + b;
 };

// quintic easing in - accelerating from zero velocity
 function easeInQuint(t, d, b, c) {
 t /= d;
 return c*t*t*t*t*t + b;
 };

// quintic easing out - decelerating to zero velocity
 function easeOutQuint(t, d, b, c) {
 t /= d;
 t--;
 return c*(t*t*t*t*t + 1) + b;
 };

// quintic easing in/out - acceleration until halfway, then deceleration
 function easeInOutQuint(t, d, b, c) {
 t /= d/2;
 if (t < 1) return c/2*t*t*t*t*t + b;
 t -= 2;
 return c/2*(t*t*t*t*t + 2) + b;
 };

// sinusoidal easing in - accelerating from zero velocity
 function easeInSine(t, d, b, c) {
 return -c * Math.cos(t/d * (Math.PI/2)) + c + b;
 };

// sinusoidal easing out - decelerating to zero velocity
 function easeOutSine(t, d, b, c) {
 return c * Math.sin(t/d * (Math.PI/2)) + b;
 };

// sinusoidal easing in/out - accelerating until halfway, then decelerating
 function easeInOutSine(t, d, b, c) {
 return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b;
 };

// exponential easing in - accelerating from zero velocity
 function easeInExpo(t, d, b, c) {
 return c * Math.pow( 2, 10 * (t/d - 1) ) + b;
 };

// exponential easing out - decelerating to zero velocity
 function easeOutExpo(t, d, b, c) {
 return c * ( -Math.pow( 2, -10 * t/d ) + 1 ) + b;
 };

// exponential easing in/out - accelerating until halfway, then decelerating
 function easeInOutExpo(t, d, b, c) {
 t /= d/2;
 if (t < 1) return c/2 * Math.pow( 2, 10 * (t - 1) ) + b;
 t--;
 return c/2 * ( -Math.pow( 2, -10 * t) + 2 ) + b;
 };

// circular easing in - accelerating from zero velocity
 function easeInCirc(t, d, b, c) {
 t /= d;
 return -c * (Math.sqrt(1 - t*t) - 1) + b;
 };

// circular easing out - decelerating to zero velocity
 function easeOutCirc(t, d, b, c) {
 t /= d;
 t--;
 return c * Math.sqrt(1 - t*t) + b;
 };

// circular easing in/out - acceleration until halfway, then deceleration
 function easeInOutCirc(t, d, b, c) {
 t /= d/2;
 if (t < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b;
 t -= 2;
 return c/2 * (Math.sqrt(1 - t*t) + 1) + b;
 };