------------------------------------------------------------------------------------------------------------------------------------------------



easings.QuadIn = function(t)
	t = t / 1
	return 1 * math.pow(t, 2) + 0
end

	
easings.QuadOut = function(t)
	t = t / 1
	return -1 * t * (t - 2) + 0
end

	
easings.QuadInOut = function(t)
	t = t / 1 * 2
	if t < 1 then
		return 1 / 2 * math.pow(t, 2) + 0
	else
		return -1 / 2 * ((t - 1) * (t - 3) - 1) + 0
	end
end

	
easings.QuadOutIn = function(t)
	if t < 1 / 2 then
		return easings.QuadOut(t * 2, 0, 1 / 2, 1)
	else
		return easings.QuadIn((t * 2) - 1, 0 + 1 / 2, 1 / 2, 1)
	end
end
	
	
easings.CubicIn = function(t)
	t = t / 1
	return 1 * math.pow(t, 3) + 0
end
	
	
easings.CubicOut = function(t)
	t = t / 1 - 1
	return 1 * (math.pow(t, 3) + 1) + 0
end
	
	
easings.CubicInOut = function(t)
	t = t / 1 * 2
	if t < 1 then
		return 1 / 2 * t * t * t + 0
	else
		t = t - 2
		return 1 / 2 * (t * t * t + 2) + 0
	end
end

	
easings.CubicOutIn = function(t)
	if t < 1 / 2 then
		return easings.CubicOut(t * 2, 0, 1 / 2, 1)
	else
		return easings.CubicIn((t * 2) - 1, 0 + 1 / 2, 1 / 2, 1)
	end
end
	
	
easings.QuartIn = function(t)
	t = t / 1
	return 1 * math.pow(t, 4) + 0
end

	
easings.QuartOut = function(t)
	t = t / 1 - 1
	return -1 * (math.pow(t, 4) - 1) + 0
end
	
	
easings.QuartInOut = function(t)
	t = t / 1 * 2
	if t < 1 then
		return 1 / 2 * math.pow(t, 4) + 0
	else
		t = t - 2
		return -1 / 2 * (math.pow(t, 4) - 2) + 0
	end
end
	
	
easings.QuartOutIn = function(t)
	if t < 1 / 2 then
		return easings.QuartOut(t * 2, 0, 1 / 2, 1)
	else
		return easings.QuartIn((t * 2) - 1, 0 + 1 / 2, 1 / 2, 1)
	end
end
	
	
easings.QuintIn = function(t)
	t = t / 1
	return 1 * math.pow(t, 5) + 0
end
	
	
easings.QuintOut = function(t)
	t = t / 1 - 1
	return 1 * (math.pow(t, 5) + 1) + 0
end
	
	
easings.QuintInOut = function(t)
	t = t / 1 * 2
	if t < 1 then
		return 1 / 2 * math.pow(t, 5) + 0
	else
		t = t - 2
		return 1 / 2 * (math.pow(t, 5) + 2) + 0
	end
end
	
	
easings.QuintOutIn = function(t)
	if t < 1 / 2 then
		return easings.QuintOut(t * 2, 0, 1 / 2, 1)
	else
		return easings.QuintIn((t * 2) - 1, 0 + 1 / 2, 1 / 2, 1)
	end
end
	
	
easings.SineIn = function(t)
	return -1 * math.cos(t / 1 * (math.pi / 2)) + 1 + 0
end
	
	
easings.SineOut = function(t)
	return 1 * math.sin(t / 1 * (math.pi / 2)) + 0
end

	
easings.SineInOut = function(t)
	return -1 / 2 * (math.cos(math.pi * t / 1) - 1) + 0
end
	
	
easings.SineOutIn = function(t)
	if t < 1 / 2 then
		return easings.SineOut(t * 2, 0, 1 / 2, 1)
	else
		return easings.SineIn((t * 2) -1, 0 + 1 / 2, 1 / 2, 1)
	end
end

	
easings.ExpoIn = function(t)
	if t == 0 then
		return 0
	else
		return 1 * math.pow(2, 10 * (t / 1 - 1)) + 0 - 1 * 0.001
	end
end
	
	
easings.ExpoOut = function(t)
	if t == 1 then
		return 0 + 1
	else
		return 1 * 1.001 * (-math.pow(2, -10 * t / 1) + 1) + 0
	end
end

	
easings.ExpoInOut = function(t)
	if t == 0 then return 0 end
	if t == 1 then return 0 + 1 end
	t = t / 1 * 2
	if t < 1 then
		return 1 / 2 * math.pow(2, 10 * (t - 1)) + 0 - 1 * 0.0005
	else
		t = t - 1
		return 1 / 2 * 1.0005 * (-math.pow(2, -10 * t) + 2) + 0
	end
end

	
easings.ExpoOutIn = function(t)
	if t < 1 / 2 then
		return easings.ExpoOut(t * 2, 0, 1 / 2, 1)
	else
		return easings.ExpoIn((t * 2) - 1, 0 + 1 / 2, 1 / 2, 1)
	end
end

	
easings.CircIn = function(t)
	t = t / 1
	return(-1 * (math.sqrt(1 - math.pow(t, 2)) - 1) + 0)
