Module Gg.M3

module M3: sig .. end

type t = Gg.m3 
The type for 3D square matrices.
val dim : int
dim is the dimension of rows and columns.
type v = Gg.v3 
The type for rows and columns as vectors.

Constructors, accessors and constants

val v : float ->
float -> float -> float -> float -> float -> float -> float -> float -> Gg.m3
v e00 e01 e02 e10 e11 e12 e20 e21 e22 is a matrix whose components are specified in row-major order
val of_rows : Gg.v3 -> Gg.v3 -> Gg.v3 -> Gg.m3
of_rows r0 r1 r2 is the matrix whose rows are r0, r1 and r2.
val of_cols : Gg.v3 -> Gg.v3 -> Gg.v3 -> Gg.m3
of_cols c0 c1 c2 is the matrix whose columns are c0, c1 and c2.
val el : int -> int -> Gg.m3 -> float
el i j a is the element aij. See also the direct element accessors.
Raises Invalid_argument if i or j is not in [0;Gg.M3.dim[.
val row : int -> Gg.m3 -> Gg.v3
row i a is the ith row of a.
Raises Invalid_argument if i is not in [0;Gg.M3.dim[.
val col : int -> Gg.m3 -> Gg.v3
col j a is the jth column of a.
Raises Invalid_argument if j is not in [0;Gg.M3.dim[.
val zero : Gg.m3
zero is the neutral element for Gg.M3.add.
val id : Gg.m3
id is the identity matrix, the neutral element for Gg.M3.mul.
val of_m2_v2 : Gg.m2 -> Gg.v2 -> Gg.m3
of_m2_v2 m v is the matrix whose first two rows are those of m,v side by side and the third is 0 0 1.
val of_m4 : Gg.m4 -> Gg.m3
of_m4 m extracts the 3D linear part (top-left 3x3 matrix) of m.
val of_quat : Gg.quat -> Gg.m3
of_quat q is the rotation of the unit quaternion q as 3D matrix.


val neg : Gg.m3 -> Gg.m3
neg a is the negated matrix -a.
val add : Gg.m3 -> Gg.m3 -> Gg.m3
add a b is the matrix addition a + b.
val sub : Gg.m3 -> Gg.m3 -> Gg.m3
sub a b is the matrix subtraction a - b.
val mul : Gg.m3 -> Gg.m3 -> Gg.m3
mul a b is the matrix multiplication a * b.
val emul : Gg.m3 -> Gg.m3 -> Gg.m3
emul a b is the element wise multiplication of a and b.
val ediv : Gg.m3 -> Gg.m3 -> Gg.m3
ediv a b is the element wise division of a and b.
val smul : float -> Gg.m3 -> Gg.m3
smul s a is a's elements multiplied by the scalar s.
val transpose : Gg.m3 -> Gg.m3
transpose a is the transpose aT.
val trace : Gg.m3 -> float
trace a is the matrix trace trace(a).
val det : Gg.m3 -> float
det a is the determinant |a|.
val inv : Gg.m3 -> Gg.m3
inv a is the inverse matrix a-1.

2D space transformations

val move2 : Gg.v2 -> Gg.m3
move2 d translates 2D space in the x and y dimensions according to d.
val rot2 : ?pt:Gg.p2 -> float -> Gg.m3
rot2 pt theta rotates 2D space around the point pt by theta radians. pt defaults to Gg.P2.o.
val scale2 : Gg.v2 -> Gg.m3
See Gg.M2.scale2.
val rigid2 : move:Gg.v2 -> rot:float -> Gg.m3
rigid2 move theta is the rigid body transformation of 2D space that rotates by theta radians and then translates by move.
val srigid2 : move:Gg.v2 -> rot:float -> scale:Gg.v2 -> Gg.m3
srigid2 move theta scale is like Gg.M3.rigid2 but starts by scaling according to scale.

3D space transformations

val rot3_map : Gg.v3 -> Gg.v3 -> Gg.m3
rot3_map u v rotates 3D space to map the unit vector u on the unit vector v.
val rot3_axis : Gg.v3 -> float -> Gg.m3
rot_axis v theta rotates 3D space by theta radians around the unit vector v.
val rot3_zyx : Gg.v3 -> Gg.m3
rot3_zyx r rotates 3D space first by V3.x r radians around the x-axis, then by V3.y r radians around the y-axis and finally by V3.z r radians around the z-axis.
val scale3 : Gg.v3 -> Gg.m3
scale3 s scales 3D space in the x, y and z dimensions according to s.


val map : (float -> float) -> Gg.m3 -> Gg.m3
map f a is the element wise application of f to a.
val mapi : (int -> int -> float -> float) -> Gg.m3 -> Gg.m3
mapi f a is like but the element indices are also given.
val fold : ('a -> float -> 'a) -> 'a -> Gg.m3 -> 'a
fold f acc a is f (...(f (f acc a00) a10)...).
val foldi : ('a -> int -> int -> float -> 'a) -> 'a -> Gg.m3 -> 'a
foldi f acc a is f (...(f (f acc 0 0 a00) 1 0 a10)...).
val iter : (float -> unit) -> Gg.m3 -> unit
iter f a is f a00; f a10; ...
val iteri : (int -> int -> float -> unit) -> Gg.m3 -> unit
iteri f a is f 0 0 a00; f 1 0 a10; ...

Predicates and comparisons

val for_all : (float -> bool) -> Gg.m3 -> bool
for_all p a is p a00 && p a10 && ...
val exists : (float -> bool) -> Gg.m3 -> bool
exists p a is p a00 || p a10 || ...
val equal : Gg.m3 -> Gg.m3 -> bool
equal a b is a = b.
val equal_f : (float -> float -> bool) -> Gg.m3 -> Gg.m3 -> bool
equal_f eq a b tests a and b like Gg.M3.equal but uses eq to test floating point values.
val compare : Gg.m3 -> Gg.m3 -> int
compare a b is a b. That is lexicographic comparison in column-major order.
val compare_f : (float -> float -> int) -> Gg.m3 -> Gg.m3 -> int
compare_f cmp a b compares a and b like but uses cmp to compare floating point values.


val pp : Format.formatter -> Gg.m3 -> unit
pp ppf a prints a textual representation of a on ppf.
val pp_f : (Format.formatter -> float -> unit) -> Format.formatter -> Gg.m3 -> unit
pp_f pp_e ppf a prints a like Gg.M3.pp but uses pp_e to print floating point values.

Element accessors

val e00 : Gg.m3 -> float
val e01 : Gg.m3 -> float
val e02 : Gg.m3 -> float
val e10 : Gg.m3 -> float
val e11 : Gg.m3 -> float
val e12 : Gg.m3 -> float
val e20 : Gg.m3 -> float
val e21 : Gg.m3 -> float
val e22 : Gg.m3 -> float