matrix

An array of arrays of floats that represent a matrix. Can be any size but transformation matrices are 4x4.

ident

ident(
m: int,n: int,one: float,zero: float,
) -> matrix 

Create identity matrix with dimensions $m \times n$

m:

int

Default: 4

The number of rows

n:

int

Default: 4

The number of columns

one:

float

Default: 1

Value to set as $1$

zero:

float

Default: 0

Value to set as $0$

dim

dim(
m: matrix,
) -> array 

Returns the dimension of the given matrix as (m, n)

m:

matrix

The matrix

column

column(
mat: matrix,n: int,
) -> vector 

Returns the nth column of a matrix as a vector

mat:

matrix

Input matrix

n:

int

The column's index

set-column

set-column(
mat: matrix,n: int,vec: vector,
) -> matrix 

Replaces the nth column of a matrix with the given vector.

mat:

matrix

Input matrix.

n:

int

The index of the column to replace

vec:

vector

The column data to insert.

round

round(
mat: matrix,precision: int,
) -> matrix 

Rounds each value in the matrix to a precision.

mat:

matrix

Input matrix

precision:

int

Default: 8

Rounding precision (digits)

transform-translate

transform-translate(
x: float,y: float,z: float,
) -> matrix 

Returns a $4 \times 4$ translation matrix

x:

float

The translation in the $x$ direction.

y:

float

The translation in the $y$ direction.

z:

float

The translation in the $x$ direction.

transform-shear-x

transform-shear-x(
factor: float,
) -> matrix 

Returns a $4 \times 4$ x-shear matrix

factor:

float

The shear in the $x$ direction.

transform-shear-z

transform-shear-z(
factor: float,
) -> matrix 

Returns a $4 \times 4$ z-shear matrix

factor:

float

The shear in the $z$ direction.

transform-scale

transform-scale(
f: floatarraydictionary,
) -> matrix 

Returns a $4 \times 4$ scale matrix

f:

float or array or dictionary

The scale factor(s) of the matrix. An array of at least 3 floats sets the x, y and z scale factors. A dictionary sets the scale in the direction of the corresponding x, y and z keys. A single float sets the scale for all directions.

transform-rotate-dir

transform-rotate-dir(
dir: vector,up: vector,
) -> matrix 

Returns a $4 \times 4$ rotation xyz matrix for a direction and up vector

dir:

vector

idk

up:

vector

idk

transform-rotate-x

transform-rotate-x(
angle: angle,
) -> matrix 

Returns a $4 \times 4$ $x$ rotation matrix

angle:

angle

The angle to rotate around the $x$ axis

transform-rotate-y

transform-rotate-y(
angle: angle,
) -> matrix 

Returns a $4 \times 4$ $y$ rotation matrix

angle:

angle

The angle to rotate around the $y$ axis

transform-rotate-z

transform-rotate-z(
angle: angle,
) -> matrix 

Returns a $4 \times 4$ $z$ rotation matrix

angle:

angle

The angle to rotate around the $z$ axis

transform-rotate-xz

transform-rotate-xz(
x: angle,z: angle,
) -> matrix 

Returns a $4 \times 4$ $x z$ rotation matrix

x:

angle

The angle to rotate around the $x$ axis

z:

angle

The angle to rotate around the $z$ axis

transform-rotate-ypr

transform-rotate-ypr(
a: angle,b: angle,c: angle,
) -> matrix 

Returns a $4 \times 4$ rotation matrix - yaw-pitch-roll

Calculates the product of the three rotation matrices $R = Rz(a) Ry(b) Rx(c)$

a:

angle

Yaw

b:

angle

Pitch

c:

angle

Roll

transform-rotate-xyz

transform-rotate-xyz(
x: angle,y: angle,z: angle,
) -> matrix 

Returns a $4 \times 4$ rotation matrix - euler angles

Calculates the product of the three rotation matrices $R = Rz(z) Ry(y) Rx(x)$

x:

angle

Rotation about x

y:

angle

Rotation about y

z:

angle

Rotation about z

mul-mat

mul-mat(
..matrices: matrix,
) -> matrix 

Multiplies matrices on top of each other.

..matrices:

matrix

The matrices to multiply from left to right.

mul4x4-vec3

mul4x4-vec3(
mat: matrix,vec: vector,w: float,
) -> vector 

Multiplies a $4 \times 4$ matrix with a vector of size 3 or 4. The resulting is three dimensional

mat:

matrix

The matrix to multiply

vec:

vector

The vector to multiply

w:

float

Default: 1

The default value for the fourth element of the vector if it is three dimensional.

mul-vec

mul-vec(
mat: matrix,vec: vector,
) -> vector 

Multiplies an $m \times n$ matrix with an $m$th dimensional vector where $m \lte 4$. Prefer the use of mul4x4-vec3 when possible as it does not use loops.

mat:

matrix

The matrix to multiply

vec:

vector

The vector to multiply

inverse

inverse(
matrix: matrix,
) -> matrix 

Calculates the inverse matrix of any size.

matrix:

matrix

The matrix to inverse.

swap-cols

swap-cols(
mat: matrix,a: int,b: int,
) -> matrix 

Swaps the ath column with the bth column.

mat:

matrix

Matrix

a:

int

The index of column a.

b:

int

The index of column b.

translate

translate(
mat: matrix,vec: vector,
) 

Translates a matrix by a vector.

mat:

matrix

The matrix to translate

vec:

vector

The vector to translate by.