Compact and simple easing functions for Unity

Easing.cs

using UnityEngine;

// Functions taken from Tween.js - Licensed under the MIT license at https://github.com/sole/tween.js
public static class Easing
{
	public enum EasingType 
	{
		Linear,
		SineIn,
		SineOut,
		SineInOut,
		QuadIn,
		QuadOut,
		QuadInOut,
		CubicIn,
		CubicOut,
		CubicInOut,
		QuartIn,
		QuartOut,
		QuartInOut,
		QuintIn,
		QuintOut,
		QuintInOut,
		ExpoIn,
		ExpoOut,
		ExpoInOut,
		CircIn,
		CircOut,
		CircInOut,
		BackIn,
		BackOut,
		BackInOut,
		ElasticIn,
		ElasticOut,
		ElasticInOut,
		BounceIn,
		BounceOut,
		BounceInOut
	}

	public static float Ease(EasingType type, float k)
	{
		switch (type)
		{
			case EasingType.BackIn:
				return Back.In(k);
			case EasingType.BackOut:
				return Back.Out(k);
			case EasingType.BackInOut:
				return Back.InOut(k);

			case EasingType.BounceIn:
				return Bounce.In(k);
			case EasingType.BounceOut:
				return Bounce.Out(k);
			case EasingType.BounceInOut:
				return Bounce.InOut(k);

			case EasingType.CircIn:
				return Circular.In(k);
			case EasingType.CircOut:
				return Circular.Out(k);
			case EasingType.CircInOut:
				return Circular.InOut(k);

			case EasingType.CubicIn:
				return Cubic.In(k);
			case EasingType.CubicOut:
				return Cubic.Out(k);
			case EasingType.CubicInOut:
				return Cubic.InOut(k);

			case EasingType.ElasticIn:
				return Elastic.In(k);
			case EasingType.ElasticOut:
				return Elastic.Out(k);
			case EasingType.ElasticInOut:
				return Elastic.InOut(k);

			case EasingType.ExpoIn:
				return Exponential.In(k);
			case EasingType.ExpoOut:
				return Exponential.Out(k);
			case EasingType.ExpoInOut:
				return Exponential.InOut(k);

			case EasingType.QuadIn:
				return Quadratic.In(k);
			case EasingType.QuadOut:
				return Quadratic.Out(k);
			case EasingType.QuadInOut:
				return Quadratic.InOut(k);

			case EasingType.QuartIn:
				return Quartic.In(k);
			case EasingType.QuartOut:
				return Quartic.Out(k);
			case EasingType.QuartInOut:
				return Quartic.InOut(k);

			case EasingType.QuintIn:
				return Quintic.In(k);
			case EasingType.QuintOut:
				return Quintic.Out(k);
			case EasingType.QuintInOut:
				return Quintic.InOut(k);

			case EasingType.SineIn:
				return Sinusoidal.In(k);
			case EasingType.SineOut:
				return Sinusoidal.Out(k);
			case EasingType.SineInOut:
				return Sinusoidal.InOut(k);

			default:
				return Linear(k);
		}
	}

	public static float Linear (float k) {
		return k;
	}
	
	public static class Quadratic
	{
		public static float In (float k) {
			return k*k;
		}
		
		public static float Out (float k) {
			return k*(2f - k);
		}
		
		public static float InOut (float k) {
			if ((k *= 2f) < 1f) return 0.5f*k*k;
			return -0.5f*((k -= 1f)*(k - 2f) - 1f);
		}		
	};
	
	public static class Cubic
	{		
		public static float In (float k) {
			return k*k*k;
		}
		
		public static float Out (float k) {
			return 1f + ((k -= 1f)*k*k);
		}
		
		public static float InOut (float k) {
			if ((k *= 2f) < 1f) return 0.5f*k*k*k;
			return 0.5f*((k -= 2f)*k*k + 2f);
		}
	};
	
	public static class Quartic
	{		
		public static float In (float k) {
			return k*k*k*k;
		}
		
		public static float Out (float k) {
			return 1f - ((k -= 1f)*k*k*k);
		}
		
		public static float InOut (float k) {
			if ((k *= 2f) < 1f) return 0.5f*k*k*k*k;
			return -0.5f*((k -= 2f)*k*k*k - 2f);
		}		
	};
	
	public static class Quintic
	{		
		public static float In (float k) {
			return k*k*k*k*k;
		}
		
		public static float Out (float k) {
			return 1f + ((k -= 1f)*k*k*k*k);
		}
		
