@spec add(mat33(), mat33()) :: mat33()

add(a,b) adds one mat33 to another mat33.

a is the first mat33.

b is the second mat33.

This returns a mat33 which is the element-wise sum of a and b.

@spec apply(mat33(), vec3()) :: vec3()

apply( a, v ) transforms a vec3 by a mat33.

a is the mat33 to transform by.

v is the vec3 to be transformed.

This returns a vec3 representing A**v**.

This is the "full" application of a matrix, and uses all elements.

@spec apply_left(vec3(), mat33()) :: vec3()

apply_left( v, a ) transforms a vec3 by a mat33, applied on the left.

a is the mat33 to transform by.

v is the vec3 to be transformed.

This returns a vec3 representing v**A**.

This is the "full" application of a matrix, and uses all elements.

@spec apply_left_transpose(vec3(), mat33()) :: vec3()

apply_left_transpose( v, a ) transforms a vec3 by a transposed mat33, applied on the left.

a is the mat33 to transform by.

v is the vec3 to be transformed.

This returns a vec3 representing v**A**^T.

This is the "full" application of a matrix, and uses all elements.

@spec apply_transpose(mat33(), vec3()) :: vec3()

apply_transpose( a, v ) transforms a vec3 by a a transposed mat33.

a is the mat33 to transform by.

v is the vec3 to be transformed.

This returns a vec3 representing A^Tv.

This is the "full" application of a matrix, and uses all elements.

@spec at(mat33(), 0..2, 0..2) :: float()

at( a, i, j) selects an element of a mat33.

a is the mat33 to index.

i is the row integer index [0,2].

j is the column integer index [0,2].

This returns a float from the matrix at row i and column j.

@spec cofactor(mat33(), 0..2, 0..2) :: float()

Returns the signed minor at zero-based row i and column j.

This is the determinant of submatrix(a, i, j), negated when i + j is odd. Indices must be integers from 0 through 2; invalid indices raise FunctionClauseError.

@spec column0(mat33()) :: vec3()

column0( a ) selects the first column of a mat33.

a is the mat33 to take the first column of.

This returns a vec3 representing the first column of a.

@spec column1(mat33()) :: vec3()

column1( a ) selects the second column of a mat33.

a is the mat33 to take the second column of.

This returns a vec3 representing the second column of a.

@spec column2(mat33()) :: vec3()

column2( a ) selects the third column of a mat33.

a is the mat33 to take the third column of.

This returns a vec3 representing the third column of a.

@spec determinant(mat33()) :: float()

Returns the determinant of a.

@spec diag(mat33()) :: vec3()

diag( a ) selects the diagonal of a mat33.

a is the mat33 to take the diagonal of.

This returns a vec3 representing the diagonal of a.

@spec identity() :: mat33()

identity() creates an identity mat33.

This returns an identity mat33.

@spec inverse(mat33()) :: mat33()

inverse(a) calculates the inverse matrix

a is a mat33 to be inverted

Returs a mat33 representing a^-1

Raises an error when you try to calculate inverse of a matrix whose determinant is zero

@spec make_reflect_2d(vec2(), float()) :: mat33()

Creates a 2D affine reflection across nx*x + ny*y = offset.

The normal may have any nonzero length. offset is the line equation constant; it is a signed distance only when the normal has unit length. Scaling the normal and offset by the same nonzero factor leaves the mirror unchanged. A zero normal raises ArithmeticError.

Use transform_point/2 for points and transform_vector/2 for directions. The homogeneous coordinate is preserved; translation affects only points.

@spec make_reflect_3d(vec3()) :: mat33()

Creates a 3D linear reflection across the plane through the origin with normal {nx, ny, nz}.

The normal may have any nonzero length; a zero normal raises ArithmeticError. Apply using apply_left/2 with a full 3-component vector.

@spec make_rotate(float()) :: mat33()

make_rotate( theta ) creates a mat33 that rotates a vec2 by theta radians about the +Z axis.

theta is the float of the number of radians of rotation the matrix will provide.

This returns a mat33 which rotates by theta radians about the +Z axis.

@spec make_scale(float()) :: mat33()

make_scale( k ) creates a mat33 that uniformly scales.

k is the float value to scale by.

This returns a mat33 whose diagonal is all ks.

@spec make_scale(float(), float(), float()) :: mat33()

make_scale( sx, sy, sz ) creates a mat33 that scales each axis independently.

sx is a float for scaling the x-axis.

sy is a float for scaling the y-axis.

sz is a float for scaling the z-axis.

This returns a mat33 whose diagonal is { sx, sy, sz }.

Note that, when used with vec2s via the transform methods, sz will have no effect.

@spec make_shear_x_2d(float()) :: mat33()

Creates a 2D affine X shear: x' = x + k*y.

The other spatial coordinates and homogeneous coordinate are unchanged. Use transform_point/2 or transform_vector/2 with 2 spatial components.

@spec make_shear_x_3d(float(), float()) :: mat33()

Creates a 3D linear X shear: x' = x + ky*y + kz*z.

