Ellipse 2D

Builders

Ellipse2D.from (Point2D.meters 4. 4.) Direction2D.x (Length.meters 2.) (Length.meters 4.)

No value returned by any evaluator

Accessors

let ellipse: Ellipse2D<Meters, Cartesian> =
    Ellipse2D.from (Point2D.meters 4. 4.) Direction2D.x (Length.meters 2.) (Length.meters 4.)

Ellipse2D.axes ellipse // or
ellipse.Axes

No value returned by any evaluator

Ellipse2D.xRadius ellipse // or
ellipse.XRadius

No value returned by any evaluator

Ellipse2D.yRadius ellipse // or
ellipse.YRadius

No value returned by any evaluator

Ellipse2D.centerPoint ellipse

No value returned by any evaluator

Ellipse2D.xAxis ellipse

No value returned by any evaluator

Ellipse2D.yAxis ellipse

No value returned by any evaluator

Ellipse2D.xDirection ellipse

No value returned by any evaluator

Ellipse2D.yDirection ellipse

No value returned by any evaluator

Ellipse2D.area ellipse

No value returned by any evaluator

Modifiers

Ellipse2D.scaleAbout
Ellipse2D.transformBy
Ellipse2D.rotateAround
Ellipse2D.translateBy
Ellipse2D.translateIn
Ellipse2D.relativeTo
Ellipse2D.placeIn

namespace Math

namespace Math.Geometry

namespace Math.Units

Multiple items
union case Cartesian.Cartesian: Cartesian

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

Multiple items
module Ellipse2D from Math.Geometry

--------------------
type Ellipse2D<'Units,'Coordinates> = { Axes: Frame2D<'Units,'Coordinates,unit> XRadius: Quantity<'Units> YRadius: Quantity<'Units> } interface IGeometry<'Coordinates> override Equals : obj:obj -> bool override GetHashCode : unit -> int

val from : centerPoint:Point2D<'Units,'Coordinates> -> xDirection:Direction2D<'Coordinates> -> xRadius:Quantity<'Units> -> yRadius:Quantity<'Units> -> Ellipse2D<'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>

Multiple items
module Direction2D from Math.Geometry

--------------------
type Direction2D<'Coordinates> = { X: float Y: float } interface IComparable interface IComparable<Direction2D<'Coordinates>> interface IGeometry<'Coordinates> member Comparison : other:Direction2D<'Coordinates> -> int override Equals : obj:obj -> bool + 1 overload override GetHashCode : unit -> int member LessThan : other:Direction2D<'Coordinates> -> bool static member xy : x:float -> y:float -> Direction2D<'Coordinates> option

val x<'Coordinates> : Direction2D<'Coordinates>

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 ellipse : Ellipse2D<Meters,Cartesian>

Multiple items
union case Meters.Meters: Meters

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

val axes : ellipse:Ellipse2D<'Units,'Coordinates> -> Frame2D<'Units,'Coordinates,'Defines>
<summary> Get the X and Y axes of an ellipse as a `Frame2D`. </summary>

Ellipse2D.Axes: Frame2D<Meters,Cartesian,unit>

val xRadius : ellipse:Ellipse2D<'Units,'Coordinates> -> Quantity<'Units>
<summary> Get the radius of an ellipse along its X axis. This may be either the minimum or maximum radius. </summary>

Ellipse2D.XRadius: Quantity<Meters>

val yRadius : ellipse:Ellipse2D<'Units,'Coordiantes> -> Quantity<'Units>
<summary> Get the radius of an ellipse along its Y axis. This may be either the minimum or maximum radius. </summary>

Ellipse2D.YRadius: Quantity<Meters>

val centerPoint : ellipse:Ellipse2D<'Units,'Coordinates> -> Point2D<'Units,'Coordinates>
<summary> Get the center point of an ellipse. </summary>

val xAxis : ellipse:Ellipse2D<'Units,'Coordinates> -> Axis2D<'Units,'Coordinates>
<summary> Get the X axis of an ellipse. </summary>

val yAxis : ellipse:Ellipse2D<'Units,'Coordinates> -> Axis2D<'Units,'Coordinates>
<summary> Get the Y axis of an ellipse. </summary>

val xDirection : ellipse:Ellipse2D<'Units,'Coordinates> -> Direction2D<'Coordinates>
<summary> Get the direction of the ellipse's X axis. </summary>

val yDirection : ellipse:Ellipse2D<'Units,'Coordinates> -> Direction2D<'Coordinates>
<summary> Get the direction of an ellipse's Y axis. </summary>

val area : ellipse:Ellipse2D<'Units,'Coordinates> -> Quantity<Squared<'Units>>
<summary> Get the area of an ellipse. </summary>

val scaleAbout : point:Point2D<'Units,'Coordinates> -> scale:float -> ellipse:Ellipse2D<'Units,'Coordinates> -> Ellipse2D<'Units,'Coordinates>
<summary> Scale an ellipse about a given point by a given scale. </summary>

val transformBy : axesTransformation:(Frame2D<'Units,'CoordinatesA,unit> -> Frame2D<'Units,'CoordinatesB,unit>) -> ellipse:Ellipse2D<'Units,'CoordinatesA> -> Ellipse2D<'Units,'CoordinatesB>

val rotateAround : point:Point2D<'Units,'Coordinates> -> angle:Angle -> ellipse:Ellipse2D<'Units,'Coordinates> -> Ellipse2D<'Units,'Coordinates>
<summary> Rotate an ellipse around a given point by a given angle. </summary>

val translateBy : displacement:Vector2D<'Units,'Coordinates> -> ellipse:Ellipse2D<'Units,'Coordinates> -> Ellipse2D<'Units,'Coordinates>
<summary> Translate an ellipse by a given displacement. </summary>

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

val relativeTo : frame:Frame2D<'Units,unit,unit> -> ellipse:Ellipse2D<'Units,unit> -> Ellipse2D<'Units,unit>
<summary> Take an ellipse defined in global coordinates, and return it expressed in local coordinates relative to a given reference frame. </summary>

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