Affine2 (scad_ml.Scad

type row = float * float * float

type t = {

r0c0 : float;

r0c1 : float;

r0c2 : float;

r1c0 : float;

r1c1 : float;

r1c2 : float;

r2c0 : float;

r2c1 : float;

r2c2 : float;

}

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 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).

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

scaling v

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

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