diff options
Diffstat (limited to 'libs/windfield/mlib/README.md')
| -rw-r--r-- | libs/windfield/mlib/README.md | 890 |
1 files changed, 890 insertions, 0 deletions
diff --git a/libs/windfield/mlib/README.md b/libs/windfield/mlib/README.md new file mode 100644 index 0000000..6bbfdb2 --- /dev/null +++ b/libs/windfield/mlib/README.md @@ -0,0 +1,890 @@ +MLib +==== + +__MLib__ is a math and shape-intersection detection library written in Lua. It's aim is to be __robust__ and __easy to use__. + +__NOTE:__ +- I am (slowly) working on completely rewriting this in order to be easier to use and less bug-prone. You can check out the progress [here](../../tree/dev). +- I am currently slowing development of MLib while moving over to helping with [CPML](https://github.com/excessive/cpml). To discuss this, please comment [here](../../issues/12). + +If you are looking for a library that handles updating/collision responses for you, take a look at [hxdx](https://github.com/adonaac/hxdx). It uses MLib functions as well as Box2d to handle physics calculations. + +## Downloading +You can download the latest __stable__ version of MLib by downloading the latest [release](../../releases/). +You can download the latest __working__ version of MLib by downloading the latest [commit](../../commits/master/). Documentation will __only__ be updated upon releases, not upon commits. + +## Implementing +To use MLib, simply place [mlib.lua](mlib.lua) inside the desired folder in your project. Then use the `require 'path.to.mlib'` to use any of the functions. + +## Examples +If you don't have [LÖVE](https://love2d.org/) installed, you can download the .zip of the demo from the [Executables](Examples/Executables) folder and extract and run the .exe that way. +You can see some examples of the code in action [here](Examples). +All examples are done using the *awesome* engine of [LÖVE](https://love2d.org/). +To run them properly, download the [.love file](Examples/LOVE) and install LÖVE to your computer. +After that, make sure you set .love files to open with "love.exe". +For more, see [here](https://love2d.org/). + +## When should I use MLib? +- If you need to know exactly where two objects intersect. +- If you need general mathematical equations to be done. +- If you need very precise details about point intersections. + +## When should I __not__ use MLib? +- All of the objects in a platformer, or other game, for instance, should not be registered with MLib. Only ones that need very specific information. +- When you don't need precise information/odd shapes. + +## Specs +#### For Windows +If you run Windows and have Telescope in `%USERPROFILE%\Documents\GitHub` (you can also manually change the path in [test.bat](test.bat)) you can simply run [test.bat](test.bat) and it will display the results, and then clean up after it's finished. + +#### Default +Alternatively, you can find the tests [here](spec.lua). Keep in mind that you may need to change certain semantics to suit your OS. +You can run them via [Telescope](https://github.com/norman/telescope/) and type the following command in the command-line of the root folder: +``` +tsc -f specs.lua +``` +If that does not work, you made need to put a link to Lua inside of the folder for `telescope` and run the following command: +``` +lua tsc -f specs.lua +``` +If you encounter further errors, try to run the command line as an administrator (usually located in `C:\Windows\System32\`), then right-click on `cmd.exe` and select `Run as administrator`, then do +``` +cd C:\Path\to\telescope\ +``` +And __then__ run one of the above commands. If none of those work, just take my word for it that all the tests pass and look at this picture. + + +## Functions +- [mlib.line](#mlibline) + - [mlib.line.checkPoint](#mliblinecheckpoint) + - [mlib.line.getClosestPoint](#mliblinegetclosestpoint) + - [mlib.line.getYIntercept](#mliblinegetintercept) + - [mlib.line.getIntersection](#mliblinegetintersection) + - [mlib.line.getLength](#mliblinegetlength) + - [mlib.line.getMidpoint](#mliblinegetmidpoint) + - [mlib.line.getPerpendicularSlope](#mliblinegetperpendicularslope) + - [mlib.line.getSegmentIntersection](#mliblinegetsegmentintersection) + - [mlib.line.getSlope](#mliblinegetslope) +- [mlib.segment](#mlibsegment) + - [mlib.segment.checkPoint](#mlibsegmentcheckpoint) + - [mlib.segment.getPerpendicularBisector](#mlibsegmentgetperpendicularbisector) + - [mlib.segment.getIntersection](#mlibsegmentgetintersection) +- [mlib.polygon](#mlibpolygon) + - [mlib.polygon.checkPoint](#mlibpolygoncheckpoint) + - [mlib.polygon.getCentroid](#mlibpolygongetcentroid) + - [mlib.polygon.getCircleIntersection](#mlibpolygongetcircleintersection) + - [mlib.polygon.getLineIntersection](#mlibpolygongetlineintersection) + - [mlib.polygon.getPolygonArea](#mlibpolygongetpolygonarea) + - [mlib.polygon.getPolygonIntersection](#mlibpolygongetpolygonintersection) + - [mlib.polygon.getSegmentIntersection](#mlibpolygongetsegmentintersection) + - [mlib.polygon.getSignedPolygonArea](#mlibpolygongetsignedpolygonarea) + - [mlib.polygon.getTriangleHeight](#mlibpolygongettriangleheight) + - [mlib.polygon.isCircleInside](#mlibpolygoniscircleinside) + - [mlib.polygon.isCircleCompletelyInside](#mlibpolygoniscirclecompletelyinside) + - [mlib.polygon.isPolygonInside](#mlibpolygonispolygoninside) + - [mlib.polygon.isPolygonCompletelyInside](#mlibpolygonispolygoncompletelyinside) + - [mlib.polygon.isSegmentInside](#mlibpolygonissegmentinside) + - [mlib.polygon.isSegmentCompletelyInside](#mlibpolygonissegmentcompletelyinside) +- [mlib.circle](#mlibcircle) + - [mlib.circle.checkPoint](#mlibcirclecheckpoint) + - [mlib.circle.getArea](#mlibcirclegetarea) + - [mlib.circle.getCircleIntersection](#mlibcirclegetcircleintersection) + - [mlib.circle.getCircumference](#mlibcirclegetcircumference) + - [mlib.circle.getLineIntersection](#mlibcirclegetlineintersection) + - [mlib.circle.getSegmentIntersection](#mlibcirclegetsegmentintersection) + - [mlib.circle.isCircleCompletelyInside](#mlibcircleiscirclecompletelyinside) + - [mlib.circle.isCircleCompletelyInsidePolygon](#mlibcircleiscirclecompletelyinsidepolygon) + - [mlib.circle.isPointOnCircle](#mlibcircleispointoncircle) + - [mlib.circle.isPolygonCompletelyInside](#mlibcircleispolygoncompletelyinside) +- [mlib.statistics](#mlibstatistics) + - [mlib.statistics.getCentralTendency](#mlibstatisticsgetcentraltendency) + - [mlib.statistics.getDispersion](#mlibstatisticsgetdispersion) + - [mlib.statistics.getMean](#mlibstatisticsgetmean) + - [mlib.statistics.getMedian](#mlibstatisticsgetmedian) + - [mlib.statistics.getMode](#mlibstatisticsgetmode) + - [mlib.statistics.getRange](#mlibstatisticsgetrange) + - [mlib.statistics.getStandardDeviation](#mlibstatisticsgetstandarddeviation) + - [mlib.statistics.getVariance](#mlibstatisticsgetvariance) + - [mlib.statistics.getVariationRatio](#mlibstatisticsgetvariationratio) +- [mlib.math](#mlibmath) + - [mlib.math.getAngle](#mlibmathgetangle) + - [mlib.math.getPercentage](#mlibmathgetpercentage) + - [mlib.math.getPercentOfChange](#mlibmathgetpercentofchange) + - [mlib.math.getQuadraticRoots](#mlibmathgetquadraticroots) + - [mlib.math.getRoot](#mlibmathgetroot) + - [mlib.math.getSummation](#mlibmathgetsummation) + - [mlib.math.isPrime](#mlibmathisprime) + - [mlib.math.round](#mlibmathround) +- [Aliases](#aliases) + +#### mlib.line +- Deals with linear aspects, such as slope and length. + +##### mlib.line.checkPoint +- Checks if a point lies on a line. +- Synopsis: + - `onPoint = mlib.line.checkPoint( px, px, x1, y1, x2, y2 )` +- Arguments: + - `px`, `py`: Numbers. The x and y coordinates of the point being tested. + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates of the line being tested. +- Returns: + - `onPoint`: Boolean. + - `true` if the point is on the line. + - `false` if it does not. +- Notes: + - You cannot use the format `mlib.line.checkPoint( px, px, slope, intercept )` because this would lead to errors on vertical lines. + +##### mlib.line.getClosestPoint +- Gives the closest point to a line. +- Synopses: + - `cx, cy = mlib.line.getClosestPoint( px, py, x1, y1, x2, y2 )` + - `cx, cy = mlib.line.getClosestPoint( px, py, slope, intercept )` +- Arguments: + - `x`, `y`: Numbers. The x and y coordinates of the point. + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates on the line. + - `slope`, `intercept`: + - Numbers. The slope and y-intercept of the line. + - Booleans (`false`). The slope and y-intercept of a vertical line. +- Returns: + - `cx`, `cy`: Numbers. The closest points that lie on the line to the point. + +##### mlib.line.getYIntercept +- Gives y-intercept of the line. +- Synopses: + - `intercept, isVertical = mlib.line.getYIntercept( x1, y1, x2, y2 )` + - `intercept, isVertical = mlib.line.getYIntercept( x1, y1, slope )` +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates that lie on the line. + - `slope`: + - Number. The slope of the line. +- Returns: + - `intercept`: + - Number. The y-intercept of the line. + - Number. The `x1` coordinate of the line if the line is vertical. + - `isVertical`: + - Boolean. `true` if the line is vertical, `false` if the line is not vertical. + +##### mlib.line.getIntersection +- Gives the intersection of two lines. +- Synopses: + - `x, y = mlib.line.getIntersection( x1, y1, x2, y2, x3, y3, x4, y4 )` + - `x, y = mlib.line.getIntersection( slope1, intercept1, x3, y3, x4, y4 )` + - `x, y = mlib.line.getIntersection( slope1, intercept1, slope2, intercept2 )` +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates that lie on the first line. + - `x3`, `y3`, `x4`, `y4`: Numbers. Two x and y coordinates that lie on the second line. + - `slope1`, `intercept1`: + - Numbers. The slope and y-intercept of the first line. + - Booleans (`false`). The slope and y-intercept of the first line (if the first line is vertical). + - `slope2`, `intercept2`: + - Numbers. The slope and y-intercept of the second line. + - Booleans (`false`). The slope and y-intercept of the second line (if the second line is vertical). +- Returns: + - `x`, `y`: + - Numbers. The x and y coordinate where the lines intersect. + - Boolean: + - `true`, `nil`: The lines are collinear. + - `false`, `nil`: The lines are parallel and __not__ collinear. + +##### mlib.line.getLength +- Gives the distance between two points. +- Synopsis: + - `length = mlib.line.getLength( x1, y1, x2, y2 ) +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates. +- Returns: + - `length`: Number. The distance between the two points. + +##### mlib.line.getMidpoint +- Gives the midpoint of two points. +- Synopsis: + - `x, y = mlib.line.getMidpoint( x1, y1, x2, y2 )` +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates. +- Returns: + - `x`, `y`: Numbers. The midpoint x and y coordinates. + +##### mlib.line.getPerpendicularSlope +- Gives the perpendicular slope of a line. +- Synopses: + - `perpSlope = mlib.line.getPerpendicularSlope( x1, y1, x2, y2 )` + - `perpSlope = mlib.line.getPerpendicularSlope( slope )` +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates. + - `slope`: Number. The slope of the line. +- Returns: + - `perpSlope`: + - Number. The perpendicular slope of the line. + - Boolean (`false`). The perpendicular slope of the line (if the original line was horizontal). + +##### mlib.line.getSegmentIntersection +- Gives the intersection of a line segment and a line. +- Synopses: + - `x1, y1, x2, y2 = mlib.line.getSegmentIntersection( x1, y1, x2, y2, x3, y3, x4, y4 )` + - `x1, y1, x2, y2 = mlib.line.getSegmentIntersection( x1, y1, x2, y2, slope, intercept )` +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates that lie on the line segment. + - `x3`, `y3`, `x4`, `y4`: Numbers. Two x and y coordinates that lie on the line. + - `slope`, `intercept`: + - Numbers. The slope and y-intercept of the the line. + - Booleans (`false`). The slope and y-intercept of the line (if the line is vertical). +- Returns: + - `x1`, `y1`, `x2`, `y2`: + - Number, Number, Number, Number. + - The points of the line segment if the line and segment are collinear. + - Number, Number, Boolean (`nil`), Boolean (`nil`). + - The coordinate of intersection if the line and segment intersect and are not collinear. + - Boolean (`false`), Boolean (`nil`), Boolean (`nil`), + - Boolean (`nil`). If the line and segment don't intersect. + +##### mlib.line.getSlope +- Gives the slope of a line. +- Synopsis: + - `slope = mlib.line.getSlope( x1, y1, x2, y2 ) +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates. +- Returns: + - `slope`: + - Number. The slope of the line. + - Boolean (`false`). The slope of the line (if the line is vertical). + +#### mlib.segment +- Deals with line segments. + +##### mlib.segment.checkPoint +- Checks if a point lies on a line segment. +- Synopsis: + - `onSegment = mlib.segment.checkPoint( px, py, x1 y1, x2, y2 )` +- Arguments: + - `px`, `py`: Numbers. The x and y coordinates of the point being checked. + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates. +- Returns: + - `onSegment`: Boolean. + - `true` if the point lies on the line segment. + - `false` if the point does not lie on the line segment. + +##### mlib.segment.getPerpendicularBisector +- Gives the perpendicular bisector of a line. +- Synopsis: + - `x, y, slope = mlib.segment.getPerpendicularBisector( x1, y1, x2, y2 )` +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates. +- Returns: + - `x`, `y`: Numbers. The midpoint of the line. + - `slope`: + - Number. The perpendicular slope of the line. + - Boolean (`false`). The perpendicular slope of the line (if the original line was horizontal). + +##### mlib.segment.getIntersection +- Checks if two line segments intersect. +- Synopsis: + - `cx1, cy1, cx2, cy2 = mlib.segment.getIntersection( x1, y1, x2, y2, x3, y3 x4, y4 )` +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates of the first line segment. + - `x3`, `y3`, `x4`, `y4`: Numbers. Two x and y coordinates of the second line segment. +- Returns: + - `cx1`, `cy1`, `cx2`, `cy2`: + - Number, Number, Number, Number. + - The points of the resulting intersection if the line segments are collinear. + - Number, Number, Boolean (`nil`), Boolean (`nil`). + - The point of the resulting intersection if the line segments are not collinear. + - Boolean (`false`), Boolean (`nil`), Boolean (`nil`) , Boolean (`nil`). + - If the line segments don't intersect. + +#### mlib.polygon +- Handles aspects involving polygons. + +##### mlib.polygon.checkPoint +- Checks if a point is inside of a polygon. +- Synopses: + - `inPolygon = mlib.polygon.checkPoint( px, py, vertices )` + - `inPolygon = mlib.polygon.checkPoint( px, py, ... )` +- Arguments: + - `px`, `py`: Numbers. The x and y coordinate of the point being checked. + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `inPolygon`: Boolean. + - `true` if the point is inside the polygon. + - `false` if the point is not inside the polygon. + +##### mlib.polygon.getCentroid +- Returns the centroid of the polygon. +- Synopses: + - `cx, cy = mlib.polygon.getCentroid( vertices )` + - `cx, cy = mlib.polygon.getCentroid( ... )` +- Arguments: + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `cx`, `cy`: Numbers. The x and y coordinates of the centroid. + +##### mlib.polygon.getCircleIntersection +- Returns the coordinates of where a circle intersects a polygon. +- Synopses: + - `intersections = mlib.polygon.getCircleIntersection( cx, cy, radius, vertices )` + - `intersections = mlib.polygon.getCircleIntersection( cx, cy, radius, ... ) +- Arguments: + - `cx`, `cy`: Number. The coordinates of the center of the circle. + - `radius`: Number. The radius of the circle. + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `intersections`: Table. Contains the intersections and type. +- Example: +```lua +local tab = _.polygon.getCircleIntersection( 5, 5, 1, 4, 4, 6, 4, 6, 6, 4, 6 ) +for i = 1, # tab do + print( i .. ':', unpack( tab[i] ) ) +end +-- 1: tangent 5 4 +-- 2: tangent 6 5 +-- 3: tangent 5 6 +-- 4: tagnent 4 5 +``` +- For more see [mlib.circle.getSegmentIntersection](#mlibcirclegetsegmentintersection) or the [specs](spec.lua# L676) + +##### mlib.polygon.getLineIntersection +- Returns the coordinates of where a line intersects a polygon. +- Synopses: + - `intersections = mlib.polygon.getLineIntersection( x1, y1, x2, y2, vertices )` + - `intersections = mlib.polygon.getLineIntersection( x1, y1, x2, y2, ... ) +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates. + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `intersections`: Table. Contains the intersections. +- Notes: + - With collinear lines, they are actually broken up. i.e. `{ 0, 4, 0, 0 }` would become `{ 0, 4 }, { 0, 0 }`. + +##### mlib.polygon.getPolygonArea +- Gives the area of a polygon. +- Synopses: + - `area = mlib.polygon.getArea( vertices )` + - `area = mlib.polygon.getArea( ... ) +- Arguments: + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `area`: Number. The area of the polygon. + +##### mlib.polygon.getPolygonIntersection +- Gives the intersection of two polygons. +- Synopsis: + - `intersections = mlib.polygon.getPolygonIntersections( polygon1, polygon2 )` +- Arguments: + - `polygon1`: Table. The vertices of the first polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `polygon2`: Table. The vertices of the second polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` +- Returns: + - `intersections`: Table. A table of the points of intersection. + +##### mlib.polygon.getSegmentIntersection +- Returns the coordinates of where a line segmeing intersects a polygon. +- Synopses: + - `intersections = mlib.polygon.getSegmentIntersection( x1, y1, x2, y2, vertices )` + - `intersections = mlib.polygon.getSegmentIntersection( x1, y1, x2, y2, ... ) +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates. + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `intersections`: Table. Contains the intersections. +- Notes: + - With collinear line segments, they are __not__ broken up. See the [specs](spec.lua# L508) for more. + +##### mlib.polygon.getSignedPolygonArea +- Gets the signed area of the polygon. If the points are ordered counter-clockwise the area is positive. If the points are ordered clockwise the number is negative. +- Synopses: + - `area = mlib.polygon.getLineIntersection( vertices )` + - `area = mlib.polygon.getLineIntersection( ... ) +- Arguments: + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `area`: Number. The __signed__ area of the polygon. If the points are ordered counter-clockwise the area is positive. If the points are ordered clockwise the number is negative. + +##### mlib.polygon.getTriangleHeight +- Gives the height of a triangle. +- Synopses: + - `height = mlib.polygon.getTriangleHeigh( base, x1, y1, x2, y2, x3, y3 )` + - `height = mlib.polygon.getTriangleHeight( base, area )` +- Arguments: + - `base`: Number. The length of the base of the triangle. + - `x1`, `y1`, `x2`, `y2`, `x3`, `y3`: Numbers. The x and y coordinates of the triangle. + - `area`: Number. The regular area of the triangle. __Not__ the signed area. +- Returns: + - `height`: Number. The height of the triangle. + +##### mlib.polygon.isCircleInside +- Checks if a circle is inside the polygon. +- Synopses: + - `inPolygon = mlib.polygon.isCircleInside( cx, cy, radius, vertices )` + - `inPolygon = mlib.polygon.isCircleInside( cx, cy, radius, ... )` +- Arguments: + - `cx`, `cy`: Numbers. The x and y coordinates for the center of the circle. + - `radius`: Number. The radius of the circle. + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `inPolygon`: Boolean. + - `true` if the circle is inside the polygon. + - `false` if the circle is not inside the polygon. +- Notes: + - Only returns true if the center of the circle is inside the circle. + +##### mlib.polygon.isCircleCompletelyInside +- Checks if a circle is completely inside the polygon. +- Synopses: + - `inPolygon = mlib.polygon.isCircleCompletelyInside( cx, cy, radius, vertices )` + - `inPolygon = mlib.polygon.isCircleCompletelyInside( cx, cy, radius, ... )` +- Arguments: + - `cx`, `cy`: Numbers. The x and y coordinates for the center of the circle. + - `radius`: Number. The radius of the circle. + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `inPolygon`: Boolean. + - `true` if the circle is __completely__ inside the polygon. + - `false` if the circle is not inside the polygon. + +##### mlib.polygon.isPolygonInside +- Checks if a polygon is inside a polygon. +- Synopsis: + - `inPolygon = mlib.polygon.isPolygonInside( polygon1, polygon2 )` +- Arguments: + - `polygon1`: Table. The vertices of the first polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `polygon2`: Table. The vertices of the second polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` +- Returns: + - `inPolygon`: Boolean. + - `true` if the `polygon2` is inside of `polygon1`. + - `false` if `polygon2` is not inside of `polygon2`. +- Notes: + - Returns true as long as any of the line segments of `polygon2` are inside of the `polygon1`. + +##### mlib.polygon.isPolygonCompletelyInside +- Checks if a polygon is completely inside a polygon. +- Synopsis: + - `inPolygon = mlib.polygon.isPolygonCompletelyInside( polygon1, polygon2 )` +- Arguments: + - `polygon1`: Table. The vertices of the first polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `polygon2`: Table. The vertices of the second polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` +- Returns: + - `inPolygon`: Boolean. + - `true` if the `polygon2` is __completely__ inside of `polygon1`. + - `false` if `polygon2` is not inside of `polygon2`. + +##### mlib.polygon.isSegmentInside +- Checks if a line segment is inside a polygon. +- Synopses: + - `inPolygon = mlib.polygon.isSegmentInside( x1, y1, x2, y2, vertices )` + - `inPolygon = mlib.polygon.isSegmentInside( x1, y1, x2, y2, ... )` +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. The x and y coordinates of the line segment. + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `inPolygon`: Boolean. + - `true` if the line segment is inside the polygon. + - `false` if the line segment is not inside the polygon. +- Note: + - Only one of the points has to be in the polygon to be considered 'inside' of the polygon. + - This is really just a faster version of [mlib.polygon.getPolygonIntersection](#mlibpolygongetpolygonintersection) that does not give the points of intersection. + +##### mlib.polygon.isSegmentCompletelyInside +- Checks if a line segment is completely inside a polygon. +- Synopses: + - `inPolygon = mlib.polygon.isSegmentCompletelyInside( x1, y1, x2, y2, vertices )` + - `inPolygon = mlib.polygon.isSegmentCompletelyInside( x1, y1, x2, y2, ... )` +- Arguments: + - `x1`, `y1`, `x2`, `y2`: Numbers. The x and y coordinates of the line segment. + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `inPolygon`: Boolean. + - `true` if the line segment is __completely__ inside the polygon. + - `false` if the line segment is not inside the polygon. + +#### mlib.circle +- Handles aspects involving circles. + +##### mlib.circle.checkPoint +- Checks if a point is on the inside or on the edge the circle. +- Synopsis: + - `inCircle = mlib.circle.checkPoint( px, px, cx, cy, radius )` +- Arguments: + - `px`, `py`: Numbers. The x and y coordinates of the point being tested. + - `cx`, `cy`: Numbers. The x and y coordinates of the center of the circle. + - `radius`: Number. The radius of the circle. +- Returns: + - `inCircle`: Boolean. + - `true` if the point is inside or on the circle. + - `false` if the point is outside of the circle. + +##### mlib.circle.getArea +- Gives the area of a circle. +- Synopsis: + - `area = mlib.circle.getArea( radius )` +- Arguments: + - `radius`: Number. The radius of the circle. +- Returns: + - `area`: Number. The area of the circle. + +##### mlib.circle.getCircleIntersection +- Gives the intersections of two circles. +- Synopsis: + - `intersections = mlib.circle.getCircleIntersection( c1x, c1y, radius1, c2x, c2y, radius2 ) +- Arguments: + - `c1x`, `c1y`: Numbers. The x and y coordinate of the first circle. + - `radius1`: Number. The radius of the first circle. + - `c2x`, `c2y`: Numbers. The x and y coordinate of the second circle. + - `radius2`: Number. The radius of the second circle. +- Returns: + - `intersections`: Table. A table that contains the type and where the circle collides. See the [specs](spec.lua# L698) for more. + +##### mlib.circle.getCircumference +- Returns the circumference of a circle. +- Synopsis: + - `circumference = mlib.circle.getCircumference( radius )` +- Arguments: + - `radius`: Number. The radius of the circle. +- Returns: + - `circumference`: Number. The circumference of a circle. + +##### mlib.circle.getLineIntersection +- Returns the intersections of a circle and a line. +- Synopsis: + - `intersections = mlib.circle.getLineIntersections( cx, cy, radius, x1, y1, x2, y2 )` +- Arguments: + - `cx`, `cy`: Numbers. The x and y coordinates for the center of the circle. + - `radius`: Number. The radius of the circle. + - `x1`, `y1`, `x2`, `y2`: Numbers. Two x and y coordinates the lie on the line. +- Returns: + - `intersections`: Table. A table with the type and where the intersections happened. Table is formatted: + - `type`, `x1`, `y1`, `x2`, `y2` + - String (`'secant'`), Number, Number, Number, Number + - The numbers are the x and y coordinates where the line intersects the circle. + - String (`'tangent'`), Number, Number, Boolean (`nil`), Boolean (`nil`) + - `x1` and `x2` represent where the line intersects the circle. + - Boolean (`false`), Boolean (`nil`), Boolean (`nil`), Boolean (`nil`), Boolean (`nil`) + - No intersection. + - For more see the [specs](spec.lua# L660). + +##### mlib.circle.getSegmentIntersection +- Returns the intersections of a circle and a line segment. +- Synopsis: + - `intersections = mlib.circle.getSegmentIntersections( cx, cy, radius, x1, y1, x2, y2 )` +- Arguments: + - `cx`, `cy`: Numbers. The x and y coordinates for the center of the circle. + - `radius`: Number. The radius of the circle. + - `x1`, `y1`, `x2`, `y2`: Numbers. The two x and y coordinates of the line segment. +- Returns: + - `intersections`: Table. A table with the type and where the intersections happened. Table is formatted: + - `type`, `x1`, `y1`, `x2`, `y2` + - String (`'chord'`), Number, Number, Number, Number + - The numbers are the x and y coordinates where the line segment is on both edges of the circle. + - String (`'enclosed'`), Number, Number, Number, Number + - The numbers are the x and y coordinates of the line segment if it is fully inside of the circle. + - String (`'secant'`), Number, Number, Number, Number + - The numbers are the x and y coordinates where the line segment intersects the circle. + - String (`'tangent'`), Number, Number, Boolean (`nil`), Boolean (`nil`) + - `x1` and `x2` represent where the line segment intersects the circle. + - Boolean (`false`), Boolean (`nil`), Boolean (`nil`), Boolean (`nil`), Boolean (`nil`) + - No intersection. + - For more see the [specs](spec.lua# L676). + +##### mlib.circle.isCircleCompletelyInside +- Checks if one circle is completely inside of another circle. +- Synopsis: + - `completelyInside = mlib.circle.isCircleCompletelyInside( c1x, c1y, c1radius, c2x, c2y, c2radius )` +- Arguments: + - `c1x`, `c1y`: Numbers. The x and y coordinates of the first circle. + - `c1radius`: Number. The radius of the first circle. + - `c2x`, `c2y`: Numbers. The x and y coordinates of the second circle. + - `c2radius`: Number. The radius of the second circle. +- Returns: + - `completelyInside`: Boolean. + - `true` if circle1 is inside of circle2. + - `false` if circle1 is not __completely__ inside of circle2. + +##### mlib.circle.isCircleCompletelyInsidePolygon +- Checks if a circle is completely inside the polygon. +- Synopses: + - `inPolygon = mlib.polygon.isCircleCompletelyInside( cx, cy, radius, vertices )` + - `inPolygon = mlib.polygon.isCircleCompletelyInside( cx, cy, radius, ... )` +- Arguments: + - `cx`, `cy`: Numbers. The x and y coordinates for the center of the circle. + - `radius`: Number. The radius of the circle. + - `vertices`: Table. The vertices of the polygon in the format `{ x1, y1, x2, y2, x3, y3, ... }` + - `...`: Numbers. The x and y coordinates of the polygon. (Same as using `unpack( vertices )`) +- Returns: + - `inPolygon`: Boolean. + - `true` if the circle is __completely__ inside the polygon. + - `false` if the circle is not inside the polygon. + +##### mlib.circle.isPointOnCircle +- Checks if a point is __exactly__ on the edge of the circle. +- Synopsis: + - `onCircle = mlib.circle.checkPoint( px, px, cx, cy, radius )` +- Arguments: + - `px`, `py`: Numbers. The x and y coordinates of the point being tested. + - `cx`, `cy`: Numbers. The x and y coordinates of the center of the circle. + - `radius`: Number. The radius of the circle. +- Returns: + - `onCircle`: Boolean. + - `true` if the point is on the circle. + - `false` if the point is on the inside or outside of the circle. +- Notes: + - Will return false if the point is inside __or__ outside of the circle. + +##### mlib.circle.isPolygonCompletelyInside +- Checks if a polygon is completely inside of a circle. +- Synopsis: + - `completelyInside = mlib.circle.isPolygonCompletelyInside( circleX, circleY, circleRadius, vertices )` + - `completelyInside = mlib.circle.isPolygonCompletelyInside( circleX, circleY, circleRadius, ... )` +- Arguments: + - `circleX`, `circleY`: Numbers. The x and y coordinates of the circle. + - `circleRadius`: Number. The radius of the circle. + - `vertices`: Table. A table containing all of the vertices of the polygon. + - `...`: Numbers. All of the points of the polygon. +- Returns: + - `completelyInside`: Boolean. + - `true` if the polygon is inside of the circle. + - `false` if the polygon is not __completely__ inside of the circle. + +#### mlib.statistics +- Handles statistical aspects of math. + +##### mlib.statistics.getCentralTendency +- Gets the central tendency of the data. +- Synopses: + - `modes, occurrences, median, mean = mlib.statistics.getCentralTendency( data )` + - `modes, occurrences, median, mean = mlib.statistics.getCentralTendency( ... )` +- Arguments: + - `data`: Table. A table containing the values of data. + - `...`: Numbers. All of the numbers in the data set. +- Returns: + - `modes, occurrences`: Table, Number. The modes of the data and the number of times it occurs. See [mlib.statistics.getMode](#mlibstatisticsgetmode). + - `median`: Number. The median of the data set. + - `mean`: Number. The mean of the data set. + +##### mlib.statistics.getDispersion +- Gets the dispersion of the data. +- Synopses: + - `variationRatio, range, standardDeviation = mlib.statistics.getDispersion( data )` + - `variationRatio, range, standardDeviation = mlib.statistics.getDispersion( ... )` +- Arguments: + - `data`: Table. A table containing the values of data. + - `...`: Numbers. All of the numbers in the data set. +- Returns: + - `variationRatio`: Number. The variation ratio of the data set. + - `range`: Number. The range of the data set. + - `standardDeviation`: Number. The standard deviation of the data set. + +##### mlib.statistics.getMean +- Gets the arithmetic mean of the data. +- Synopses: + - `mean = mlib.statistics.getMean( data )` + - `mean = mlib.statistics.getMean( ... )` +- Arguments: + - `data`: Table. A table containing the values of data. + - `...`: Numbers. All of the numbers in the data set. +- Returns: + - `mean`: Number. The arithmetic mean of the data set. + +##### mlib.statistics.getMedian +- Gets the median of the data set. +- Synopses: + - `median = mlib.statistics.getMedian( data )` + - `median = mlib.statistics.getMedian( ... )` +- Arguments: + - `data`: Table. A table containing the values of data. + - `...`: Numbers. All of the numbers in the data set. +- Returns: + - `median`: Number. The median of the data. + +##### mlib.statistics.getMode +- Gets the mode of the data set. +- Synopses: + - `mode, occurrences = mlib.statistics.getMode( data )` + - `mode, occurrences = mlib.statistics.getMode( ... )` +- Arguments: + - `data`: Table. A table containing the values of data. + - `...`: Numbers. All of the numbers in the data set. +- Returns: + - `mode`: Table. The mode(s) of the data. + - `occurrences`: Number. The number of time the mode(s) occur. + +##### mlib.statistics.getRange +- Gets the range of the data set. +- Synopses: + - `range = mlib.statistics.getRange( data )` + - `range = mlib.statistics.getRange( ... )` +- Arguments: + - `data`: Table. A table containing the values of data. + - `...`: Numbers. All of the numbers in the data set. +- Returns: + - `range`: Number. The range of the data. + +##### mlib.statistics.getStandardDeviation +- Gets the standard deviation of the data. +- Synopses: + - `standardDeviation = mlib.statistics.getStandardDeviation( data )` + - `standardDeviation = mlib.statistics.getStandardDeviation( ... )` +- Arguments: + - `data`: Table. A table containing the values of data. + - `...`: Numbers. All of the numbers in the data set. +- Returns: + - `standardDeviation`: Number. The standard deviation of the data set. + +##### mlib.statistics.getVariance +- Gets the variation of the data. +- Synopses: + - `variance = mlib.statistics.getVariance( data )` + - `variance = mlib.statistics.getVariance( ... )` +- Arguments: + - `data`: Table. A table containing the values of data. + - `...`: Numbers. All of the numbers in the data set. +- Returns: + - `variance`: Number. The variation of the data set. + +##### mlib.statistics.getVariationRatio +- Gets the variation ratio of the data. +- Synopses: + - `variationRatio = mlib.statistics.getVariationRatio( data )` + - `variationRatio = mlib.statistics.getVariationRatio( ... )` +- Arguments: + - `data`: Table. A table containing the values of data. + - `...`: Numbers. All of the numbers in the data set. +- Returns: + - `variationRatio`: Number. The variation ratio of the data set. + +#### mlib.math +- Miscellaneous functions that have no home. + +##### mlib.math.getAngle +- Gets the angle between three points. +- Synopsis: + - `angle = mlib.math.getAngle( x1, y1, x2, y2, x3, y3 )` +- Arguments: + - `x1`, `y1`: Numbers. The x and y coordinates of the first point. + - `x2`, `y2`: Numbers. The x and y coordinates of the vertex of the two points. + - `x3`, `y3`: Numbers. The x and y coordinates of the second point. + +##### mlib.math.getPercentage +- Gets the percentage of a number. +- Synopsis: + - `percentage = mlib.math.getPercentage( percent, number )` +- Arguments: + - `percent`: Number. The decimal value of the percent (i.e. 100% is 1, 50% is .5). + - `number`: Number. The number to get the percentage of. +- Returns: + - `percentage`: Number. The `percent`age or `number`. + +##### mlib.math.getPercentOfChange +- Gets the percent of change from one to another. +- Synopsis: + - `change = mlib.math.getPercentOfChange( old, new )` +- Arguments: + - `old`: Number. The original number. + - `new`: Number. The new number. +- Returns: + - `change`: Number. The percent of change from `old` to `new`. + +##### mlib.math.getQuadraticRoots +- Gets the quadratic roots of the the equation. +- Synopsis: + - `root1, root2 = mlib.math.getQuadraticRoots( a, b, c )` +- Arguments: + - `a`, `b`, `c`: Numbers. The a, b, and c values of the equation `a * x ^ 2 + b * x ^ 2 + c`. +- Returns: + - `root1`, `root2`: Numbers. The roots of the equation (where `a * x ^ 2 + b * x ^ 2 + c = 0`). + +##### mlib.math.getRoot +- Gets the `n`th root of a number. +- Synopsis: + - `x = mlib.math.getRoot( number, root )` +- Arguments: + - `number`: Number. The number to get the root of. + - `root`: Number. The root. +- Returns: + - `x`: The `root`th root of `number`. +- Example: +```lua +local a = mlib.math.getRoot( 4, 2 ) -- Same as saying 'math.pow( 4, .5 )' or 'math.sqrt( 4 )' in this case. +local b = mlib.math.getRoot( 27, 3 ) + +print( a, b ) --> 2, 3 +``` + - For more, see the [specs](spec.lua# L860). + +##### mlib.math.getSummation +- Gets the summation of numbers. +- Synopsis: + - `summation = mlib.math.getSummation( start, stop, func )` +- Arguments: + - `start`: Number. The number at which to start the summation. + - `stop`: Number. The number at which to stop the summation. + - `func`: Function. The method to add the numbers. + - Arguments: + - `i`: Number. Index. + - `previous`: Table. The previous values used. +- Returns: + - `Summation`: Number. The summation of the numbers. + - For more, see the [specs](spec.lua# L897). + +##### mlib.math.isPrime +- Checks if a number is prime. +- Synopsis: + - `isPrime = mlib.math.isPrime( x )` +- Arguments: + - `x`: Number. The number to check if it's prime. +- Returns: + - `isPrime`: Boolean. + - `true` if the number is prime. + - `false` if the number is not prime. + +##### mlib.math.round +- Rounds a number to the given decimal place. +- Synopsis: + - `rounded = mlib.math.round( number, [place] ) +- Arguments: + - `number`: Number. The number to round. + - `place (1)`: Number. The decimal place to round to. Defaults to 1. +- Returns: + - The rounded number. + - For more, see the [specs](spec.lua# L881). + +#### Aliases +| Alias | Corresponding Function | +| ----------------------------------------------|:---------------------------------------------------------------------------------:| +| milb.line.getDistance | [mlib.line.getLength](#mliblinegetlength) | +| mlib.line.getCircleIntersection | [mlib.circle.getLineIntersection](#mlibcirclegetlineintersection) | +| milb.line.getPolygonIntersection | [mlib.polygon.getLineIntersection](#mlibpolygongetlineintersection) | +| mlib.line.getLineIntersection | [mlib.line.getIntersection](#mliblinegetintersection) | +| mlib.segment.getCircleIntersection | [mlib.circle.getSegmentIntersection](#mlibcirclegetsegmentintersection) | +| milb.segment.getPolygonIntersection | [mlib.pollygon.getSegmentIntersection](#mlibpollygongetsegmentintersection) | +| mlib.segment.getLineIntersection | [mlib.line.getSegmentIntersection](#mliblinegetsegmentintersection) | +| mlib.segment.getSegmentIntersection | [mlib.segment.getIntersection](#mlibsegmentgetintersection) | +| milb.segment.isSegmentCompletelyInsideCircle | [mlib.circle.isSegmentCompletelyInside](#mlibcircleissegmentcompletelyinside) | +| mlib.segment.isSegmentCompletelyInsidePolygon | [mlib.polygon.isSegmentCompletelyInside](#mlibpolygonissegmentcompletelyinside) | +| mlib.circle.getPolygonIntersection | [mlib.polygon.getCircleIntersection](#mlibpolygongetcircleintersection) | +| mlib.circle.isCircleInsidePolygon | [mlib.polygon.isCircleInside](#mlibpolygoniscircleinside) | +| mlib.circle.isCircleCompletelyInsidePolygon | [mlib.polygon.isCircleCompletelyInside](#mlibpolygoniscirclecompletelyinside) | +| mlib.polygon.isCircleCompletelyOver | [mlib.circleisPolygonCompletelyInside](#mlibcircleispolygoncompletelyinside) | + +## 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 at gmail.com |