The other spatial coordinates are unchanged. Apply using apply_left/2 with a full 3-component vector.

@spec make_shear_y_2d(float()) :: mat33()

Creates a 2D affine Y shear: y' = y + k*x.

The other spatial coordinates and homogeneous coordinate are unchanged. Use transform_point/2 or transform_vector/2 with 2 spatial components.

@spec make_shear_y_3d(float(), float()) :: mat33()

Creates a 3D linear Y shear: y' = y + kx*x + kz*z.

The other spatial coordinates are unchanged. Apply using apply_left/2 with a full 3-component vector.

@spec make_shear_z_3d(float(), float()) :: mat33()

Creates a 3D linear Z shear: z' = z + kx*x + ky*y.

The other spatial coordinates are unchanged. Apply using apply_left/2 with a full 3-component vector.

@spec make_translate(float(), float()) :: mat33()

make_translate( tx, ty ) creates a mat33 that translates a vec2 by (tx, ty).

tx is a float for translating along the x-axis.

ty is a float for translating along the y-axis.

This returns a mat33 which translates by a vec2 { tx, ty }.

@spec multiply(mat33(), mat33()) :: mat33()

multiply( a, b ) multiply two matrices a and b together.

a is the mat33 multiplicand.

b is the mat33 multiplier.

This returns the mat33 product of the a and b.

@spec multiply_transpose(mat33(), mat33()) :: mat33()

multiply_transpose( a, b ) multiply two matrices a and b^T together.

a is the mat33 multiplicand.

b is the mat33 multiplier.

This returns the mat33 product of the a and b^T.

@spec orthonormalize(mat33()) :: mat33()

Orthonormalizes the three rows of a, returning floating-point entries.

Uses modified Gram-Schmidt with a second orthogonalization pass. Rows are processed in order: the first row keeps its direction, the second has its component along the first removed, and the third has its components along both removed. The resulting rows have unit length and are mutually perpendicular, preserving the input's handedness (including reflections).

Each input row is normalized before removing projections, so the result does not depend on positive scaling of individual rows. Raises ArithmeticError for a zero row or when a remaining perpendicular component has length at most 1.0e-12, treating nearly dependent rows as degenerate.

This treats all three rows as a 3D basis, following the row-vector convention. It is order-dependent and does not preserve 2D homogeneous translation.

Examples

iex> Graphmath.Mat33.orthonormalize({2.0, 0.0, 0.0, 1.0, 3.0, 0.0, 4.0, 5.0, 6.0})
{1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0}

@spec round(mat33(), 0..15) :: mat33()

round( a, sigfigs ) rounds every element of a mat33 to some number of decimal places.

a is the mat33 to round.

sigfigs is an integer on [0,15] of the number of decimal places to round to.

This returns a mat33 which is the result of rounding a.

@spec row0(mat33()) :: vec3()

row0( a ) selects the first row of a mat33.

a is the mat33 to take the first row of.

This returns a vec3 representing the first row of a.

@spec row1(mat33()) :: vec3()

row1( a ) selects the second row of a mat33.

a is the mat33 to take the second row of.

This returns a vec3 representing the second row of a.

@spec row2(mat33()) :: vec3()

row2( a ) selects the third row of a mat33.

a is the mat33 to take the third row of.

This returns a vec3 representing the third row of a.

@spec scale(mat33(), float()) :: mat33()

scale( a, k ) scales every element in a mat33 by a coefficient k.

a is the mat33 to scale.

k is the float to scale by.

This returns a mat33 a scaled element-wise by k.

@spec submatrix(mat33(), 0..2, 0..2) :: Graphmath.Mat22.mat22()

Returns the Graphmath.Mat22 obtained by deleting row i and column j.

The remaining entries retain their row-major order. Indices are zero-based integers from 0 through 2; invalid indices raise FunctionClauseError.

This returns a matrix. Its determinant is the corresponding scalar minor.

@spec subtract(mat33(), mat33()) :: mat33()

subtract(a,b) subtracts one mat33 from another mat33.

a is the minuend.

b is the subtraherd.

This returns a mat33 formed by the element-wise subtraction of b from a.

@spec trace(mat33()) :: float()

Returns the trace, the sum of the diagonal entries.

@spec transform_point(mat33(), vec2()) :: vec2()

Transforms a 2D point {x, y} using the row-vector product {x, y, 1.0} a.

Returns the first two coordinates, including the effect of translation. Use with 2D affine matrices. No perspective division is performed. For a full 3D linear transformation, use apply_left/2 with {x, y, z}.

@spec transform_vector(mat33(), vec2()) :: vec2()

Transforms a 2D direction {x, y} using the row-vector product {x, y, 0.0} a.

Returns the first two coordinates. The zero homogeneous coordinate excludes translation; rotations, scales, reflections and shears still affect the vector. For a full 3D linear transformation, use apply_left/2 with {x, y, z}.

@spec zero() :: mat33()

zero() creates a zeroed mat33.

This returns a zeroed mat33.