# Module `OCADml.Affine2`

A 2d affine transformation matrix.

`type row = float * float * float`
`type t = Gg.m3`
`val id : t`

The identity matrix.

## Basic Matrix Operations

`val mul : t -> t -> t`

`mul a b`

Multiply the matrices `a` and `b`.

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

`add a b`

Element by element addition of the matrices `a` and `b`.

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

`sub a b`

Element by element subtraction of the matrix `b` from `a`.

`val emul : t -> t -> t`

`emul a b`

Element by element multiplication of the matrices `a` and `b`.

`val ediv : t -> t -> t`

`ediv a b`

Element by element division of the matrix `a` by `b`.

`val smul : t -> float -> t`

`smul t s`

Multiply each element of the matrix `t` by the scalar `s`.

`val sdiv : t -> float -> t`

`sdiv t s`

Divide each element of the matrix `t` by the scalar `s`.

`val sadd : t -> float -> t`

`sadd t s`

Add the scalar `s` to each element of the matrix `t`.

`val ssub : t -> float -> t`

`ssub t s`

Subtract the scalar `s` to from each element of the matrix `t`.

`val transpose : t -> t`

`transpose t`

Transpose the rows and columns of `t`.

`val map : (float -> float) -> t -> t`

`map f t`

Apply the function `f` to all elements of `t`.

`val trace : t -> float`

`trace t`

Sum the elements on the main diagonal (upper left to lower right) of `t`.

`val get : t -> int -> int -> float`

`get t r c`

Get the element at `r`ow and `c`olumn of `t`. Equivalent to `t.(r).(c)`. Raises `Invalid_argument` if access is out of bounds.

`val compose : t -> t -> t`

`compose a b`

Compose the affine transformations `a` and `b`. Equivalent to `mul b a`, which when applied, will perform the transformation `a`, then the transformation `b`.

`val (%>) : t -> t -> t`

`a %> b`

Alias to `compose`.

`val (%) : t -> t -> t`

`a % b`

Mathematical composition of affine transformations `a` and `b`, equivalent to `mul a b`.

## Construction

```val v : float -> float -> float -> float -> float -> float -> float -> float -> float -> t```

`v e00 e01 e02 e10 e11 e12 e20 e21 e22`

Create a 2d affine matrix from elements in row major order.

### Construction by Rows

`val of_rows : row -> row -> t`

`of_rows rows`

Create an 2d affine transformation matrix from two rows. The last row is set to `0., 0., 1.`.

`val of_row_matrix_exn : float array array -> t`

`of_row_matrix_exn m`

Convert the float matrix `m` into a `t` if it is the correct shape (3 x 3), otherwise raise `Invalid_argument`.

`val of_row_matrix : float array array -> (t, string) Stdlib.result`

`of_row_matrix m`

Convert the float matrix `m` into a `t` if it is the correct shape (3 x 3).

## Element Accessors

`val e00 : t -> float`
`val e01 : t -> float`
`val e02 : t -> float`
`val e10 : t -> float`
`val e11 : t -> float`
`val e12 : t -> float`
`val e20 : t -> float`
`val e21 : t -> float`
`val e22 : t -> float`

## Transforms

`val translate : V2.t -> t`

`translation v`

Create a 2d affine transformation matrix from the xy translation vector `v`.

`val xtrans : float -> t`

`xtrans x`

Create a 2d affine transformation matrix that applies a translation of `x` distance along the x-axis.

`val ytrans : float -> t`

`ytrans y`

Create a 2d affine transformation matrix that applies a translation of `y` distance along the y-axis.

`val rotate : ?about:V2.t -> float -> t`

`rotate ?about r`

Create an affine transformation matrix that applies a rotation of `r` radians around the origin (or the point `about` if provided).

`val zrot : ?about:V2.t -> float -> t`

`zrot ?about r`

Create an affine transformation matrix that applies a rotation of `r` radians around the origin (or the point `about` if provided). Alias of `rotate`.

`val align : V2.t -> V2.t -> t`

`align a b`

Compute an affine transformation matrix that would bring the vector `a` into alignment with `b`.

`val scale : V2.t -> t`

`scale v`

Create a 2d affine transformation matrix from the xyz scaling vector `v`.

`val xscale : float -> t`

`xscale x`

Create a 2d affine transformation matrix that applies x-axis scaling.

`val yscale : float -> t`

`yscale y`

Create a 2d affine transformation matrix that applies y-axis scaling.

`val mirror : V2.t -> t`

`mirror ax`

Create an affine transformation matrix that applies a reflection across the axis `ax`.

`val skew : float -> float -> t`

`skew xa ya`

Create an affine transformation matrix that applies a skew transformation along the xy plane.

• `xa`: skew angle (in radians) in the direction of the x-axis
• `ya`: skew angle (in radians) in the direction of the y-axis
`val transform : t -> V2.t -> V2.t`

`transform t v`

Apply the 2d affine transformation matrix `t` to the vector `v`.

## Conversions

`val lift : t -> Affine3.t`

## Output

`val to_string : t -> string`