`type t = Signature.point`

The abstract type for points

`val pt : (Num.t * Num.t) -> t`

Construct a point from two numeric values

The following functions create points of length 1. They are especially useful to specify directions with `Path.Vec`

`val dir : float -> t`

`dir f` is the point at angle `f` on the unit circle. `f` shall be given in degrees

The unitary vectors pointing up, down, left and right

`val up : t`
`val down : t`
`val left : t`
`val right : t`
`val origin : t`
`val length : t -> Num.t`

`length p` is the length of vector from the origin to `p`

`val xpart : t -> Num.t`

`xpart p` is the x coordinate of point `p`

`val ypart : t -> Num.t`

`ypart p` is the y coordinate of point `p`

### Operations on points

`val transform : Transform.t -> t -> t`

Apply a transformation to a point

`val segment : float -> t -> t -> t`

`segment f p1 p2` is the point `(1-f)p1 + fp2`. Stated otherwise, if `p1` is at `0.` and `p2` is at `1.`, return the point that lies at `f`

`val add : t -> t -> t`
`val shift : t -> t -> t`

Sum two points

`val sub : t -> t -> t`

Substract two points

`val mult : Num.t -> t -> t`
`val scale : Num.t -> t -> t`

Multiply a point by a scalar

`val rotate : float -> t -> t`

Rotate a point by an angle in degrees

`val rotate_around : t -> float -> t -> t`

`rotate_around p1 f p2` rotates `p2` around `p1` by an angle `f` in degrees

`val xscale : Num.t -> t -> t`

Scales the X coordinate of a point by a scalar

`val yscale : Num.t -> t -> t`

Scales the Y coordinate of a point by a scalar

`val normalize : t -> t`

Normalize the vector represented by the point. The origin becomes the origin

### Convenient constructors

The following functions build a point at a given scale (see `Num.t` for scales)

`val bpp : (float * float) -> t`
`val inp : (float * float) -> t`
`val cmp : (float * float) -> t`
`val mmp : (float * float) -> t`
`val ptp : (float * float) -> t`

Same as the previous functions but build list of points

`val map_bp : (float * float) list -> t list`
`val map_in : (float * float) list -> t list`
`val map_cm : (float * float) list -> t list`
`val map_mm : (float * float) list -> t list`
`val map_pt : (float * float) list -> t list`
`val p : ?scale:(float -> Num.t) -> (float * float) -> t`

Builds a point from a pair of floats

- parameter scale

  a scaling function to be applied to each float; see `Num.t` for scaling functions for usual units

`val ptlist : ?scale:(float -> Num.t) -> (float * float) list -> t list`

Same as `p`, but builds a list of points

`val draw : ?brush:Brush.t -> ?color:Color.t -> ?pen:Pen.t -> t -> Command.t`

Draw a point

- parameter color

  the color of the point; default is black

- parameter pen

  the pen used to draw the pen; default is `Brush.Pen.default`