path: root/libs/windfield/mlib/mlib.lua

--[[ License
	A math library made in Lua
	copyright (C) 2014 Davis Claiborne
	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.
	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.
	You should have received a copy of the GNU General Public License along
	with this program; if not, write to the Free Software Foundation, Inc.,
	51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
	Contact me at davisclaib@gmail.com
]]

-- Local Utility Functions ---------------------- {{{
local unpack = table.unpack or unpack

-- Used to handle variable-argument functions and whether they are passed as func{ table } or func( unpack( table ) )
local function checkInput( ... )
	local input = {}
	if type( ... ) ~= 'table' then input = { ... } else input = ... end
	return input
end

-- Deals with floats / verify false false values. This can happen because of significant figures.
local function checkFuzzy( number1, number2 )
	return ( number1 - .00001 <= number2 and number2 <= number1 + .00001 )
end

-- Remove multiple occurrences from a table.
local function removeDuplicatePairs( tab )
	for index1 = #tab, 1, -1 do
		local first = tab[index1]
		for index2 = #tab, 1, -1 do
			local second = tab[index2]
			if index1 ~= index2 then
				if type( first[1] ) == 'number' and type( second[1] ) == 'number' and type( first[2] ) == 'number' and type( second[2] ) == 'number' then
					if checkFuzzy( first[1], second[1] ) and checkFuzzy( first[2], second[2] ) then
						table.remove( tab, index1 )
					end
				elseif first[1] == second[1] and first[2] == second[2] then
					table.remove( tab, index1 )
				end
			end
		end
	end
	return tab
end


local function removeDuplicates4Points( tab )
    for index1 = #tab, 1, -1 do
        local first = tab[index1]
        for index2 = #tab, 1, -1 do
            local second = tab[index2]
            if index1 ~= index2 then
                if type( first[1] ) ~= type( second[1] ) then return false end
                if type( first[2] ) == 'number' and type( second[2] ) == 'number' and type( first[3] ) == 'number' and type( second[3] ) == 'number' then
                    if checkFuzzy( first[2], second[2] ) and checkFuzzy( first[3], second[3] ) then
                        table.remove( tab, index1 )
                    end
                elseif checkFuzzy( first[1], second[1] ) and checkFuzzy( first[2], second[2] ) and checkFuzzy( first[3], second[3] ) then
                    table.remove( tab, index1 )
                end
            end
        end
    end
    return tab
end


-- Add points to the table.
local function addPoints( tab, x, y )
    tab[#tab + 1] = x
    tab[#tab + 1] = y
end

-- Like removeDuplicatePairs but specifically for numbers in a flat table
local function removeDuplicatePointsFlat( tab )
    for i = #tab, 1 -2 do
        for ii = #tab - 2, 3, -2 do
            if i ~= ii then
                local x1, y1 = tab[i], tab[i + 1]
                local x2, y2 = tab[ii], tab[ii + 1]
                if checkFuzzy( x1, x2 ) and checkFuzzy( y1, y2 ) then
                    table.remove( tab, ii ); table.remove( tab, ii + 1 )
                end
            end
        end
    end
    return tab
end


-- Check if input is actually a number
local function validateNumber( n )
	if type( n ) ~= 'number' then return false
	elseif n ~= n then return false -- nan
	elseif math.abs( n ) == math.huge then return false
	else return true end
end

local function cycle( tab, index ) return tab[( index - 1 ) % #tab + 1] end

local function getGreatestPoint( points, offset )
    offset = offset or 1
    local start = 2 - offset
    local greatest = points[start]
    local least = points[start]
    for i = 2, #points / 2 do
        i = i * 2 - offset
        if points[i] > greatest then
            greatest = points[i]
        end
        if points[i] < least then
            least = points[i]
        end
    end
    return greatest, least
end

local function isWithinBounds( min, num, max )
    return num >= min and num <= max
end

local function distance2( x1, y1, x2, y2 ) -- Faster since it does not use math.sqrt
	local dx, dy = x1 - x2, y1 - y2
	return dx * dx + dy * dy
end -- }}}

-- Points -------------------------------------- {{{
local function rotatePoint( x, y, rotation, ox, oy )
    ox, oy = ox or 0, oy or 0
    return ( x - ox ) * math.cos( rotation ) + ox - ( y - oy ) * math.sin( rotation ), ( x - ox ) * math.sin( rotation ) + ( y - oy ) * math.cos( rotation ) + oy
end

local function scalePoint( x, y, scale, ox, oy )
    ox, oy = ox or 0, oy or 0
    return ( x - ox ) * scale + ox, ( y - oy ) * scale + oy
end
-- }}}

-- Lines --------------------------------------- {{{
-- Returns the length of a line.
local function getLength( x1, y1, x2, y2 )
	local dx, dy = x1 - x2, y1 - y2
	return math.sqrt( dx * dx + dy * dy )
end

-- Gives the midpoint of a line.
local function getMidpoint( x1, y1, x2, y2 )
	return ( x1 + x2 ) / 2, ( y1 + y2 ) / 2
end

-- Gives the slope of a line.
local function getSlope( x1, y1, x2, y2 )
	if checkFuzzy( x1, x2 ) then return false end -- Technically it's undefined, but this is easier to program.
	return ( y1 - y2 ) / ( x1 - x2 )
end

-- Gives the perpendicular slope of a line.
-- x1, y1, x2, y2
-- slope
local function getPerpendicularSlope( ... )
	local input = checkInput( ... )
	local slope

	if #input ~= 1 then
		slope = getSlope( unpack( input ) )
	else
		slope = unpack( input )
	end

	if not slope then return 0 -- Vertical lines become horizontal.
	elseif checkFuzzy( slope, 0 ) then return false -- Horizontal lines become vertical.
    else return -1 / slope end
end

-- Gives the y-intercept of a line.
-- x1, y1, x2, y2
-- x1, y1, slope
local function getYIntercept( x, y, ... )
	local input = checkInput( ... )
	local slope

	if #input == 1 then
		slope = input[1]
	else
		slope = getSlope( x, y, unpack( input ) )
	end

	if not slope then return x, true end -- This way we have some information on the line.
	return y - slope * x, false
end

-- Gives the intersection of two lines.
-- slope1, slope2, x1, y1, x2, y2
-- slope1, intercept1, slope2, intercept2
-- x1, y1, x2, y2, x3, y3, x4, y4
local function getLineLineIntersection( ... )
	local input = checkInput( ... )
	local x1, y1, x2, y2, x3, y3, x4, y4
	local slope1, intercept1
	local slope2, intercept2
	local x, y

	if #input == 4 then -- Given slope1, intercept1, slope2, intercept2.
		slope1, intercept1, slope2, intercept2 = unpack( input )

		-- Since these are lines, not segments, we can use arbitrary points, such as ( 1, y ), ( 2, y )
		y1 = slope1 and slope1 * 1 + intercept1 or 1
		y2 = slope1 and slope1 * 2 + intercept1 or 2
		y3 = slope2 and slope2 * 1 + intercept2 or 1
		y4 = slope2 and slope2 * 2 + intercept2 or 2
		x1 = slope1 and ( y1 - intercept1 ) / slope1 or intercept1
		x2 = slope1 and ( y2 - intercept1 ) / slope1 or intercept1
		x3 = slope2 and ( y3 - intercept2 ) / slope2 or intercept2
		x4 = slope2 and ( y4 - intercept2 ) / slope2 or intercept2
	elseif #input == 6 then -- Given slope1, intercept1, and 2 points on the other line.
		slope1, intercept1 = input[1], input[2]
		slope2 = getSlope( input[3], input[4], input[5], input[6] )
		intercept2 = getYIntercept( input[3], input[4], input[5], input[6] )

		y1 = slope1 and slope1 * 1 + intercept1 or 1
		y2 = slope1 and slope1 * 2 + intercept1 or 2
		y3 = input[4]
		y4 = input[6]
		x1 = slope1 and ( y1 - intercept1 ) / slope1 or intercept1
		x2 = slope1 and ( y2 - intercept1 ) / slope1 or intercept1
		x3 = input[3]
		x4 = input[5]
	elseif #input == 8 then -- Given 2 points on line 1 and 2 points on line 2.
		slope1 = getSlope( input[1], input[2], input[3], input[4] )
		intercept1 = getYIntercept( input[1], input[2], input[3], input[4] )
		slope2 = getSlope( input[5], input[6], input[7], input[8] )
		intercept2 = getYIntercept( input[5], input[6], input[7], input[8] )

		x1, y1, x2, y2, x3, y3, x4, y4 = unpack( input )
	end

	if not slope1 and not slope2 then -- Both are vertical lines
		if x1 == x3 then -- Have to have the same x positions to intersect
			return true
		else
			return false
		end
	elseif not slope1 then -- First is vertical
		x = x1 -- They have to meet at this x, since it is this line's only x
		y = slope2 and slope2 * x + intercept2 or 1
	elseif not slope2 then -- Second is vertical
		x = x3 -- Vice-Versa
		y = slope1 * x + intercept1
	elseif checkFuzzy( slope1, slope2 ) then -- Parallel (not vertical)
		if checkFuzzy( intercept1, intercept2 ) then -- Same intercept
			return true
		else
			return false
		end
	else -- Regular lines
		x = ( -intercept1 + intercept2 ) / ( slope1 - slope2 )
		y = slope1 * x + intercept1
	end

	return x, y
end

-- Gives the closest point on a line to a point.
-- perpendicularX, perpendicularY, x1, y1, x2, y2
-- perpendicularX, perpendicularY, slope, intercept
local function getClosestPoint( perpendicularX, perpendicularY, ... )
	local input = checkInput( ... )
	local x, y, x1, y1, x2, y2, slope, intercept

	if #input == 4 then -- Given perpendicularX, perpendicularY, x1, y1, x2, y2
		x1, y1, x2, y2 = unpack( input )
		slope = getSlope( x1, y1, x2, y2 )
		intercept = getYIntercept( x1, y1, x2, y2 )
	elseif #input == 2 then -- Given perpendicularX, perpendicularY, slope, intercept
		slope, intercept = unpack( input )
        x1, y1 = 1, slope and slope * 1 + intercept or 1 -- Need x1 and y1 in case of vertical/horizontal lines.
	end

	if not slope then -- Vertical line
		x, y = x1, perpendicularY -- Closest point is always perpendicular.
	elseif checkFuzzy( slope, 0 ) then -- Horizontal line
		x, y = perpendicularX, y1
	else
		local perpendicularSlope = getPerpendicularSlope( slope )
		local perpendicularIntercept = getYIntercept( perpendicularX, perpendicularY, perpendicularSlope )
		x, y = getLineLineIntersection( slope, intercept, perpendicularSlope, perpendicularIntercept )
	end

	return x, y
end

-- Gives the intersection of a line and a line segment.
-- x1, y1, x2, y2, x3, y3, x4, y4
-- x1, y1, x2, y2, slope, intercept
local function getLineSegmentIntersection( x1, y1, x2, y2, ... )
	local input = checkInput( ... )

	local slope1, intercept1, x, y, lineX1, lineY1, lineX2, lineY2
	local slope2, intercept2 = getSlope( x1, y1, x2, y2 ), getYIntercept( x1, y1, x2, y2 )

	if #input == 2 then -- Given slope, intercept
		slope1, intercept1 = input[1], input[2]
        lineX1, lineY1 = 1, slope1 and slope1 + intercept1
        lineX2, lineY2 = 2, slope1 and slope1 * 2 + intercept1
	else -- Given x3, y3, x4, y4
        lineX1, lineY1, lineX2, lineY2 = unpack( input )
		slope1 = getSlope( unpack( input ) )
		intercept1 = getYIntercept( unpack( input ) )
	end

	if not slope1 and not slope2 then -- Vertical lines
		if checkFuzzy( x1, lineX1 ) then
			return x1, y1, x2, y2
		else
			return false
		end
	elseif not slope1 then -- slope1 is vertical
		x, y = input[1], slope2 * input[1] + intercept2
	elseif not slope2 then -- slope2 is vertical
		x, y = x1, slope1 * x1 + intercept1
	else
		x, y = getLineLineIntersection( slope1, intercept1, slope2, intercept2 )
	end

	local length1, length2, distance
	if x == true then -- Lines are collinear.
		return x1, y1, x2, y2
	elseif x then -- There is an intersection
		length1, length2 = getLength( x1, y1, x, y ), getLength( x2, y2, x, y )
		distance = getLength( x1, y1, x2, y2 )
	else -- Lines are parallel but not collinear.
		if checkFuzzy( intercept1, intercept2 ) then
			return x1, y1, x2, y2
		else
			return false
		end
	end

	if length1 <= distance and length2 <= distance then return x, y else return false end
end

-- Checks if a point is on a line.
-- Does not support the format using slope because vertical lines would be impossible to check.
local function checkLinePoint( x, y, x1, y1, x2, y2 )
	local m = getSlope( x1, y1, x2, y2 )
	local b = getYIntercept( x1, y1, m )

	if not m then -- Vertical
		return checkFuzzy( x, x1 )
	end
	return checkFuzzy( y, m * x + b )
end -- }}}

-- Segment -------------------------------------- {{{
-- Gives the perpendicular bisector of a line.
local function getPerpendicularBisector( x1, y1, x2, y2 )
	local slope = getSlope( x1, y1, x2, y2 )
	local midpointX, midpointY = getMidpoint( x1, y1, x2, y2 )
	return midpointX, midpointY, getPerpendicularSlope( slope )
end

-- Gives whether or not a point lies on a line segment.
local function checkSegmentPoint( px, py, x1, y1, x2, y2 )
	-- Explanation around 5:20: https://www.youtube.com/watch?v=A86COO8KC58
	local x = checkLinePoint( px, py, x1, y1, x2, y2 )
	if not x then return false end

	local lengthX = x2 - x1
	local lengthY = y2 - y1

	if checkFuzzy( lengthX, 0 ) then -- Vertical line
		if checkFuzzy( px, x1 ) then
			local low, high
			if y1 > y2 then low = y2; high = y1
			else low = y1; high = y2 end

			if py >= low and py <= high then return true
			else return false end
		else
			return false
		end
	elseif checkFuzzy( lengthY, 0 ) then -- Horizontal line
		if checkFuzzy( py, y1 ) then
			local low, high
			if x1 > x2 then low = x2; high = x1
			else low = x1; high = x2 end

			if px >= low and px <= high then return true
			else return false end
		else
			return false
		end
	end

	local distanceToPointX = ( px - x1 )
	local distanceToPointY = ( py - y1 )
	local scaleX = distanceToPointX / lengthX
	local scaleY = distanceToPointY / lengthY

	if ( scaleX >= 0 and scaleX <= 1 ) and ( scaleY >= 0 and scaleY <= 1 ) then -- Intersection
		return true
	end
	return false
end

-- Gives the point of intersection between two line segments.
local function getSegmentSegmentIntersection( x1, y1, x2, y2, x3, y3, x4, y4 )
	local slope1, intercept1 = getSlope( x1, y1, x2, y2 ), getYIntercept( x1, y1, x2, y2 )
	local slope2, intercept2 = getSlope( x3, y3, x4, y4 ), getYIntercept( x3, y3, x4, y4 )

	if ( ( slope1 and slope2 ) and checkFuzzy( slope1, slope2 ) ) or ( not slope1 and not slope2 ) then -- Parallel lines
		if checkFuzzy( intercept1, intercept2 ) then -- The same lines, possibly in different points.
			local points = {}
			if checkSegmentPoint( x1, y1, x3, y3, x4, y4 ) then addPoints( points, x1, y1 ) end
			if checkSegmentPoint( x2, y2, x3, y3, x4, y4 ) then addPoints( points, x2, y2 ) end
			if checkSegmentPoint( x3, y3, x1, y1, x2, y2 ) then addPoints( points, x3, y3 ) end
			if checkSegmentPoint( x4, y4, x1, y1, x2, y2 ) then addPoints( points, x4, y4 ) end

			points = removeDuplicatePointsFlat( points )
			if #points == 0 then return false end
			return unpack( points )
		else
			return false
		end
	end

	local x, y = getLineLineIntersection( x1, y1, x2, y2, x3, y3, x4, y4 )
	if x and checkSegmentPoint( x, y, x1, y1, x2, y2 ) and checkSegmentPoint( x, y, x3, y3, x4, y4 ) then
		return x, y
	end
	return false
end -- }}}

-- Math ----------------------------------------- {{{
-- Get the root of a number (i.e. the 2nd (square) root of 4 is 2)
local function getRoot( number, root )
	return number ^ ( 1 / root )
end

-- Checks if a number is prime.
local function isPrime( number )
	if number < 2 then return false end

	for i = 2, math.sqrt( number ) do
		if number % i == 0 then
			return false
		end
	end
	return true
end

-- Rounds a number to the xth decimal place (round( 3.14159265359, 4 ) --> 3.1416)
local function round( number, place )
	local pow = 10 ^ ( place or 0 )
    return math.floor( number * pow + .5 ) / pow
end

-- Gives the summation given a local function
local function getSummation( start, stop, func )
	local returnValues = {}
	local sum = 0
	for i = start, stop do
		local value = func( i, returnValues )
		returnValues[i] = value
		sum = sum + value
	end
	return sum
end

-- Gives the percent of change.
local function getPercentOfChange( old, new )
	if old == 0 and new == 0 then
        return 0
	else
		return ( new - old ) / math.abs( old )
	end
end

-- Gives the percentage of a number.
local function getPercentage( percent, number )
	return percent * number
end

-- Returns the quadratic roots of an equation.
local function getQuadraticRoots( a, b, c )
	local discriminant = b ^ 2 - ( 4 * a * c )
	if discriminant < 0 then return false end
	discriminant = math.sqrt( discriminant )
	local denominator = ( 2 * a )
	return ( -b - discriminant ) / denominator, ( -b + discriminant ) / denominator
end

-- Gives the angle between three points.
local function getAngle( x1, y1, x2, y2, x3, y3 )
    local a = getLength( x3, y3, x2, y2 )
    local b = getLength( x1, y1, x2, y2 )
    local c = getLength( x1, y1, x3, y3 )

   return math.acos( ( a * a + b * b - c * c ) / ( 2 * a * b ) )
end -- }}}

-- Circle --------------------------------------- {{{
-- Gives the area of the circle.
local function getCircleArea( radius )
	return math.pi * ( radius * radius )
end

-- Checks if a point is within the radius of a circle.
local function checkCirclePoint( x, y, circleX, circleY, radius )
	return getLength( circleX, circleY, x, y ) <= radius
end

-- Checks if a point is on a circle.
local function isPointOnCircle( x, y, circleX, circleY, radius )
	return checkFuzzy( getLength( circleX, circleY, x, y ), radius )
end

-- Gives the circumference of a circle.
local function getCircumference( radius )
	return 2 * math.pi * radius
end

-- Gives the intersection of a line and a circle.
local function getCircleLineIntersection( circleX, circleY, radius, x1, y1, x2, y2 )
	slope = getSlope( x1, y1, x2, y2 )
	intercept = getYIntercept( x1, y1, slope )

	if slope then
		local a = ( 1 + slope ^ 2 )
		local b = ( -2 * ( circleX ) + ( 2 * slope * intercept ) - ( 2 * circleY * slope ) )
		local c = ( circleX ^ 2 + intercept ^ 2 - 2 * ( circleY ) * ( intercept ) + circleY ^ 2 - radius ^ 2 )

		x1, x2 = getQuadraticRoots( a, b, c )

		if not x1 then return false end

		y1 = slope * x1 + intercept
		y2 = slope * x2 + intercept

		if checkFuzzy( x1, x2 ) and checkFuzzy( y1, y2 ) then
			return 'tangent', x1, y1
		else
			return 'secant', x1, y1, x2, y2
		end
	else -- Vertical Lines
		local lengthToPoint1 = circleX - x1
		local remainingDistance = lengthToPoint1 - radius
		local intercept = math.sqrt( -( lengthToPoint1 ^ 2 - radius ^ 2 ) )

		if -( lengthToPoint1 ^ 2 - radius ^ 2 ) < 0 then return false end

		local bottomX, bottomY = x1, circleY - intercept
		local topX, topY = x1, circleY + intercept

		if topY ~= bottomY then
			return 'secant', topX, topY, bottomX, bottomY
		else
			return 'tangent', topX, topY
		end
	end
end

-- Gives the type of intersection of a line segment.
local function getCircleSegmentIntersection( circleX, circleY, radius, x1, y1, x2, y2 )
	local Type, x3, y3, x4, y4 = getCircleLineIntersection( circleX, circleY, radius, x1, y1, x2, y2 )
	if not Type then return false end

	local slope, intercept = getSlope( x1, y1, x2, y2 ), getYIntercept( x1, y1, x2, y2 )

	if isPointOnCircle( x1, y1, circleX, circleY, radius ) and isPointOnCircle( x2, y2, circleX, circleY, radius ) then -- Both points are on line-segment.
		return 'chord', x1, y1, x2, y2
	end

	if slope then
		if checkCirclePoint( x1, y1, circleX, circleY, radius ) and checkCirclePoint( x2, y2, circleX, circleY, radius ) then -- Line-segment is fully in circle.
			return 'enclosed', x1, y1, x2, y2
		elseif x3 and x4 then
			if checkSegmentPoint( x3, y3, x1, y1, x2, y2 ) and not checkSegmentPoint( x4, y4, x1, y1, x2, y2 ) then -- Only the first of the points is on the line-segment.
				return 'tangent', x3, y3
			elseif checkSegmentPoint( x4, y4, x1, y1, x2, y2 ) and not checkSegmentPoint( x3, y3, x1, y1, x2, y2 ) then -- Only the second of the points is on the line-segment.
				return 'tangent', x4, y4
			else -- Neither of the points are on the circle (means that the segment is not on the circle, but "encasing" the circle)
				if checkSegmentPoint( x3, y3, x1, y1, x2, y2 ) and checkSegmentPoint( x4, y4, x1, y1, x2, y2 ) then
					return 'secant', x3, y3, x4, y4
				else
					return false
				end
			end
		elseif not x4 then -- Is a tangent.
			if checkSegmentPoint( x3, y3, x1, y1, x2, y2 ) then
				return 'tangent', x3, y3
			else -- Neither of the points are on the line-segment (means that the segment is not on the circle or "encasing" the circle).
				local length = getLength( x1, y1, x2, y2 )
				local distance1 = getLength( x1, y1, x3, y3 )
				local distance2 = getLength( x2, y2, x3, y3 )

				if length > distance1 or length > distance2 then
					return false
				elseif length < distance1 and length < distance2 then
					return false
				else
					return 'tangent', x3, y3
				end
			end
		end
	else
		local lengthToPoint1 = circleX - x1
		local remainingDistance = lengthToPoint1 - radius
		local intercept = math.sqrt( -( lengthToPoint1 ^ 2 - radius ^ 2 ) )

		if -( lengthToPoint1 ^ 2 - radius ^ 2 ) < 0 then return false end

		local topX, topY = x1, circleY - intercept
		local bottomX, bottomY = x1, circleY + intercept

		local length = getLength( x1, y1, x2, y2 )
		local distance1 = getLength( x1, y1, topX, topY )
		local distance2 = getLength( x2, y2, topX, topY )

		if bottomY ~= topY then -- Not a tangent
			if checkSegmentPoint( topX, topY, x1, y1, x2, y2 ) and checkSegmentPoint( bottomX, bottomY, x1, y1, x2, y2 ) then
				return 'chord', topX, topY, bottomX, bottomY
			elseif checkSegmentPoint( topX, topY, x1, y1, x2, y2 ) then
				return 'tangent', topX, topY
			elseif checkSegmentPoint( bottomX, bottomY, x1, y1, x2, y2 ) then
				return 'tangent', bottomX, bottomY
			else
				return false
			end
		else -- Tangent
			if checkSegmentPoint( topX, topY, x1, y1, x2, y2 ) then
				return 'tangent', topX, topY
			else
				return false
			end
		end
	end
end

-- Checks if one circle intersects another circle.
local function getCircleCircleIntersection( circle1x, circle1y, radius1, circle2x, circle2y, radius2 )
	local length = getLength( circle1x, circle1y, circle2x, circle2y )
	if length > radius1 + radius2 then return false end -- If the distance is greater than the two radii, they can't intersect.
	if checkFuzzy( length, 0 ) and checkFuzzy( radius1, radius2 ) then return 'equal' end
	if checkFuzzy( circle1x, circle2x ) and checkFuzzy( circle1y, circle2y ) then return 'collinear' end

	local a = ( radius1 * radius1 - radius2 * radius2 + length * length ) / ( 2 * length )
	local h = math.sqrt( radius1 * radius1 - a * a )

	local p2x = circle1x + a * ( circle2x - circle1x ) / length
	local p2y = circle1y + a * ( circle2y - circle1y ) / length
	local p3x = p2x + h * ( circle2y - circle1y ) / length
	local p3y = p2y - h * ( circle2x - circle1x ) / length
	local p4x = p2x - h * ( circle2y - circle1y ) / length
	local p4y = p2y + h * ( circle2x - circle1x ) / length

	if not validateNumber( p3x ) or not validateNumber( p3y ) or not validateNumber( p4x ) or not validateNumber( p4y ) then
		return 'inside'
	end

	if checkFuzzy( length, radius1 + radius2 ) or checkFuzzy( length, math.abs( radius1 - radius2 ) ) then return 'tangent', p3x, p3y end
	return 'intersection', p3x, p3y, p4x, p4y
end

-- Checks if circle1 is entirely inside of circle2.
local function isCircleCompletelyInsideCircle( circle1x, circle1y, circle1radius, circle2x, circle2y, circle2radius )
	if not checkCirclePoint( circle1x, circle1y, circle2x, circle2y, circle2radius ) then return false end
	local Type = getCircleCircleIntersection( circle2x, circle2y, circle2radius, circle1x, circle1y, circle1radius )
	if ( Type ~= 'tangent' and Type ~= 'collinear' and Type ~= 'inside' ) then return false end
	return true
end

-- Checks if a line-segment is entirely within a circle.
local function isSegmentCompletelyInsideCircle( circleX, circleY, circleRadius, x1, y1, x2, y2 )
	local Type = getCircleSegmentIntersection( circleX, circleY, circleRadius, x1, y1, x2, y2 )
	return Type == 'enclosed'
end -- }}}

-- Polygon -------------------------------------- {{{
-- Gives the signed area.
-- If the points are clockwise the number is negative, otherwise, it's positive.
local function getSignedPolygonArea( ... )
	local points = checkInput( ... )

	-- Shoelace formula (https://en.wikipedia.org/wiki/Shoelace_formula).
	points[#points + 1] = points[1]
	points[#points + 1] = points[2]

	return ( .5 * getSummation( 1, #points / 2,
		function( index )
			index = index * 2 - 1 -- Convert it to work properly.
			return ( ( points[index] * cycle( points, index + 3 ) ) - ( cycle( points, index + 2 ) * points[index + 1] ) )
		end
	) )
end

-- Simply returns the area of the polygon.
local function getPolygonArea( ... )
	return math.abs( getSignedPolygonArea( ... ) )
end

-- Gives the height of a triangle, given the base.
-- base, x1, y1, x2, y2, x3, y3, x4, y4
-- base, area
local function getTriangleHeight( base, ... )
	local input = checkInput( ... )
	local area

	if #input == 1 then area = input[1] -- Given area.
	else area = getPolygonArea( input ) end -- Given coordinates.

	return ( 2 * area ) / base, area
end

-- Gives the centroid of the polygon.
local function getCentroid( ... )
	local points = checkInput( ... )

	points[#points + 1] = points[1]
	points[#points + 1] = points[2]

	local area = getSignedPolygonArea( points ) -- Needs to be signed here in case points are counter-clockwise.

	-- This formula: https://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon
	local centroidX = ( 1 / ( 6 * area ) ) * ( getSummation( 1, #points / 2,
		function( index )
			index = index * 2 - 1 -- Convert it to work properly.
			return ( ( points[index] + cycle( points, index + 2 ) ) * ( ( points[index] * cycle( points, index + 3 ) ) - ( cycle( points, index + 2 ) * points[index + 1] ) ) )
		end
	) )

	local centroidY = ( 1 / ( 6 * area ) ) * ( getSummation( 1, #points / 2,
		function( index )
			index = index * 2 - 1 -- Convert it to work properly.
			return ( ( points[index + 1] + cycle( points, index + 3 ) ) * ( ( points[index] * cycle( points, index + 3 ) ) - ( cycle( points, index + 2 ) * points[index + 1] ) ) )
		end
	) )

	return centroidX, centroidY
end

-- Returns whether or not a line intersects a polygon.
-- x1, y1, x2, y2, polygonPoints
local function getPolygonLineIntersection( x1, y1, x2, y2, ... )
	local input = checkInput( ... )
	local choices = {}

	local slope = getSlope( x1, y1, x2, y2 )
	local intercept = getYIntercept( x1, y1, slope )

	local x3, y3, x4, y4
	if slope then
		x3, x4 = 1, 2
		y3, y4 = slope * x3 + intercept, slope * x4 + intercept
	else
		x3, x4 = x1, x1
		y3, y4 = y1, y2
	end

	for i = 1, #input, 2 do
		local x1, y1, x2, y2 = getLineSegmentIntersection( input[i], input[i + 1], cycle( input, i + 2 ), cycle( input, i + 3 ), x3, y3, x4, y4 )
		if x1 and not x2 then choices[#choices + 1] = { x1, y1 }
		elseif x1 and x2 then choices[#choices + 1] = { x1, y1, x2, y2 } end
        -- No need to check 2-point sets since they only intersect each poly line once.
	end

	local final = removeDuplicatePairs( choices )
	return #final > 0 and final or false
end

-- Returns if the line segment intersects the polygon.
-- x1, y1, x2, y2, polygonPoints
local function getPolygonSegmentIntersection( x1, y1, x2, y2, ... )
	local input = checkInput( ... )
	local choices = {}

	for i = 1, #input, 2 do
		local x1, y1, x2, y2 = getSegmentSegmentIntersection( input[i], input[i + 1], cycle( input, i + 2 ), cycle( input, i + 3 ), x1, y1, x2, y2 )
		if x1 and not x2 then choices[#choices + 1] = { x1, y1 }
		elseif x2 then choices[#choices + 1] = { x1, y1, x2, y2 } end
	end

	local final = removeDuplicatePairs( choices )
	return #final > 0 and final or false
end

-- Checks if the point lies INSIDE the polygon not on the polygon.
local function checkPolygonPoint( px, py, ... )
	local points = { unpack( checkInput( ... ) ) } -- Make a new table, as to not edit values of previous.

	local greatest, least = getGreatestPoint( points, 0 )
	if not isWithinBounds( least, py, greatest ) then return false end
	greatest, least = getGreatestPoint( points )
	if not isWithinBounds( least, px, greatest ) then return false end

	local count = 0
	for i = 1, #points, 2 do
		if checkFuzzy( points[i + 1], py ) then
			points[i + 1] = py + .001 -- Handles vertices that lie on the point.
            -- Not exactly mathematically correct, but a lot easier.
		end
		if points[i + 3] and checkFuzzy( points[i + 3], py ) then
			points[i + 3] = py + .001 -- Do not need to worry about alternate case, since points[2] has already been done.
		end
		local x1, y1 = points[i], points[i + 1]
		local x2, y2 = points[i + 2] or points[1], points[i + 3] or points[2]

		if getSegmentSegmentIntersection( px, py, greatest, py, x1, y1, x2, y2 ) then
			count = count + 1
		end
	end

	return count and count % 2 ~= 0
end

-- Returns if the line segment is fully or partially inside.
-- x1, y1, x2, y2, polygonPoints
local function isSegmentInsidePolygon( x1, y1, x2, y2, ... )
	local input = checkInput( ... )

	local choices = getPolygonSegmentIntersection( x1, y1, x2, y2, input ) -- If it's partially enclosed that's all we need.
	if choices then return true end

	if checkPolygonPoint( x1, y1, input ) or checkPolygonPoint( x2, y2, input ) then return true end
	return false
end

-- Returns whether two polygons intersect.
local function getPolygonPolygonIntersection( polygon1, polygon2 )
	local choices = {}

	for index1 = 1, #polygon1, 2 do
		local intersections = getPolygonSegmentIntersection( polygon1[index1], polygon1[index1 + 1], cycle( polygon1, index1 + 2 ), cycle( polygon1, index1 + 3 ), polygon2 )
		if intersections then
			for index2 = 1, #intersections do
				choices[#choices + 1] = intersections[index2]
			end
		end
	end

	for index1 = 1, #polygon2, 2 do
		local intersections = getPolygonSegmentIntersection( polygon2[index1], polygon2[index1 + 1], cycle( polygon2, index1 + 2 ), cycle( polygon2, index1 + 3 ), polygon1 )
		if intersections then
			for index2 = 1, #intersections do
				choices[#choices + 1] = intersections[index2]
			end
		end
	end

	choices = removeDuplicatePairs( choices )
	for i = #choices, 1, -1 do
		if type( choices[i][1] ) == 'table' then -- Remove co-linear pairs.
			table.remove( choices, i )
		end
	end

	return #choices > 0 and choices
end

-- Returns whether the circle intersects the polygon.
-- x, y, radius, polygonPoints
local function getPolygonCircleIntersection( x, y, radius, ... )
	local input = checkInput( ... )
	local choices = {}

	for i = 1, #input, 2 do
		local Type, x1, y1, x2, y2 = getCircleSegmentIntersection( x, y, radius, input[i], input[i + 1], cycle( input, i + 2 ), cycle( input, i + 3 ) )
		if x2 then
			choices[#choices + 1] = { Type, x1, y1, x2, y2 }
		elseif x1 then choices[#choices + 1] = { Type, x1, y1 } end
	end

	local final = removeDuplicates4Points( choices )

	return #final > 0 and final
end

-- Returns whether the circle is inside the polygon.
-- x, y, radius, polygonPoints
local function isCircleInsidePolygon( x, y, radius, ... )
	local input = checkInput( ... )
	return checkPolygonPoint( x, y, input )
end

-- Returns whether the polygon is inside the polygon.
local function isPolygonInsidePolygon( polygon1, polygon2 )
	local bool = false
	for i = 1, #polygon2, 2 do
		local result = false
		result = isSegmentInsidePolygon( polygon2[i], polygon2[i + 1], cycle( polygon2, i + 2 ), cycle( polygon2, i + 3 ), polygon1 )
		if result then bool = true; break end
	end
	return bool
end

-- Checks if a segment is completely inside a polygon
local function isSegmentCompletelyInsidePolygon( x1, y1, x2, y2, ... )
	local polygon = checkInput( ... )
	if not checkPolygonPoint( x1, y1, polygon )
	or not checkPolygonPoint( x2, y2, polygon )
	or getPolygonSegmentIntersection( x1, y1, x2, y2, polygon ) then
		return false
	end
	return true
end

-- Checks if a polygon is completely inside another polygon
local function isPolygonCompletelyInsidePolygon( polygon1, polygon2 )
	for i = 1, #polygon1, 2 do
		local x1, y1 = polygon1[i], polygon1[i + 1]
		local x2, y2 = polygon1[i + 2] or polygon1[1], polygon1[i + 3] or polygon1[2]
		if not isSegmentCompletelyInsidePolygon( x1, y1, x2, y2, polygon2 ) then
			return false
		end
	end
	return true
end

-------------- Circle w/ Polygons --------------
-- Gets if a polygon is completely within a circle
-- circleX, circleY, circleRadius, polygonPoints
local function isPolygonCompletelyInsideCircle( circleX, circleY, circleRadius, ... )
	local input = checkInput( ... )
	local function isDistanceLess( px, py, x, y, circleRadius ) -- Faster, does not use math.sqrt
		local distanceX, distanceY = px - x, py - y
		return distanceX * distanceX + distanceY * distanceY < circleRadius * circleRadius -- Faster. For comparing distances only.
	end

	for i = 1, #input, 2 do
		if not checkCirclePoint( input[i], input[i + 1], circleX, circleY, circleRadius ) then return false end
	end
	return true
end

-- Checks if a circle is completely within a polygon
-- circleX, circleY, circleRadius, polygonPoints
local function isCircleCompletelyInsidePolygon( circleX, circleY, circleRadius, ... )
	local input = checkInput( ... )
	if not checkPolygonPoint( circleX, circleY, ... ) then return false end

	local rad2 = circleRadius * circleRadius

	for i = 1, #input, 2 do
		local x1, y1 = input[i], input[i + 1]
		local x2, y2 = input[i + 2] or input[1], input[i + 3] or input[2]
		if distance2( x1, y1, circleX, circleY ) <= rad2 then return false end
		if getCircleSegmentIntersection( circleX, circleY, circleRadius, x1, y1, x2, y2 ) then return false end
	end
	return true
end -- }}}

-- Statistics ----------------------------------- {{{
-- Gets the average of a list of points
-- points
local function getMean( ... )
	local input = checkInput( ... )

	mean = getSummation( 1, #input,
		function( i, t )
			return input[i]
		end
	) / #input

	return mean
end

local function getMedian( ... )
	local input = checkInput( ... )

	table.sort( input )

	local median
	if #input % 2 == 0 then -- If you have an even number of terms, you need to get the average of the middle 2.
		median = getMean( input[#input / 2], input[#input / 2 + 1] )
	else
		median = input[#input / 2 + .5]
	end

	return median
end

-- Gets the mode of a number.
local function getMode( ... )
	local input = checkInput( ... )

	table.sort( input )
	local sorted = {}
	for i = 1, #input do
		local value = input[i]
		sorted[value] = sorted[value] and sorted[value] + 1 or 1
	end

	local occurrences, least = 0, {}
	for i, value in pairs( sorted ) do
		if value > occurrences then
			least = { i }
			occurrences = value
		elseif value == occurrences then
			least[#least + 1] = i
		end
	end

	if #least >= 1 then return least, occurrences
	else return false end
end

-- Gets the range of the numbers.
local function getRange( ... )
	local input = checkInput( ... )
	local high, low = math.max( unpack( input ) ), math.min( unpack( input ) )
	return high - low
end

-- Gets the variance of a set of numbers.
local function getVariance( ... )
	local input = checkInput( ... )
	local mean = getMean( ... )
	local sum = 0
	for i = 1, #input do
		sum = sum + ( mean - input[i] ) * ( mean - input[i] )
	end
	return sum / #input
end

-- Gets the standard deviation of a set of numbers.
local function getStandardDeviation( ... )
	return math.sqrt( getVariance( ... ) )
end

-- Gets the central tendency of a set of numbers.
local function getCentralTendency( ... )
	local mode, occurrences = getMode( ... )
	return mode, occurrences, getMedian( ... ), getMean( ... )
end

-- Gets the variation ratio of a data set.
local function getVariationRatio( ... )
	local input = checkInput( ... )
	local numbers, times = getMode( ... )
	times = times * #numbers -- Account for bimodal data
	return 1 - ( times / #input )
end

-- Gets the measures of dispersion of a data set.
local function getDispersion( ... )
	return getVariationRatio( ... ), getRange( ... ), getStandardDeviation( ... )
end -- }}}

return {
	_VERSION = 'MLib 0.10.0',
	_DESCRIPTION = 'A math and shape-intersection detection library for Lua',
	_URL = 'https://github.com/davisdude/mlib',
    point = {
        rotate = rotatePoint,
        scale = scalePoint,
    },
	line = {
		getLength = getLength,
		getMidpoint = getMidpoint,
		getSlope = getSlope,
		getPerpendicularSlope = getPerpendicularSlope,
		getYIntercept = getYIntercept,
		getIntersection = getLineLineIntersection,
		getClosestPoint = getClosestPoint,
		getSegmentIntersection = getLineSegmentIntersection,
		checkPoint = checkLinePoint,

		-- Aliases
		getDistance = getLength,
		getCircleIntersection = getCircleLineIntersection,
		getPolygonIntersection = getPolygonLineIntersection,
		getLineIntersection = getLineLineIntersection,
    },
    segment = {
        checkPoint = checkSegmentPoint,
		getPerpendicularBisector = getPerpendicularBisector,
        getIntersection = getSegmentSegmentIntersection,

        -- Aliases
        getCircleIntersection = getCircleSegmentIntersection,
        getPolygonIntersection = getPolygonSegmentIntersection,
        getLineIntersection = getLineSegmentIntersection,
        getSegmentIntersection = getSegmentSegmentIntersection,
        isSegmentCompletelyInsideCircle = isSegmentCompletelyInsideCircle,
        isSegmentCompletelyInsidePolygon = isSegmentCompletelyInsidePolygon,
	},
	math = {
		getRoot = getRoot,
		isPrime = isPrime,
		round = round,
		getSummation =	getSummation,
		getPercentOfChange = getPercentOfChange,
		getPercentage = getPercentage,
		getQuadraticRoots = getQuadraticRoots,
		getAngle = getAngle,
	},
	circle = {
		getArea = getCircleArea,
		checkPoint = checkCirclePoint,
		isPointOnCircle = isPointOnCircle,
		getCircumference = getCircumference,
		getLineIntersection = getCircleLineIntersection,
		getSegmentIntersection = getCircleSegmentIntersection,
		getCircleIntersection = getCircleCircleIntersection,
		isCircleCompletelyInside = isCircleCompletelyInsideCircle,
		isPolygonCompletelyInside = isPolygonCompletelyInsideCircle,
		isSegmentCompletelyInside = isSegmentCompletelyInsideCircle,

		-- Aliases
		getPolygonIntersection = getPolygonCircleIntersection,
		isCircleInsidePolygon = isCircleInsidePolygon,
		isCircleCompletelyInsidePolygon = isCircleCompletelyInsidePolygon,
	},
	polygon = {
		getSignedArea = getSignedPolygonArea,
		getArea = getPolygonArea,
		getTriangleHeight = getTriangleHeight,
		getCentroid = getCentroid,
		getLineIntersection = getPolygonLineIntersection,
		getSegmentIntersection = getPolygonSegmentIntersection,
		checkPoint = checkPolygonPoint,
		isSegmentInside = isSegmentInsidePolygon,
		getPolygonIntersection = getPolygonPolygonIntersection,
		getCircleIntersection = getPolygonCircleIntersection,
		isCircleInside = isCircleInsidePolygon,
		isPolygonInside = isPolygonInsidePolygon,
		isCircleCompletelyInside = isCircleCompletelyInsidePolygon,
		isSegmentCompletelyInside = isSegmentCompletelyInsidePolygon,
		isPolygonCompletelyInside = isPolygonCompletelyInsidePolygon,

		-- Aliases
		isCircleCompletelyOver = isPolygonCompletelyInsideCircle,
	},
	statistics = {
		getMean = getMean,
		getMedian = getMedian,
		getMode = getMode,
		getRange = getRange,
		getVariance = getVariance,
		getStandardDeviation = getStandardDeviation,
		getCentralTendency = getCentralTendency,
		getVariationRatio = getVariationRatio,
		getDispersion = getDispersion,
	},
}