Vendor tcllib linear algebra

1 files changed, 818 insertions, 0 deletions

diff --git a/vendor/math/math_geometry.man b/vendor/math/math_geometry.man
new file mode 100644
index 00000000..d9d4c1ad
--- /dev/null
+++ b/vendor/math/math_geometry.man
@@ -0,0 +1,818 @@
+[comment {-*- tcl -*- doctools manpage}]
+[manpage_begin math::geometry n 1.4.1]
+[keywords angle]
+[keywords distance]
+[keywords line]
+[keywords math]
+[keywords {plane geometry}]
+[keywords point]
+[copyright {2001 by Ideogramic ApS and other parties}]
+[copyright {2010 by Andreas Kupries}]
+[copyright {2010 by Kevin Kenny}]
+[copyright {2018 by Arjen Markus}]
+[copyright {2020 by Manfred Rosenberger}]
+[moddesc   {Tcl Math Library}]
+[titledesc {Geometrical computations}]
+[category  Mathematics]
+[require Tcl [opt 8.5]]
+[require math::geometry [opt 1.4.1]]
+
+[description]
+[para]
+The [package math::geometry] package is a collection of functions for
+computations and manipulations on two-dimensional geometrical objects,
+such as points, lines and polygons.
+
+[para]
+The geometrical objects are implemented as plain lists of coordinates.
+For instance a line is defined by a list of four numbers, the x- and
+y-coordinate of a first point and the x- and y-coordinates of a second
+point on the line.
+
+[para]
+[emph Note:] In version 1.4.0 an inconsistency was repaired - see [uri https://core.tcl-lang.org/tcllib/tktview?name=fb4812f82b].
+More in [sectref "COORDINATE SYSTEM"]
+
+[para]
+The various types of object are recognised by the number of coordinate
+pairs and the context in which they are used: a list of four elements
+can be regarded as an infinite line, a finite line segment but also
+as a polyline of one segment and a point set of two points.
+
+[para]
+Currently the following types of objects are distinguished:
+[list_begin itemized]
+[item]
+[emph point] - a list of two coordinates representing the x- and
+y-coordinates respectively.
+
+[item]
+[emph line] - a list of four coordinates, interpreted as the x- and
+y-coordinates of two distinct points on the line.
+
+[item]
+[emph "line segment"] - a list of four coordinates, interpreted as the
+x- and y-coordinates of the first and the last points on the line
+segment.
+
+[item]
+[emph "polyline"] - a list of an even number of coordinates,
+interpreted as the x- and y-coordinates of an ordered set of points.
+
+[item]
+[emph "polygon"] - like a polyline, but the implicit assumption is that
+the polyline is closed (if the first and last points do not coincide,
+the missing segment is automatically added).
+
+[item]
+[emph "point set"] - again a list of an even number of coordinates, but
+the points are regarded without any ordering.
+
+[item]
+[emph "circle"] - a list of three numbers, the first two are the coordinates of the
+centre and the third is the radius.
+
+[list_end]
+
+
+[section "PROCEDURES"]
+
+The package defines the following public procedures:
+
+[list_begin definitions]
+
+[call [cmd ::math::geometry::+] [arg point1] [arg point2]]
+
+Compute the sum of the two vectors given as points and return it.
+The result is a vector as well.
+
+
+[call [cmd ::math::geometry::-] [arg point1] [arg point2]]
+
+Compute the difference (point1 - point2) of the two vectors
+given as points and return it. The result is a vector as well.
+
+
+[call [cmd ::math::geometry::p] [arg x] [arg y]]
+
+Construct a point from its coordinates and return it as the
+result of the command.
+
+
+[call [cmd ::math::geometry::distance] [arg point1] [arg point2]]
+
+Compute the distance between the two points and return it as the
+result of the command. This is in essence the same as
+
+[example {
+    math::geometry::length [math::geomtry::- point1 point2]
+}]
+
+
+[call [cmd ::math::geometry::length] [arg point]]
+
+Compute the length of the vector and return it as the
+result of the command.
+
+
+[call [cmd ::math::geometry::s*] [arg factor] [arg point]]
+
+Scale the vector by the factor and return it as the
+result of the command. This is a vector as well.
+
+
+[call [cmd ::math::geometry::direction] [arg angle]]
+
+Given the angle in degrees this command computes and returns
+the unit vector pointing into this direction. The vector for
+angle == 0 points to the right (east), and for angle == 90 up (north).
+
+
+[call [cmd ::math::geometry::h] [arg length]]
+
+Returns a horizontal vector on the X-axis of the specified length.
+Positive lengths point to the right (east).
+
+
+[call [cmd ::math::geometry::v] [arg length]]
+
+Returns a vertical vector on the Y-axis of the specified length.
+Positive lengths point down (south).
+
+
+[call [cmd ::math::geometry::between] [arg point1] [arg point2] [arg s]]
+
+Compute the point which is at relative distance [arg s] between the two
+points and return it as the result of the command. A relative distance of
+[const 0] returns [arg point1], the distance [const 1] returns [arg point2].
+Distances < 0 or > 1 extrapolate along the line between the two point.
+
+
+[call [cmd ::math::geometry::octant] [arg point]]
+
+Compute the octant of the circle the point is in and return it as the result
+of the command. The possible results are
+
+[list_begin enum]
+[enum] east
+[enum] northeast
+[enum] north
+[enum] northwest
+[enum] west
+[enum] southwest
+[enum] south
+[enum] southeast
+[list_end]
+
+Each octant is the arc of the circle +/- 22.5 degrees from the cardinal direction
+the octant is named for.
+
+
+[call [cmd ::math::geometry::rect] [arg nw] [arg se]]
+
+Construct a rectangle from its northwest and southeast corners and return
+it as the result of the command.
+
+
+[call [cmd ::math::geometry::nwse] [arg rect]]
+
+Extract the northwest and southeast corners of the rectangle and return
+them as the result of the command (a 2-element list containing the
+points, in the named order).
+
+
+[call [cmd ::math::geometry::angle] [arg line]]
+
+Calculate the angle from the positive x-axis to a given line
+(in two dimensions only).
+
+[list_begin arguments]
+[arg_def list line] Coordinates of the line
+[list_end]
+
+
+[call [cmd ::math::geometry::angleBetween] [arg vector1] [arg vector2]]
+
+Calculate the angle between two vectors (in degrees)
+
+[list_begin arguments]
+[arg_def list vector1] First vector
+[arg_def list vector2] Second vector
+[list_end]
+
+
+[call [cmd ::math::geometry::inproduct] [arg vector1] [arg vector2]]
+
+Calculate the inner product of two vectors
+
+[list_begin arguments]
+[arg_def list vector1] First vector
+[arg_def list vector2] Second vector
+[list_end]
+
+
+[call [cmd ::math::geometry::areaParallellogram] [arg vector1] [arg vector2]]
+
+Calculate the area of the parallellogram with the two vectors as its sides
+
+[list_begin arguments]
+[arg_def list vector1] First vector
+[arg_def list vector2] Second vector
+[list_end]
+
+
+[call [cmd ::math::geometry::calculateDistanceToLine] [arg P] [arg line]]
+
+Calculate the distance of point P to the (infinite) line and return the
+result
+
+[list_begin arguments]
+[arg_def list P] List of two numbers, the coordinates of the point
+
+[arg_def list line] List of four numbers, the coordinates of two points
+on the line
+[list_end]
+
+
+[call [cmd ::math::geometry::calculateDistanceToLineSegment] [arg P] [arg linesegment]]
+
+Calculate the distance of point P to the (finite) line segment and
+return the result.
+
+[list_begin arguments]
+[arg_def list P] List of two numbers, the coordinates of the point
+
+[arg_def list linesegment] List of four numbers, the coordinates of the
+first and last points of the line segment
+[list_end]
+
+
+[call [cmd ::math::geometry::calculateDistanceToPolyline] [arg P] [arg polyline]]
+
+Calculate the distance of point P to the polyline and
+return the result. Note that a polyline needs not to be closed.
+
+[list_begin arguments]
+[arg_def list P] List of two numbers, the coordinates of the point
+
+[arg_def list polyline] List of numbers, the coordinates of the
+vertices of the polyline
+[list_end]
+
+
+[call [cmd ::math::geometry::calculateDistanceToPolygon] [arg P] [arg polygon]]
+
+Calculate the distance of point P to the polygon and
+return the result. If the list of coordinates is not closed (first and last
+points differ), it is automatically closed.
+
+[list_begin arguments]
+[arg_def list P] List of two numbers, the coordinates of the point
+
+[arg_def list polygon] List of numbers, the coordinates of the
+vertices of the polygon
+[list_end]
+
+
+[call [cmd ::math::geometry::findClosestPointOnLine] [arg P] [arg line]]
+
+Return the point on a line which is closest to a given point.
+
+[list_begin arguments]
+[arg_def list P] List of two numbers, the coordinates of the point
+
+[arg_def list line] List of four numbers, the coordinates of two points
+on the line
+[list_end]
+
+
+[call [cmd ::math::geometry::findClosestPointOnLineSegment] [arg P] [arg linesegment]]
+
+Return the point on a [emph "line segment"] which is closest to a given
+point.
+
+[list_begin arguments]
+[arg_def list P] List of two numbers, the coordinates of the point
+
+[arg_def list linesegment] List of four numbers, the first and last
+points on the line segment
+[list_end]
+
+
+[call [cmd ::math::geometry::findClosestPointOnPolyline] [arg P] [arg polyline]]
+
+Return the point on a [emph "polyline"] which is closest to a given
+point.
+
+[list_begin arguments]
+[arg_def list P] List of two numbers, the coordinates of the point
+
+[arg_def list polyline] List of numbers, the vertices of the polyline
+[list_end]
+
+
+[call [cmd ::math::geometry::lengthOfPolyline] [arg polyline]]
+
+Return the length of the [emph "polyline"] (note: it not regarded as a
+polygon)
+
+[list_begin arguments]
+[arg_def list polyline] List of numbers, the vertices of the polyline
+[list_end]
+
+
+[call [cmd ::math::geometry::movePointInDirection] [arg P] [arg direction] [arg dist]]
+
+Move a point over a given distance in a given direction and return the
+new coordinates (in two dimensions only).
+
+[list_begin arguments]
+[arg_def list P] Coordinates of the point to be moved
+[arg_def double direction] Direction (in degrees; 0 is to the right, 90
+upwards)
+[arg_def list dist] Distance over which to move the point
+[list_end]
+
+
+[call [cmd ::math::geometry::lineSegmentsIntersect] [arg linesegment1] [arg linesegment2]]
+
+Check if two line segments intersect or coincide. Returns 1 if that is
+the case, 0 otherwise (in two dimensions only). If an endpoint of one segment lies on
+the other segment (or is very close to the segment), they are considered to intersect
+
+[list_begin arguments]
+[arg_def list linesegment1] First line segment
+[arg_def list linesegment2] Second line segment
+[list_end]
+
+
+[call [cmd ::math::geometry::findLineSegmentIntersection] [arg linesegment1] [arg linesegment2]]
+
+Find the intersection point of two line segments. Return the coordinates
+or the keywords "coincident" or "none" if the line segments coincide or
+have no points in common (in two dimensions only).
+
+[list_begin arguments]
+[arg_def list linesegment1] First line segment
+[arg_def list linesegment2] Second line segment
+[list_end]
+
+
+[call [cmd ::math::geometry::findLineIntersection] [arg line1] [arg line2]]
+
+Find the intersection point of two (infinite) lines. Return the coordinates
+or the keywords "coincident" or "none" if the lines coincide or
+have no points in common (in two dimensions only).
+
+[list_begin arguments]
+[arg_def list line1] First line
+[arg_def list line2] Second line
+[list_end]
+
+See section [sectref References] for details on the algorithm and math behind it.
+
+
+[call [cmd ::math::geometry::polylinesIntersect] [arg polyline1] [arg polyline2]]
+
+Check if two polylines intersect or not (in two dimensions only).
+
+[list_begin arguments]
+[arg_def list polyline1] First polyline
+[arg_def list polyline2] Second polyline
+[list_end]
+
+
+[call [cmd ::math::geometry::polylinesBoundingIntersect] [arg polyline1] [arg polyline2] [arg granularity]]
+
+Check whether two polylines intersect, but reduce
+the correctness of the result to the given granularity.
+Use this for faster, but weaker, intersection checking.
+[para]
+How it works:
+[para]
+Each polyline is split into a number of smaller polylines,
+consisting of granularity points each. If a pair of those smaller
+lines' bounding boxes intersect, then this procedure returns 1,
+otherwise it returns 0.
+
+[list_begin arguments]
+[arg_def list polyline1] First polyline
+[arg_def list polyline2] Second polyline
+[arg_def int granularity] Number of points in each part (<=1 means check
+every edge)
+
+[list_end]
+
+
+[call [cmd ::math::geometry::intervalsOverlap] [arg y1] [arg y2] [arg y3] [arg y4] [arg strict]]
+
+Check if two intervals overlap.
+
+[list_begin arguments]
+[arg_def double y1,y2] Begin and end of first interval
+[arg_def double y3,y4] Begin and end of second interval
+[arg_def logical strict] Check for strict or non-strict overlap
+[list_end]
+
+
+[call [cmd ::math::geometry::rectanglesOverlap] [arg P1] [arg P2] [arg Q1] [arg Q2] [arg strict]]
+
+Check if two rectangles overlap.
+
+[list_begin arguments]
+[arg_def list P1] upper-left corner of the first rectangle
+[arg_def list P2] lower-right corner of the first rectangle
+[arg_def list Q1] upper-left corner of the second rectangle
+[arg_def list Q2] lower-right corner of the second rectangle
+[arg_def list strict] choosing strict or non-strict interpretation
+[list_end]
+
+
+[call [cmd ::math::geometry::bbox] [arg polyline]]
+
+Calculate the bounding box of a polyline. Returns a list of four
+coordinates: the upper-left and the lower-right corner of the box.
+
+[list_begin arguments]
+[arg_def list polyline] The polyline to be examined
+[list_end]
+
+
+[call [cmd ::math::geometry::overlapBBox] [arg polyline1] [arg polyline2] [opt strict]]
+
+Check if the bounding boxes of two polylines overlap or not.
+[para]
+Arguments:
+[list_begin arguments]
+[arg_def list polyline1] The first polyline
+[arg_def list polyline1] The second polyline
+[arg_def int strict] Whether strict overlap is to checked (1) or if the bounding boxes may touch (0, default)
+[list_end]
+
+
+[call [cmd ::math::geometry::pointInsideBBox] [arg bbox] [arg point]]
+[para]
+Check if the point is inside or on the bounding box or not.
+
+Arguments:
+[list_begin arguments]
+[arg_def list bbox] The bounding box given as a list of x/y coordinates
+[arg_def list point] The point to be checked
+[list_end]
+
+
+[call [cmd ::math::geometry::cathetusPoint] [arg pa] [arg pb] [arg cathetusLength] [opt location]]
+
+Return the third point of the rectangular triangle defined by the two given end points of the hypothenusa.
+The triangle's side from point A (or B, if the location is given as "b") to the third point is the cathetus length.
+
+If the cathetus' length is lower than the length of the hypothenusa, an empty list is returned.
+[para]
+Arguments:
+[list_begin arguments]
+[arg_def list pa] The starting point on hypotenuse
+[arg_def list pb] The ending point on hypotenuse
+[arg_def float cathetusLength] The length of the cathetus of the triangle
+[arg_def string location] The location of the given cathetus,
+"a" means given cathetus shares point pa (default)
+"b" means given cathetus shares point pb
+[list_end]
+
+
+[call [cmd ::math::geometry::parallel] [arg line] [arg offset] [opt orient]]
+
+Return a line parallel to the given line, with a distance "offset". The orientation is determined by the
+two points defining the line.
+[para]
+Arguments:
+[list_begin arguments]
+[arg_def list line] The given line
+[arg_def float offset] The distance to the given line
+[arg_def string orient] Orientation of the new line with respect to the given line (defaults to "right")
+[list_end]
+[para]
+
+[call [cmd ::math::geometry::unitVector] [arg line]]
+
+Return a unit vector from the given line or direction, if the [term line] argument is
+a single point (then a line through the origin is assumed)
+
+Arguments:
+[list_begin arguments]
+[arg_def list line] The line in question (or a single point, implying a line through the origin)
+[list_end]
+
+
+[call [cmd ::math::geometry::pointInsidePolygon] [arg P] [arg polyline]]
+
+Determine if a point is completely inside a polygon. If the point
+touches the polygon, then the point is not completely inside the
+polygon.
+
+[list_begin arguments]
+[arg_def list P] Coordinates of the point
+[arg_def list polyline] The polyline to be examined
+[list_end]
+
+
+[call [cmd ::math::geometry::pointInsidePolygonAlt] [arg P] [arg polyline]]
+
+Determine if a point is completely inside a polygon. If the point
+touches the polygon, then the point is not completely inside the
+polygon. [emph Note:] this alternative procedure uses the so-called
+winding number to determine this. It handles self-intersecting polygons
+in a "natural" way.
+
+[list_begin arguments]
+[arg_def list P] Coordinates of the point
+[arg_def list polyline] The polyline to be examined
+[list_end]
+
+
+[call [cmd ::math::geometry::rectangleInsidePolygon] [arg P1] [arg P2] [arg polyline]]
+
+Determine if a rectangle is completely inside a polygon. If polygon
+touches the rectangle, then the rectangle is not complete inside the
+polygon.
+
+[list_begin arguments]
+[arg_def list P1] Upper-left corner of the rectangle
+[arg_def list P2] Lower-right corner of the rectangle
+[para]
+[arg_def list polygon] The polygon in question
+[list_end]
+
+
+[call [cmd ::math::geometry::areaPolygon] [arg polygon]]
+
+Calculate the area of a polygon.
+
+[list_begin arguments]
+[arg_def list polygon] The polygon in question
+[list_end]
+
+
+[call [cmd ::math::geometry::translate] [arg vector] [arg polyline]]
+
+Translate a polyline over a given vector
+
+[list_begin arguments]
+[arg_def list vector]   Translation vector
+[arg_def list polyline] The polyline to be translated
+[list_end]
+
+
+[call [cmd ::math::geometry::rotate] [arg angle] [arg polyline]]
+
+Rotate a polyline over a given angle (degrees) around the origin
+
+[list_begin arguments]
+[arg_def list angle]    Angle over which to rotate the polyline (degrees)
+[arg_def list polyline] The polyline to be rotated
+[list_end]
+
+
+[call [cmd ::math::geometry::rotateAbout] [arg p] [arg angle] [arg polyline]]
+
+Rotate a polyline around a given point p and return the new polyline.
+[para]
+Arguments:
+[list_begin arguments]
+[arg_def list p] The point of rotation
+[arg_def float angle] The angle over which to rotate the polyline (degrees)
+[arg_def list polyline] The polyline to be rotated
+[list_end]
+
+
+[call [cmd ::math::geometry::reflect] [arg angle] [arg polyline]]
+
+Reflect a polyline in a line through the origin at a given angle (degrees) to the x-axis
+
+[list_begin arguments]
+[arg_def list angle]    Angle of the line of reflection (degrees)
+[arg_def list polyline] The polyline to be reflected
+[list_end]
+
+
+[call [cmd ::math::geometry::degToRad] [arg angle]]
+
+Convert from degrees to radians
+
+[list_begin arguments]
+[arg_def list angle]    Angle in degrees
+[list_end]
+
+
+[call [cmd ::math::geometry::radToDeg] [arg angle]]
+
+Convert from radians to degrees
+
+[list_begin arguments]
+[arg_def list angle]    Angle in radians
+[list_end]
+
+
+[call [cmd ::math::geometry::circle] [arg centre] [arg radius]]
+
+Convenience procedure to create a circle from a point and a radius.
+
+[list_begin arguments]
+[arg_def list centre]    Coordinates of the circle centre
+[arg_def list radius]    Radius of the circle
+[list_end]
+
+
+[call [cmd ::math::geometry::circleTwoPoints] [arg point1] [arg point2]]
+
+Convenience procedure to create a circle from two points on its circumference
+The centre is the point between the two given points, the radius is half the
+distance between them.
+
+[list_begin arguments]
+[arg_def list point1]    First point
+[arg_def list point2]    Second point
+[list_end]
+
+
+[call [cmd ::math::geometry::pointInsideCircle] [arg point] [arg circle]]
+
+Determine if the given point is inside the circle or on the circumference (1)
+or outside (0).
+
+[list_begin arguments]
+[arg_def list point]     Point to be checked
+[arg_def list circle]    Circle that may or may not contain the point
+[list_end]
+
+
+[call [cmd ::math::geometry::lineIntersectsCircle] [arg line] [arg circle]]
+
+Determine if the given line intersects the circle or touches it (1)
+or does not (0).
+
+[list_begin arguments]
+[arg_def list line]      Line to be checked
+[arg_def list circle]    Circle that may or may not be intersected
+[list_end]
+
+
+[call [cmd ::math::geometry::lineSegmentIntersectsCircle] [arg segment] [arg circle]]
+
+Determine if the given line segment intersects the circle or touches it (1)
+or does not (0).
+
+[list_begin arguments]
+[arg_def list segment]   Line segment to be checked
+[arg_def list circle]    Circle that may or may not be intersected
+[list_end]
+
+
+[call [cmd ::math::geometry::intersectionLineWithCircle] [arg line] [arg circle]]
+
+Determine the points at which the given line intersects the circle. There can
+be zero, one or two points. (If the line touches the circle or is close to it,
+then one point is returned. An arbitrary margin of 1.0e-10 times the radius
+is used to determine this situation.)
+
+[list_begin arguments]
+[arg_def list line]      Line to be checked
+[arg_def list circle]    Circle that may or may not be intersected
+[list_end]
+
+
+[call [cmd ::math::geometry::intersectionCircleWithCircle] [arg circle1] [arg circle2]]
+
+Determine the points at which the given two circles intersect. There can
+be zero, one or two points. (If the two circles touch the circle or are very close,
+then one point is returned. An arbitrary margin of 1.0e-10 times the mean of the radii of
+the two circles is used to determine this situation.)
+
+[list_begin arguments]
+[arg_def list circle1]    First circle
+[arg_def list circle2]    Second circle
+[list_end]
+
+
+[call [cmd ::math::geometry::tangentLinesToCircle] [arg point] [arg circle]]
+
+Determine the tangent lines from the given point to the circle. There can
+be zero, one or two lines. (If the point is on the cirucmference or very close to
+the circle, then one line is returned. An arbitrary margin of 1.0e-10 times the
+radius of the circle is used to determine this situation.)
+
+[list_begin arguments]
+[arg_def list point]      Point in question
+[arg_def list circle]     Circle to which the tangent lines are to be determined
+[list_end]
+
+
+[call [cmd ::math::geometry::intersectionPolylines] [arg polyline1] [arg polyline2] [opt mode] [opt granularity]]
+
+Return the first point or all points where the two polylines intersect. If the number of points in the polylines is large,
+you can use the granularity to get an approximate answer faster.
+[para]
+Arguments:
+[list_begin arguments]
+[arg_def list polyline1] The first polyline
+[arg_def list polyline2] The second polyline
+[arg_def string mode] Whether to return only the first (default) or to return all intersection points ("all")
+[arg_def int granularity] The number of points that will be skipped plus 1 in the search for intersection points (1 or smaller means an exact answer is returned)
+[list_end]
+
+
+[call [cmd ::math::geometry::intersectionPolylineCircle] [arg polyline] [arg circle] [opt mode] [opt granularity]]
+
+Return the first point or all points where the polyline intersects the circle. If the number of points in the polyline is large,
+you can use the granularity to get an approximate answer faster.
+[para]
+Arguments:
+[list_begin arguments]
+[arg_def list polyline] The polyline that may intersect the circle
+[arg_def list circle] The circle in question
+[arg_def string mode] Whether to return only the first (default) or to return all intersection points ("all")
+[arg_def int granularity] The number of points that will be skipped plus 1 in the search for intersection points (1 or smaller means an exact answer is returned)
+[list_end]
+
+
+[call [cmd ::math::geometry::polylineCutOrigin] [arg polyline1] [arg polyline2] [opt granularity]]
+
+Return the part of the first polyline from the origin up to the first intersection with the second. If the number of points in the polyline is large,
+you can use the granularity to get an approximate answer faster.
+[para]
+Arguments:
+[list_begin arguments]
+[arg_def list polyline1] The first polyline (from which a part is to be returned)
+[arg_def list polyline2] The second polyline
+[arg_def int granularity] The number of points that will be skipped plus 1 in the search for intersection points (1 or smaller means an exact answer is returned)
+[list_end]
+
+
+[call [cmd ::math::geometry::polylineCutEnd] [arg polyline1] [arg polyline2] [opt granularity]]
+
+Return the part of the first polyline from the last intersection point with the second to the end. If the number of points in the polyline is large,
+you can use the granularity to get an approximate answer faster.
+[para]
+Arguments:
+[list_begin arguments]
+[arg_def list polyline1] The first polyline (from which a part is to be returned)
+[arg_def list polyline2] The second polyline
+[arg_def int granularity] The number of points that will be skipped plus 1 in the search for intersection points (1 or smaller means an exact answer is returned)
+[list_end]
+
+
+[call [cmd ::math::geometry::splitPolyline] [arg polyline] [arg numberVertex]]
+
+Split the poyline into a set of polylines where each separate polyline holds "numberVertex" vertices between the two end points.
+[para]
+Arguments:
+[list_begin arguments]
+[arg_def list polyline] The polyline to be split up
+[arg_def int numberVertex] The number of "internal" vertices
+[list_end]
+
+
+[call [cmd ::math::geometry::enrichPolyline] [arg polyline] [arg accuracy]]
+
+Split up each segment of a polyline into a number of smaller segments and return the result.
+[para]
+Arguments:
+[list_begin arguments]
+[arg_def list polyline] The polyline to be refined
+[arg_def int accuracy] The number of subsegments to be created
+[list_end]
+
+
+[call [cmd ::math::geometry::cleanupPolyline] [arg polyline]]
+
+Remove duplicate neighbouring vertices and return the result.
+[para]
+Arguments:
+[list_begin arguments]
+[arg_def list polyline] The polyline to be cleaned up
+[list_end]
+
+[list_end]
+
+
+[section "COORDINATE SYSTEM"]
+The coordinate system used by the package is the ordinary cartesian system, where the
+positive x-axis is directed to the right and the positive y-axis is directed upwards.
+Angles and directions are defined with respect to the positive x-axis in a counter-clockwise
+direction, so that an angle of 90 degrees is the direction of the positive y-axis.
+
+Note that the Tk canvas coordinates differ from this, as there the origin is located in the
+upper left corner of the window. Up to and including version 1.3, the direction and octant
+procedures of this package used this convention inconsistently.
+
+
+[section References]
+
+[list_begin enumerated]
+[enum] [uri http:/wiki.tcl.tk/12070 {Polygon Intersection}]
+[enum] [uri http://en.wikipedia.org/wiki/Line-line_intersection]
+[enum] [uri http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/]
+[list_end]
+
+[vset CATEGORY {math :: geometry}]
+[include ../common-text/feedback.inc]
+[manpage_end]