Circle 2D

Builders

Circle2D.atOrigin (Length.meters 2.)

No value returned by any evaluator

Circle2D.atPoint (Point2D.meters 5. 2.) (Length.meters 4.)

No value returned by any evaluator

Circle2D.withRadius (Length.meters 4.) (Point2D.meters 5. 2.)

No value returned by any evaluator

Circle2D.throughPoints (Point2D.meters 3. 4.) (Point2D.meters -1. 2.) (Point2D.meters 4. 1.)

No value returned by any evaluator

Circle2D.sweptAround Point2D.origin (Point2D.meters 3. 3.)

No value returned by any evaluator

Accessors

let circle: Circle2D<Meters, Cartesian> =
    Circle2D.atPoint (Point2D.meters 5. 2.) (Length.meters 4.)

Circle2D.centerPoint circle // or
circle.Center

No value returned by any evaluator

Circle2D.radius circle // or
circle.Radius

No value returned by any evaluator

Circle2D.diameter circle

No value returned by any evaluator

Circle2D.area circle

No value returned by any evaluator

Circle2D.circumference circle

No value returned by any evaluator

Circle2D.toArc circle

No value returned by any evaluator

Circle2D.boundingBox circle

No value returned by any evaluator

Modifiers

Circle2D.scaleAbout
Circle2D.translateBy
Circle2D.translateIn
Circle2D.relativeTo
Circle2D.placeIn
Circle2D.containsPoint
Circle2D.intersectsBoundingBox

namespace Math

namespace Math.Geometry

namespace Math.Units

Multiple items
union case Cartesian.Cartesian: Cartesian

--------------------
type Cartesian = | Cartesian

Multiple items
module Circle2D from Math.Geometry

--------------------
type Circle2D<'Units,'Coordinates> = { Center: Point2D<'Units,'Coordinates> Radius: Quantity<'Units> } interface IGeometry<'Coordinates> override Equals : obj:obj -> bool override GetHashCode : unit -> int

val atOrigin : radius:Quantity<'a> -> Circle2D<'a,'b>

Multiple items
module Length from Math.Units
<category>Module: Unit System</category>
<summary> A <c>Length</c> represents a length in meters, feet, centimeters, miles etc. It is stored as a number of meters. </summary>

--------------------
type Length = Quantity<Meters>
<category>Unit System</category>

val meters : m:float -> Length
<category index="2">Metric</category>

val atPoint : center:Point2D<'Units,'Coordinates> -> radius:Quantity<'Units> -> Circle2D<'Units,'Coordinates>

Multiple items
module Point2D from Math.Geometry

--------------------
[<Struct>] type Point2D<'Units,'Coordinates> = { X: Quantity<'Units> Y: Quantity<'Units> } interface IComparable interface IComparable<Point2D<'Units,'Coordinates>> interface IGeometry<'Coordinates> member Comparison : other:Point2D<'Units,'Coordinates> -> int override Equals : obj:obj -> bool + 1 overload override GetHashCode : unit -> int member LessThan : other:Point2D<'Units,'Coordinates> -> bool static member ( * ) : lhs:Point2D<'Units,'Coordinates> * rhs:float -> Point2D<'Units,'Coordinates> + 1 overload static member ( + ) : lhs:Point2D<'Units,'Coordinates> * rhs:Vector2D<'Units,'Coordinates> -> Point2D<'Units,'Coordinates> static member ( - ) : lhs:Point2D<'Units,'Coordinates> * rhs:Point2D<'Units,'Coordinates> -> Vector2D<'Units,'Coordinates> + 1 overload ...

val meters : x:float -> y:float -> Point2D<Meters,'Coordinates>

val withRadius : radius:Quantity<'Units> -> center:Point2D<'Units,'Coordinates> -> Circle2D<'Units,'Coordinates>

val throughPoints : p1:Point2D<'Units,'Coordinates> -> p2:Point2D<'Units,'Coordinates> -> p3:Point2D<'Units,'Coordinates> -> Circle2D<'Units,'Coordinates> option

val sweptAround : centerPoint:Point2D<'Units,'Coordinates> -> point:Point2D<'Units,'Coordinates> -> Circle2D<'Units,'Coordinates>

val origin<'Units,'Coordinates> : Point2D<'Units,'Coordinates>

val circle : Circle2D<Meters,Cartesian>

Multiple items
union case Meters.Meters: Meters

--------------------
type Meters = | Meters
<category>Unit</category>

val centerPoint : circle:Circle2D<'Units,'Coordinates> -> Point2D<'Units,'Coordinates>

Circle2D.Center: Point2D<Meters,Cartesian>

val radius : circle:Circle2D<'Units,'Coordinates> -> Quantity<'Units>

Circle2D.Radius: Quantity<Meters>

val diameter : circle:Circle2D<'Units,'Coordinates> -> Quantity<'Units>

val area : circle:Circle2D<'Units,'Coordinates> -> Quantity<Squared<'Units>>

val circumference : circle:Circle2D<'Units,'Coordinates> -> Quantity<'Units>

val toArc : circle:Circle2D<'Units,'Coordinates> -> Arc2D<'Units,'Coordinates>

val boundingBox : circle:Circle2D<'Units,'Coordinates> -> BoundingBox2D<'Units,'Coordinates>

val scaleAbout : point:Point2D<'Units,'Coordinates> -> scale:float -> circle:Circle2D<'Units,'Coordinates> -> Circle2D<'Units,'Coordinates>

val translateBy : displacement:Vector2D<'Units,'Coordinates> -> circle:Circle2D<'Units,'Coordinates> -> Circle2D<'Units,'Coordinates>
<summary> Translate a circle by a given displacement. </summary>

val translateIn : direction:Direction2D<'Coordinates> -> distance:Quantity<'Units> -> circle:Circle2D<'Units,'Coordinates> -> Circle2D<'Units,'Coordinates>
<summary> Translate a circle in a given direction by a given distance. </summary>

val relativeTo : frame:Frame2D<'Units,'GlobalCoordinates,'LocalCoordinates> -> circle:Circle2D<'Units,'GlobalCoordinates> -> Circle2D<'Units,'LocalCoordinates>
<summary> Take a circle defined in global coordinates, and return it expressed in local coordinates relative to a given reference frame. </summary>

val placeIn : frame:Frame2D<'Units,'GlobalCoordinates,'LocalCoordinates> -> circle:Circle2D<'Units,'LocalCoordinates> -> Circle2D<'Units,'GlobalCoordinates>
<summary> Take a circle considered to be defined in local coordinates relative to a given reference frame, and return that circle expressed in global coordinates. </summary>

val containsPoint : point:Point2D<'Units,'Coordinates> -> circle:Circle2D<'Units,'Coordinates> -> bool
<summary> Test if a circle point is contained within a circle. A point is considered to be contained if the point lies on the edge of the circle. </summary>

val intersectsBoundingBox : box:BoundingBox2D<'Units,'Coordinates> -> circle:Circle2D<'Units,'Coordinates> -> bool
<summary> Check if a circle intersects with a given bounding box. This function will return true if the circle intersects the edges of the bounding box _or_ is fully contained within the bounding box. </summary>