OCADml 0.6.0 (latest) · OCaml Package

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 row and column 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

package OCADml