Sign in Join

Live chat for Free Pascal, Lazarus, Delphi and every Pascal programmer.

Mailing lists / fpc-pascal / 2003-12

how to add a package to fpc release

2 messages · 2 people ·

Reply by email Subscribe to this list Your subscription

Read-only archive. Use j and k to move between messages.

Arash Partow

Hi All,

I've recently begun writing a simple computational geometry unit in object pascal. Its not object oriented just a large list of geometric primitives etc, so far things seem to compile on FPC.

I was wondering if anyone could tell me what the protocols are for adding such a package to FPC if it is deemed acceptable.

Regards

Arash

PS: Below are the method signatures for the unit

Function Orientation(x1,y1,x2,y2,Px,Py:Double):Double;
Function Orientation(Pnt1,Pnt2:TPoint2D; Px,Py:Double):Double;
Function Orientation(Pnt1,Pnt2,Pnt3:TPoint2D):Double;
Function Orientation(Ln:TLine2D; Pnt:TPoint2D):Double;
Function Orientation(Seg:TSegment2D; Pnt:TPoint2D):Double;
Function Orientation(x1,y1,z1,x2,y2,z2,x3,y3,z3,Px,Py,Pz:Double):Double;
Function Orientation(Pnt1,Pnt2,Pnt3:TPoint3D; Px,Py,Pz:Double):Double;
Function Orientation(Pnt1,Pnt2,Pnt3,Pnt4:TPoint3D):Double;
Function Orientation(Tri:TTriangle3D; Pnt:TPoint3D):Double;
Function Collinear(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function Collinear(PntA,PntB,PntC:TPoint2D):Boolean;
Function Collinear(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function Collinear(PntA,PntB,PntC:TPoint3D):Boolean;
Function IsPntCollinear(PntA,PntB,PntC:TPoint2D):Boolean;
Function IsPntCollinear(Line:TLine2D; PntC:TPoint2D):Boolean;
Function IsPntCollinear(PntA,PntB,PntC:TPoint3D):Boolean;
Function IsPntCollinear(Line:TLine3D; PntC:TPoint3D):Boolean;
Function IsOnRightSide(x,y:Double; Ln:TLine2D):Boolean;
Function IsOnRightSide(Pnt:TPoint2D; Ln:TLine2D):Boolean;
Function IsOnLeftSide(x,y:Double; Ln:TLine2D):Boolean;
Function IsOnLeftSide(Pnt:TPoint2D; Ln:TLine2D):Boolean;
Function Intersect(x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean;
Function Intersect(Pnt1,Pnt2,Pnt3,Pnt4:TPoint2D):Boolean;
Function Intersect(Ln1,Ln2:TLine2D):Boolean;
Function Intersect(x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):Boolean;
Function Intersect(P1,P2,P3,P4:TPoint3D):Boolean;
Function Intersect(Ln1,Ln2:TLine3D):Boolean;
Function Intersect(Ln:TLine2D; Rec:TRectangle):Boolean;
Function Intersect(Ln:TLine2D; Tri:TTriangle2D):Boolean;
Function Intersect(Ln:TLine2D; Quad:TQuadix2D):Boolean;
Function Intersect(Ln:TLine2D; Cir:TCircle):Boolean;
Function Intersect(Ln:TLine3D; Sphere:TSphere):Boolean;
Function IntersectPoint(P1,P2,P3,P4:TPoint2D; Var Nx,Ny:Double):Boolean;
Function IntersectPoint(P1,P2,P3,P4:TPoint2D):TPoint2D;
Function IntersectPoint(Ln1,Ln2:TLine2D):TPoint2D;
Function VertexAngle(x1,y1,x2,y2,x3,y3:Double):Double;
Function VertexAngle(Pnt1,Pnt2,Pnt3:TPoint2D):Double;
Function VertexAngle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Double;
Function VertexAngle(Pnt1,Pnt2,Pnt3:TPoint3D):Double;
Function SegmentIntersectAngle(Pnt1,Pnt2,Pnt3,Pnt4:TPoint2D):Double;
Function SegmentIntersectAngle(Ln1,Ln2:TLine2D):Double;
Function SegmentIntersectAngle(Pnt1,Pnt2,Pnt3,Pnt4:TPoint3D):Double;
Function SegmentIntersectAngle(Ln1,Ln2:TLine3D):Double;
Function InPortal(P:TPoint2D):Boolean;
Function InPortal(P:TPoint3D):Boolean;
Function HighestPoint(Polygon: TPolygon):TPoint2D;
Function HighestPoint(Tri:TTriangle2D):TPoint2D;
Function HighestPoint(Tri:TTriangle3D):TPoint3D;
Function HighestPoint(Quadix:TQuadix2D):TPoint2D;
Function HighestPoint(Quadix:TQuadix3D):TPoint3D;
Function LowestPoint(Polygon: TPolygon):TPoint2D;
Function LowestPoint(Tri:TTriangle2D):TPoint2D;
Function LowestPoint(Tri:TTriangle3D):TPoint3D;
Function LowestPoint(Quadix:TQuadix2D):TPoint2D;
Function LowestPoint(Quadix:TQuadix3D):TPoint3D;
Function Coincident(Pnt1,Pnt2:TPoint2D):Boolean;
Function Coincident(Pnt1,Pnt2:TPoint3D):Boolean;
Function Coincident(Ln1,Ln2:TLine2D):Boolean;
Function Coincident(Ln1,Ln2:TLine3D):Boolean;
Function Coincident(Seg1,Seg2:TSegment2D):Boolean;
Function Coincident(Seg1,Seg2:TSegment3D):Boolean;
Function Coincident(Tri1,Tri2:TTriangle2D):Boolean;
Function Coincident(Tri1,Tri2:TTriangle3D):Boolean;
Function Coincident(Rect1,Rect2:TRectangle):Boolean;
Function Coincident(Quad1,Quad2:TQuadix2D):Boolean;
Function Coincident(Quad1,Quad2:TQuadix3D):Boolean;
Function Coincident(Cir1,Cir2:TCircle):Boolean;
Function Coincident(Sphr1,Sphr2:TSphere):Boolean;
Procedure PerpendicularPntToSegment(x1,y1,x2,y2,Px,Py:Double; Var
Nx,Ny:Double);
Function  PerpendicularPntToSegment(Line:TLine2D; Pnt:TPoint2D):TPoint2D;
Function  PntToSegmentDistance(Px,Py,x1,y1,x2,y2:Double):Double;
Function  PntToSegmentDistance(Pnt:TPoint2D; Line:TLine2D):Double;
Function SegmentsParallel(x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean;
Function SegmentsParallel(Ln1,Ln2:TLine2D):Boolean;
Function
SegmentsParallel(x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):Boolean;
Function SegmentsParallel(Pnt1,Pnt2,Pnt3,Pnt4:TPoint3D):Boolean;
Function SegmentsParallel(Ln1,Ln2:TLine3D):Boolean;
Function SegmentsPerpendicular(x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean;
Function SegmentsPerpendicular(Ln1,Ln2:TLine2D):Boolean;
Function
SegmentsPerpendicular(x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):Boolean;
Function SegmentsPerpendicular(Ln1,Ln2:TLine3D):Boolean;
Procedure SetPlane(xh,xl,yh,yl:Double);
Procedure SetPlane(Pnt1,Pnt2:TPoint2D);
Procedure SetPlane(Rec:TRectangle);
Function RectangleIntersect(x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean;
Function RectangleIntersect(Rec1,Rec2:TRectangle):Boolean;
Function Intersect(Cir1,Cir2:TCircle):Boolean;
Function CircleInCircle(Cir1,Cir2:TCircle):Boolean;
Function IsTangent(Ln:TLine2D; Cir:TCircle):Boolean;
Function Distance(x1,y1,x2,y2:Double):Double;
Function Distance(Pnt1,Pnt2:TPoint2D):Double;
Function Distance(x1,y1,z1,x2,y2,z2:Double):Double;
Function Distance(Pnt1,Pnt2:TPoint3D):Double;
Function Distance(Line:TLine2D):Double;
Function Distance(Line:TLine3D):Double;
Function LayDistance(x1,y1,x2,y2:Double):Double;
Function LayDistance(Pnt1,Pnt2:TPoint2D):Double;
Function LayDistance(x1,y1,z1,x2,y2,z2:Double):Double;
Function LayDistance(Pnt1,Pnt2:TPoint3D):Double;
Function LayDistance(Line:TLine2D):Double;
Function LayDistance(Line:TLine3D):Double;
Function ManhattanDistance(x1,y1,x2,y2:Double):Double;
Function ManhattanDistance(Pnt1,Pnt2:TPoint2D):Double;
Function ManhattanDistance(x1,y1,z1,x2,y2,z2:Double):Double;
Function ManhattanDistance(Pnt1,Pnt2:TPoint3D):Double;
Function ManhattanDistance(Line:TLine2D):Double;
Function ManhattanDistance(Line:TLine3D):Double;
Function TriangleType(x1,y1,x2,y2,x3,y3:Double):TTriangleType;
Function TriangleType(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):TTriangleType;
Function TriangleType(Pnt1,Pnt2,Pnt3:TPoint2D):TTriangleType;
Function TriangleType(Pnt1,Pnt2,Pnt3:TPoint3D):TTriangleType;
Function TriangleType(Tri:TTriangle2D):TTriangleType;
Function TriangleType(Tri:TTriangle3D):TTriangleType;
Function IsEquilateralTriangle(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function IsEquilateralTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function IsEquilateralTriangle(Pnt1,Pnt2,Pnt3:TPoint2D):Boolean;
Function IsEquilateralTriangle(Pnt1,Pnt2,Pnt3:TPoint3D):Boolean;
Function IsEquilateralTriangle(Tri:TTriangle2D):Boolean;
Function IsEquilateralTriangle(Tri:TTriangle3D):Boolean;
Function IsIsoscelesTriangle(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function IsIsoscelesTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function IsIsoscelesTriangle(Pnt1,Pnt2,Pnt3:TPoint2D):Boolean;
Function IsIsoscelesTriangle(Pnt1,Pnt2,Pnt3:TPoint3D):Boolean;
Function IsIsoscelesTriangle(Tri:TTriangle2D):Boolean;
Function IsIsoscelesTriangle(Tri:TTriangle3D):Boolean;
Function IsRightTriangle(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function IsRightTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function IsRightTriangle(Pnt1,Pnt2,Pnt3:TPoint2D):Boolean;
Function IsRightTriangle(Pnt1,Pnt2,Pnt3:TPoint3D):Boolean;
Function IsRightTriangle(Tri:TTriangle2D):Boolean;
Function IsRightTriangle(Tri:TTriangle3D):Boolean;
Function IsScaleneTriangle(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function IsScaleneTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function IsScaleneTriangle(Pnt1,Pnt2,Pnt3:TPoint2D):Boolean;
Function IsScaleneTriangle(Pnt1,Pnt2,Pnt3:TPoint3D):Boolean;
Function IsScaleneTriangle(Tri:TTriangle2D):Boolean;
Function IsScaleneTriangle(Tri:TTriangle3D):Boolean;
Function IsObtuseTriangle(x1,y1,x2,y2,x3,y3:Double):Boolean;
Function IsObtuseTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):Boolean;
Function IsObtuseTriangle(Pnt1,Pnt2,Pnt3:TPoint2D):Boolean;
Function IsObtuseTriangle(Pnt1,Pnt2,Pnt3:TPoint3D):Boolean;
Function IsObtuseTriangle(Tri:TTriangle2D):Boolean;
Function IsObtuseTriangle(Tri:TTriangle3D):Boolean;
Function PntInTriangle(Px,Py,x1,y1,x2,y2,x3,y3:Double):Boolean;
Function PntInTriangle(Pnt:TPoint2D; Tri:TTriangle2D):Boolean;
Function PntInCircle(Px,Py:Double; Circle:TCircle):Boolean;
Function PntInCircle(Pnt:TPoint2D; Circle:TCircle):Boolean;
Function TriangleInCircle(Tri:TTriangle2D; Circle:TCircle):TInclusion;
Function RectangleInCircle(Rect:TRectangle; Circle:TCircle):TInclusion;
Function QuadixInCircle(Quad:TQuadix2D; Circle:TCircle):TInclusion;
Function PntInRectangle(Px,Py:Double; x1,y1,x2,y2:Double):Boolean;
Function PntInRectangle(Pnt:TPoint2D; x1,y1,x2,y2:Double):Boolean;
Function PntInRectangle(Px,Py:Double; Rec:TRectangle):Boolean;
Function PntInRectangle(Pnt:TPoint2D; Rec:TRectangle):Boolean;
Function TriangleInRectangle(Tri:TTriangle2D; Rec:TRectangle):TInclusion;
Function QuadixInRectangle(Quad:TQuadix2D; Rec:TRectangle):TInclusion;
Function PntInQuadix(Px,Py,x1,y1,x2,y2,x3,y3,x4,y4:Double):Boolean;
Function PntInQuadix(Pnt,Pnt1,Pnt2,Pnt3,Pnt4: TPoint2D):Boolean;
Function PntInQuadix(Pnt:TPoint2D; Quad:TQuadix2D):Boolean;
Function TriangleInQuadix(Tri:TTriangle2D; Quad:TQuadix2D):TInclusion;
Function PntInSphere(x,y,z: Double; Sphere:TSphere):Boolean;
Function PntInSphere(Pnt3D:TPoint3D; Sphere:TSphere):Boolean;
Function PntOnSphere(Pnt3D:TPoint3D; Sphere:TSphere):Boolean;
Function PolyhedronInSphere(Poly:TPolyhedron; Sphere:TSphere):TInclusion;
Function TriangleCircumcircle(P1,P2,P3:TPoint2D):TCircle;
Function TriangleCircumcircle(Tri:TTriangle2D):TCircle;
Function InscribedCircle(P1,P2,P3:TPoint2D):TCircle;
Function InscribedCircle(Tri:TTriangle2D):TCircle;
Function SegmentMidPoint(P1,P2:TPoint2D):TPoint2D;
Function SegmentMidPoint(Line:TLine2D):TPoint2D;
Function SegmentMidPoint(P1,P2:TPoint3D):TPoint3D;
Function SegmentMidPoint(Line:TLine3D):TPoint3D;
Function OrthoCenter(x1,y1,x2,y2,x3,y3:Double):TPoint2D;
Function OrthoCenter(Pnt1,Pnt2,CPnt:TPoint2D):TPoint2D;
Function OrthoCenter(Ln1,Ln2,Ln3:TLine2D):TPoint2D;
Function OrthoCenter(Tri:TTriangle2D):TPoint2D;
Function PolygonCentroid(Polygon :TPolygon):TPoint2D;
Function PolygonCentroid(Polygon :Array Of TPoint3D):TPoint3D;
Function PolygonSegmentIntersect(Ln:TLine2D; Poly: TPolygon):Boolean;
Function PolygonInPolygon(Poly1,Poly2: TPolygon):Boolean;
Function PolygonIntersect(Poly1,Poly2: TPolygon):Boolean;
Function PntInConvexPolygon(Px,Py:Double; Poly: TPolygon):Boolean;
Function PntInConvexPolygon(Pnt:TPoint2D; Poly: TPolygon):Boolean;
Function PntInConcavePolygon(Px,Py:Double; Poly: TPolygon):Boolean;
Function PntInConcavePolygon(Pnt:TPoint2D; Poly: TPolygon):Boolean;
Function PntOnPolygon(Px,Py:Double; Poly: TPolygon):Boolean;
Function PntOnPolygon(Pnt:TPoint2D; Poly: TPolygon):Boolean;
Function PntInPolygon(Px,Py:Double; Poly: TPolygon):Boolean;
Function PntInPolygon(Pnt:TPoint2D; Poly: TPolygon):Boolean;
Function ComplexPolygon(Poly: TPolygon):Boolean;
Function SimplePolygon(Poly: TPolygon):Boolean;
Function ConvexPolygon(Poly: TPolygon):Boolean;
Function ConcavePolygon(Poly: TPolygon):Boolean;
Procedure PolygonConstruction(Poly: TPolygon);
Function ConvexHull(Polygon:TPolygon):TPolygon;
Function ConvexHull(Polyhedron:TPolyhedron):TPolyhedron;
Function RectangularHull(Poly:TPolygon):TRectangle;
Function CircularHull(Poly:TPolygon):TCircle;
Function SphereHull(Poly: Array Of TPoint3D):TSphere;
Function Clip(Ln:TLine2D; Rec:TRectangle):TLine2D;
Function Clip(Ln:TLine2D; Tri:TTriangle2D):TLine2D;
Function Clip(Ln:TLine2D; Quad:TQuadix2D):TLine2D;
Function Area(Tri:TTriangle2D):Double;
Function Area(Tri:TTriangle3D):Double;
Function Area(Quad:TQuadix2D):Double;
Function Area(Quad:TQuadix3D):Double;
Function Area(Rec:TRectangle):Double;
Function Area(Cir:TCircle):Double;
Function Area(Poly:TPolygon):Double;
Function Perimeter(Tri:TTriangle2D):Double;
Function Perimeter(Tri:TTriangle3D):Double;
Function Perimeter(Quad:TQuadix2D):Double;
Function Perimeter(Quad:TQuadix3D):Double;
Function Perimeter(Rec:TRectangle):Double;
Function Perimeter(Cir:TCircle):Double;
Function Perimeter(Poly:TPolygon):Double;
Function Rotate(RotAng:Double; x,y:Double; Var Nx,Ny:Double):Boolean;
Function Rotate(RotAng:Double; x,y,ox,oy:Double; Var Nx,Ny:Double):Boolean;
Function Rotate(RotAng:Double; Pnt:TPoint2D):TPoint2D;
Function Rotate(RotAng:Double; Pnt,OPnt:TPoint2D):TPoint2D;
Function Rotate(RotAng:Double; Ln:TLine2D):TLine2D;
Function Rotate(RotAng:Double; Ln:TLine2D; Pnt: TPoint2D):TLine2D;
Function Rotate(RotAng:Double; Seg:TSegment2D):TSegment2D;
Function Rotate(RotAng:Double; Seg:TSegment2D; Pnt: TPoint2D):TSegment2D;
Function Rotate(RotAng:Double; Tri:TTriangle2D):TTriangle2D;
Function Rotate(RotAng:Double; Tri:TTriangle2D; OPnt:TPoint2D):TTriangle2D;
Function Rotate(RotAng:Double; Quad:TQuadix2D):TQuadix2D;
Function Rotate(RotAng:Double; Quad:TQuadix2D; OPnt:TPoint2D):TQuadix2D;
Function Rotate(RotAng:Double; Rec:TRectangle):TRectangle;
Function Rotate(RotAng:Double; Rec:TRectangle; OPnt:TPoint2D):TRectangle;
Function Rotate(RotAng:Double; Poly:TPolygon):TPolygon;
Function Rotate(RotAng:Double; Poly:TPolygon; OPnt:TPoint2D):TPolygon;
Function Rotate(Rx,Ry,Rz:Double; x,y,z:Double; Var Nx,Ny,Nz:Double):Boolean;
Function Rotate(Rx,Ry,Rz:Double; x,y,z,ox,oy,oz:Double; Var
Nx,Ny,Nz:Double):Boolean;
Function Rotate(Rx,Ry,Rz:Double; Pnt:TPoint3D):TPoint3D;
Function Rotate(Rx,Ry,Rz:Double; Pnt,OPnt:TPoint3D):TPoint3D;
Function Rotate(Rx,Ry,Rz:Double; Ln:TLine3D):TLine3D;
Function Rotate(Rx,Ry,Rz:Double; Ln:TLine3D; Pnt: TPoint3D):TLine3D;
Function Rotate(Rx,Ry,Rz:Double; Seg:TSegment3D):TSegment3D;
Function Rotate(Rx,Ry,Rz:Double; Seg:TSegment3D; Pnt: TPoint3D):TSegment3D;
Function Rotate(Rx,Ry,Rz:Double; Tri:TTriangle3D):TTriangle3D;
Function Rotate(Rx,Ry,Rz:Double; Tri:TTriangle3D;
OPnt:TPoint3D):TTriangle3D;
Function Rotate(Rx,Ry,Rz:Double; Quad:TQuadix3D):TQuadix3D;
Function Rotate(Rx,Ry,Rz:Double; Quad:TQuadix3D; OPnt:TPoint3D):TQuadix3D;
Function Rotate(Rx,Ry,Rz:Double; Poly:TPolygon3D):TPolygon3D;
Function Rotate(Rx,Ry,Rz:Double; Poly:TPolygon3D; OPnt:TPoint3D):TPolygon3D;
Function Translate(Dx,Dy:Double; Pnt:TPoint2D):TPoint2D;
Function Translate(Dx,Dy:Double; Ln:TLine2D):TLine2D;
Function Translate(Dx,Dy:Double; Seg:TSegment2D):TSegment2D;
Function Translate(Dx,Dy:Double; Tri:TTriangle2D):TTriangle2D;
Function Translate(Dx,Dy:Double; Quad:TQuadix2D):TQuadix2D;
Function Translate(Dx,Dy:Double; Rec:TRectangle):TRectangle;
Function Translate(Dx,Dy:Double; Cir:TCircle):TCircle;
Function Translate(Dx,Dy:Double; Poly: TPolygon):TPolygon;
Function Translate(Pnt:TPoint2D; Poly: TPolygon):TPolygon;
Function Translate(Dx,Dy,Dz:Double; Pnt:TPoint3D):TPoint3D;
Function Translate(Dx,Dy,Dz:Double; Ln:TLine3D):TLine3D;
Function Translate(Dx,Dy,Dz:Double; Seg:TSegment3D):TSegment3D;
Function Translate(Dx,Dy,Dz:Double; Tri:TTriangle3D):TTriangle3D;
Function Translate(Dx,Dy,Dz:Double; Quad:TQuadix3D):TQuadix3D;
Function Translate(Dx,Dy,Dz:Double; Sphere:TSphere):TSphere;
Function Translate(Dx,Dy,Dz:Double; Poly: TPolygon3D):TPolygon3D;
Function Translate(Pnt:TPoint3D; Poly: TPolygon3D):TPolygon3D;
Function Scale(Dx,Dy:Double; Pnt:TPoint2D):TPoint2D;
Function Scale(Dx,Dy:Double; Ln:TLine2D):TLine2D;
Function Scale(Dx,Dy:Double; Seg:TSegment2D):TSegment2D;
Function Scale(Dx,Dy:Double; Tri:TTriangle2D):TTriangle2D;
Function Scale(Dx,Dy:Double; Quad:TQuadix2D):TQuadix2D;
Function Scale(Dx,Dy:Double; Rec:TRectangle):TRectangle;
Function Scale(Dr:Double; Cir:TCircle):TCircle;
Function Scale(Dx,Dy:Double; Poly: TPolygon):TPolygon;
Function Scale(Dx,Dy,Dz:Double; Pnt:TPoint3D):TPoint3D;
Function Scale(Dx,Dy,Dz:Double; Ln:TLine3D):TLine3D;
Function Scale(Dx,Dy,Dz:Double; Seg:TSegment3D):TSegment3D;
Function Scale(Dx,Dy,Dz:Double; Tri:TTriangle3D):TTriangle3D;
Function Scale(Dx,Dy,Dz:Double; Quad:TQuadix3D):TQuadix3D;
Function Scale(Dr:Double; Sphere:TSphere):TSphere;
Function Scale(Dx,Dy,Dz:Double; Poly: TPolygon3D):TPolygon3D;
Function EquatePoint(x,y:Double):TPoint2D;
Function EquatePoint(x,y,z:Double):TPoint3D;
Function EquateLine(x1,y1,x2,y2:Double):TLine2D;
Function EquateLine(x1,y1,z1,x2,y2,z2:Double):TLine3D;
Function EquateQuadix(x1,y1,x2,y2,x3,y3,x4,y4:Double):TQuadix2D;
Function EquateQuadix(x1,y1,z1,x2,y2,z2,x3,y3,z3,x4,y4,z4:Double):TQuadix3D;
Function EquateRectangle(x1,y1,x2,y2:Double):TRectangle;
Function EquateTriangle(x1,y1,x2,y2,x3,y3:Double):TTriangle2D;
Function EquateTriangle(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):TTriangle3D;
Function EquateCircle(x,y,r:Double):TCircle;
Function EquateSphere(x,y,z,r:Double):TSphere;
Function EquatePlane(x1,y1,z1,x2,y2,z2,x3,y3,z3:Double):TPlane3D;
Function EquatePlane(Pnt1,Pnt2,Pnt3:TPoint3D):TPlane3D;

_________________________________________________________________ Hot chart ringtones and polyphonics. Go to
http://ninemsn.com.au/mobilemania/default.asp

Unknown author
to Arash Partow
Arash Partow wrote 8 lines
Hi All, I've recently begun writing a simple computational geometry unit in object pascal. Its not object oriented just a large list of geometric primitives etc, so far things seem to compile on FPC. I was wondering if anyone could tell me what the protocols are for adding such a package to FPC if it is deemed acceptable.

The best thing to do is to add it to the contributed units section of the FPC web site. It will be by far the best option.

Michael.