		public static float InOut (float k) {
			if ((k *= 2f) < 1f) return 0.5f*k*k*k*k*k;
			return 0.5f*((k -= 2f)*k*k*k*k + 2f);
		}		
	};
	
	public static class Sinusoidal
	{		
		public static float In (float k) {
			return 1f - Mathf.Cos(k*Mathf.PI/2f);
		}
		
		public static float Out (float k) {
			return Mathf.Sin(k*Mathf.PI/2f);
		}
		
		public static float InOut (float k) {
			return 0.5f*(1f - Mathf.Cos(Mathf.PI*k));
		}		
	};
	
	public static class Exponential
	{		
		public static float In (float k) {
			return Mathf.Approximately(k, 0f) ? 0f : Mathf.Pow(1024f, k - 1f);
		}
		
		public static float Out (float k) {
			return Mathf.Approximately(k, 1f) ? 1f : 1f - Mathf.Pow(2f, -10f*k);
		}

		public static float InOut (float k) {
			if (Mathf.Approximately(k, 0f)) return 0f;
			if (Mathf.Approximately(k, 1f)) return 1f;
			if ((k *= 2f) < 1f) return 0.5f*Mathf.Pow(1024f, k - 1f);
			return 0.5f*(-Mathf.Pow(2f, -10f*(k - 1f)) + 2f);
		}		
	};
	
	public static class Circular
	{		
		public static float In (float k) {
			return 1f - Mathf.Sqrt(1f - k*k);
		}
		
		public static float Out (float k) {
			return Mathf.Sqrt(1f - ((k -= 1f)*k));
		}
		
		public static float InOut (float k) {
			if ((k *= 2f) < 1f) return -0.5f*(Mathf.Sqrt(1f - k*k) - 1);
			return 0.5f*(Mathf.Sqrt(1f - (k -= 2f)*k) + 1f);
		}		
	};
	
	public static class Elastic
	{
		public static float In (float k) {
			if (Mathf.Approximately(k, 0f)) return 0;
			if (Mathf.Approximately(k, 1f)) return 1;
			return -Mathf.Pow( 2f, 10f*(k -= 1f))*Mathf.Sin((k - 0.1f)*(2f*Mathf.PI)/0.4f);
		}
		
		public static float Out (float k) {
			if (Mathf.Approximately(k, 0f)) return 0;
			if (Mathf.Approximately(k, 1f)) return 1;
			return Mathf.Pow(2f, -10f*k)*Mathf.Sin((k - 0.1f)*(2f*Mathf.PI)/0.4f) + 1f;
		}
		
		public static float InOut (float k) {
			if ((k *= 2f) < 1f) return -0.5f*Mathf.Pow(2f, 10f*(k -= 1f))*Mathf.Sin((k - 0.1f)*(2f*Mathf.PI)/0.4f);
			return Mathf.Pow(2f, -10f*(k -= 1f))*Mathf.Sin((k - 0.1f)*(2f*Mathf.PI)/0.4f)*0.5f + 1f;
		}		
	};
	
	public static class Back
	{
		const float s = 1.70158f;
		const float s2 = 2.5949095f;
		
		public static float In (float k) {
			return k*k*((s + 1f)*k - s);
		}
		
		public static float Out (float k) {
			return (k -= 1f)*k*((s + 1f)*k + s) + 1f;
		}
		
		public static float InOut (float k) {
			if ((k *= 2f) < 1f) return 0.5f*(k*k*((s2 + 1f)*k - s2));
			return 0.5f*((k -= 2f)*k*((s2 + 1f)*k + s2) + 2f);
		}		
	};
	
	public static class Bounce
	{		
		public static float In (float k) {
			return 1f - Out(1f - k);
		}
		
		public static float Out (float k) {			
			if (k < (1f/2.75f)) {
				return 7.5625f*k*k;				
			}
			else if (k < (2f/2.75f)) {
				return 7.5625f*(k -= (1.5f/2.75f))*k + 0.75f;
			}
			else if (k < (2.5f/2.75f)) {
				return 7.5625f *(k -= (2.25f/2.75f))*k + 0.9375f;
			}
			else {
				return 7.5625f*(k -= (2.625f/2.75f))*k + 0.984375f;
			}
		}
		
		public static float InOut (float k) {
			if (k < 0.5f) return In(k*2f)*0.5f;
			return Out(k*2f - 1f)*0.5f + 0.5f;
		}		
	};
}