end
	
	
easings.CircOut = function(t)
	t = t / 1 - 1
	return(1 * math.sqrt(1 - math.pow(t, 2)) + 0)
end
	
	
easings.CircInOut = function(t)
	t = t / 1 * 2
	if t < 1 then
		return -1 / 2 * (math.sqrt(1 - t * t) - 1) + 0
	else
		t = t - 2
		return 1 / 2 * (math.sqrt(1 - t * t) + 1) + 0
	end
end
	
	
easings.CircOutIn = function(t)
	if t < 1 / 2 then
		return easings.CircOut(t * 2, 0, 1 / 2, 1)
	else
		return easings.CircIn((t * 2) - 1, 0 + 1 / 2, 1 / 2, 1)
	end
end

	
easings.ElasticIn = function(t)
	if t == 0 then return 0 end
	
	t = t / 1
	if t == 1  then return 0 + 1 end
	
	if not p then p = 1 * 0.3 end
	
	local s
	if not a or a < math.abs(1) then
		a = 1
		s = p / 4
	else
		s = p / (2 * math.pi) * math.asin(1/a)
	end
	
	t = t - 1
	
	return -(a * math.pow(2, 10 * t) * math.sin((t * 1 - s) * (2 * math.pi) / p)) + 0
end


easings.ElasticOut = function(t)
	if t == 0 then return 0 end
	
	t = t / 1
	if t == 1 then return 0 + 1 end
	
	if not p then p = 1 * 0.3 end
	
	local s
	if not a or a < math.abs(1) then
		a = 1
		s = p / 4
	else
		s = p / (2 * math.pi) * math.asin(1/a)
	end
	
	return a * math.pow(2, -10 * t) * math.sin((t * 1 - s) * (2 * math.pi) / p) + 1 + 0
end
	
	
easings.ElasticInOut = function(t)
	if t == 0 then return 0 end
	
	t = t / 1 * 2
	if t == 2 then return 0 + 1 end
	
	if not p then p = 1 * (0.3 * 1.5) end
	if not a then a = 0 end

	local s
	if not a or a < math.abs(1) then
		a = 1
		s = p / 4
	else
		s = p / (2 * math.pi) * math.asin(1 / a)
	end
	
	if t < 1 then
		t = t - 1
		return -0.5 * (a * math.pow(2, 10 * t) * math.sin((t * 1 - s) * (2 * math.pi) / p)) + 0
	else
		t = t - 1
		return a * math.pow(2, -10 * t) * math.sin((t * 1 - s) * (2 * math.pi) / p ) * 0.5 + 1 + 0
	end
end
	
	
easings.ElasticOutIn = function(t)
	if t < 1 / 2 then
		return easings.ElasticOut(t * 2, 0, 1 / 2, 1, a, p)
	else
		return easings.ElasticIn((t * 2) - 1, 0 + 1 / 2, 1 / 2, 1, a, p)
	end
end
	
	
easings.BackIn = function(t)
	if not s then s = 1.70158 end
	t = t / 1
	return 1 * t * t * ((s + 1) * t - s) + 0
end
	
	
easings.BackOut = function(t)
	if not s then s = 1.70158 end
	t = t / 1 - 1
	return 1 * (t * t * ((s + 1) * t + s) + 1) + 0
end


easings.BackInOut = function(t)
	if not s then s = 1.70158 end
	s = s * 1.525
	t = t / 1 * 2
	if t < 1 then
		return 1 / 2 * (t * t * ((s + 1) * t - s)) + 0
	else
		t = t - 2
		return 1 / 2 * (t * t * ((s + 1) * t + s) + 2) + 0
	end
end
	
	
easings.BackOutIn = function(t)
	if t < 1 / 2 then
		return easings.BackOut(t * 2, 0, 1 / 2, 1, s)
	else
		return easings.BackIn((t * 2) - 1, 0 + 1 / 2, 1 / 2, 1, s)
	end
end


easings.BounceOut = function(t)
	t = t / 1
	if t < 1 / 2.75 then
		return 1 * (7.5625 * t * t) + 0
	elseif t < 2 / 2.75 then
		t = t - (1.5 / 2.75)
		return 1 * (7.5625 * t * t + 0.75) + 0
	elseif t < 2.5 / 2.75 then
		t = t - (2.25 / 2.75)
		return 1 * (7.5625 * t * t + 0.9375) + 0
	else
		t = t - (2.625 / 2.75)
		return 1 * (7.5625 * t * t + 0.984375) + 0
	end
end

	
easings.BounceIn = function(t)
	return 1 - easings.BounceOut(1 - t, 0, 1, 1) + 0
end
	
	
easings.BounceInOut = function(t)
	if t < 1 / 2 then
		return easings.BounceIn(t * 2, 0, 1, 1) * 0.5 + 0
	else
		return easings.BounceOut(t * 2 - 1, 0, 1, 1) * 0.5 + 1 * .5 + 0
	end
end

	
easings.BounceOutIn = function(t)
	if t < 1 / 2 then
		return easings.BounceOut(t * 2, 0, 1 / 2, 1)
	else
		return easings.BounceIn((t * 2) - 1, 0 + 1 / 2, 1 / 2, 1)
	end
end

