struct Geode::Matrix4x4(T)

Overview

Matrix with 4 rows and 4 columns. Provides a rectangular array of scalars of the same type.

T is the scalar type. Indices i and j refer to the zero-based row and column index respectively. Unless noted otherwise, all operations are in row-major order.

Included Modules

Extended Modules

Defined in:

geode/matrices/matrix4.cr

Constructors

Class Method Summary

Instance Method Summary

Macro Summary

Instance methods inherited from module Geode::Matrix4x4Transforms3D(T)

reflect_x : self reflect_x, reflect_y : self reflect_y, reflect_z : self reflect_z, rotate(angle : Number | Angle, axis : CommonVector(U, 3)) : CommonMatrix forall U rotate, rotate_x(angle : Number | Angle) : CommonMatrix rotate_x, rotate_y(angle : Number | Angle) : CommonMatrix rotate_y, rotate_z(angle : Number | Angle) : CommonMatrix rotate_z, scale(x, y, z) : CommonMatrix scale, scale3(amount : Number) : CommonMatrix scale3, shear_x(y, z) : CommonMatrix shear_x, shear_y(x, z) : CommonMatrix shear_y, shear_z(x, y) : CommonMatrix shear_z, translate(x, y, z) : CommonMatrix translate

Instance methods inherited from module Geode::SquareMatrix(T, 4, 4)

determinant determinant, diagonal : CommonVector(T, N) diagonal, each_diagonal(& : T -> _) : Nil
each_diagonal : Iterator(T)
each_diagonal
, inv inv, inverse inverse, trace trace

Instance methods inherited from module Geode::CommonMatrix(T, 4, 4)

[](i : Int, j : Int) : T [], []?(i : Int, j : Int) : T? []?, column(j : Int) : CommonVector(T, M) column, column?(j : Int) : CommonVector(T, M)? column?, columns : Int columns, columns_at(*indices) : Tuple columns_at, each_column(& : CommonVector(T, M) -> _) each_column, each_column_with_index(offset = 0, & : CommonVector(T, M), Int32 -> _) each_column_with_index, each_indices(& : Int32, Int32 -> _) each_indices, each_row(& : CommonVector(T, N) -> _) each_row, each_row_with_index(offset = 0, & : CommonVector(T, N), Int32 -> _) each_row_with_index, each_with_indices(& : T, Int32, Int32 -> _) each_with_indices, inspect(io : IO) : Nil inspect, map(& : T -> U) : CommonMatrix forall U map, map_with_index(offset = 0, & : T, Int32 -> U) : CommonMatrix(U, M, N) forall U map_with_index, map_with_indices(& : T, Int32, Int32 -> U) : CommonMatrix(U, M, N) forall U map_with_indices, row(i : Int) : CommonVector(T, N) row, row?(i : Int) : CommonVector(T, N)? row?, rows : Int rows, rows_at(*indices) : Tuple rows_at, size size, square? square?, to_columns : Array to_columns, to_rows : Array to_rows, to_s(io : IO) : Nil to_s, unsafe_fetch(i : Int, j : Int) : T unsafe_fetch, unsafe_fetch_column(j : Int) : CommonVector(T, M) unsafe_fetch_column, unsafe_fetch_row(i : Int) : CommonVector(T, N) unsafe_fetch_row, zip_map(other : CommonMatrix(U, M, N), & : T, U -> V) : CommonMatrix(V, M, N) forall U, V zip_map

Instance methods inherited from module Geode::MatrixVectors(4, 4)

&*(vector : CommonVector(U, P)) : CommonVector forall U, P &*, *(vector : CommonVector(U, P)) : CommonVector forall U, P *, column? column?, row? row?, to_vector : CommonVector to_vector

Instance methods inherited from module Geode::MatrixOperations(4, 4)

&*(scalar : Number) : CommonMatrix &*, &+(other : CommonMatrix(T, M, N)) : CommonMatrix forall T &+, &-(other : CommonMatrix(T, M, N)) : CommonMatrix forall T &-, *(scalar : Number) : CommonMatrix *, +(other : CommonMatrix(T, M, N)) : CommonMatrix forall T +, -(other : CommonMatrix(T, M, N)) : CommonMatrix forall T
- : self
-
, /(scalar : Number) : CommonMatrix /, //(scalar : Number) : CommonMatrix //, abs : self abs, abs2 : self abs2, ceil : self ceil, clamp(min : CommonMatrix(T, M, N), max : CommonMatrix(T, M, N)) : CommonMatrix forall T
clamp(min, max) : CommonMatrix
clamp(range : Range(CommonMatrix(T, M, N), CommonMatrix(T, M, N))) : CommonMatrix forall T
clamp(range : Range) : CommonMatrix
clamp
, edge(edge : CommonMatrix(T, M, N)) : self forall T
edge(edge) : self
edge
, floor : self floor, fraction : self fraction, lerp(other : CommonMatrix(T, M, N), t : Number) : CommonMatrix forall T lerp, round(mode : Number::RoundingMode = :ties_even) : self
round(digits : Number, base = 10, *, mode : Number::RoundingMode = :ties_even) : self
round
, scale(matrix : CommonMatrix(T, M, N)) : CommonMatrix forall T scale, scale!(matrix : CommonMatrix(T, M, N)) : CommonMatrix forall T scale!, sign : self sign

Instance methods inherited from module Geode::MatrixIterators(T, 4, 4)

each_column : Iterator(CommonVector(T, M)) each_column, each_column_with_index(offset = 0) : Iterator(Tuple(CommonVector(T, M), Int32)) each_column_with_index, each_indices : Iterator(Tuple(Int32, Int32)) each_indices, each_row : Iterator(CommonVector(T, N)) each_row, each_row_with_index(offset = 0) : Iterator(Tuple(CommonVector(T, N), Int32)) each_row_with_index, each_with_indices : Iterator(Tuple(T, Int32, Int32)) each_with_indices

Instance methods inherited from module Geode::MatrixComparison(4, 4)

==(other : CommonMatrix(T, M, N)) forall T ==, compare(other : CommonMatrix(T, M, N)) : CommonMatrix(Int32, M, N) forall T compare, eq?(other : CommonMatrix(T, M, N)) : CommonMatrix(Bool, M, N) forall T eq?, ge?(other : CommonMatrix(T, M, N)) : CommonMatrix(Bool, M, N) forall T ge?, gt?(other : CommonMatrix(T, M, N)) : CommonMatrix(Bool, M, N) forall T gt?, le?(other : CommonMatrix(T, M, N)) : CommonMatrix(Bool, M, N) forall T le?, lt?(other : CommonMatrix(T, M, N)) : CommonMatrix(Bool, M, N) forall T lt?, near_zero?(tolerance) near_zero?, zero? zero?

Constructor Detail

def self.identity : self #

Creates an identity matrix.

An identity matrix is a square matrix with ones along the diagonal and zeroes elsewhere.


[View source]
def self.new(matrix : CommonMatrix(T, 4, 4)) #

Copies contents from another matrix.


[View source]
def self.new(&) #

Creates a new matrix by iterating through each element.

Yields the indices (i and j) for the matrix element. The block should return the value to use for the corresponding element.

Matrix4x4.new { |i, j| i * 10 + j }

[View source]
def self.new(rows : Indexable(Indexable(T))) #

Creates a new matrix from nested collections.

The size of rows must be 4. Each row of elements in rows must have a size of 4.


[View source]
def self.new(elements : Indexable(T)) #

Creates a new matrix from a flat collection of elements.

The size of elements must be equal to 4 x 4 (16). Items in elements are consumed in row-major order.


[View source]
def self.new(scalar : T) : self #

Creates a new matrix with the diagonal elements set to a scalar value.

The main diagonal will be filled with scalar. All other elements will be zeroes.


[View source]
def self.zero : self #

Creates a matrix filled with zeroes.


[View source]

Class Method Detail

def self.[](row_0 : Indexable, row_1 : Indexable, row_2 : Indexable, row_3 : Indexable) #

Constructs a matrix with existing elements.

The type of the elements is specified by the type parameter. Each value is cast to the type T.


[View source]

Instance Method Detail

def &*(other : CommonMatrix(U, 4, P)) : Matrix forall U, P #

Multiplies this matrix by another.

The other matrix's row count (M) must be equal to this matrix's column count (N). Produces a new matrix with the row count from this matrix and the column count from other. Matrices can be of any size and type as long as this condition is met.

Values will wrap instead of overflowing and raising an error.


[View source]
def &*(other : Matrix4x1) : Matrix4x1 #

Multiplies this matrix by another.

The other matrix's row count (M) must be equal to this matrix's column count (N). Produces a new matrix with the row count from this matrix and the column count from other. Matrices can be of any size and type as long as this condition is met.

Values will wrap instead of overflowing and raising an error.


[View source]
def &*(other : Matrix4x2) : Matrix4x2 #

Multiplies this matrix by another.

The other matrix's row count (M) must be equal to this matrix's column count (N). Produces a new matrix with the row count from this matrix and the column count from other. Matrices can be of any size and type as long as this condition is met.

Values will wrap instead of overflowing and raising an error.


[View source]
def &*(other : Matrix4x3) : Matrix4x3 #

Multiplies this matrix by another.

The other matrix's row count (M) must be equal to this matrix's column count (N). Produces a new matrix with the row count from this matrix and the column count from other. Matrices can be of any size and type as long as this condition is met.

Values will wrap instead of overflowing and raising an error.


[View source]
def &*(other : Matrix4x4) : Matrix4x4 #

Multiplies this matrix by another.

The other matrix's row count (M) must be equal to this matrix's column count (N). Produces a new matrix with the row count from this matrix and the column count from other. Matrices can be of any size and type as long as this condition is met.

Values will wrap instead of overflowing and raising an error.


[View source]
def *(other : CommonMatrix(U, 4, P)) : Matrix forall U, P #

Multiplies this matrix by another.

The other matrix's row count (M) must be equal to this matrix's column count (N). Produces a new matrix with the row count from this matrix and the column count from other. Matrices can be of any size and type as long as this condition is met.


[View source]
def *(other : Matrix4x1) : Matrix4x1 #

Multiplies this matrix by another.

The other matrix's row count (M) must be equal to this matrix's column count (N). Produces a new matrix with the row count from this matrix and the column count from other. Matrices can be of any size and type as long as this condition is met.


[View source]
def *(other : Matrix4x2) : Matrix4x2 #

Multiplies this matrix by another.

The other matrix's row count (M) must be equal to this matrix's column count (N). Produces a new matrix with the row count from this matrix and the column count from other. Matrices can be of any size and type as long as this condition is met.


[View source]
def *(other : Matrix4x3) : Matrix4x3 #

Multiplies this matrix by another.

The other matrix's row count (M) must be equal to this matrix's column count (N). Produces a new matrix with the row count from this matrix and the column count from other. Matrices can be of any size and type as long as this condition is met.


[View source]
def *(other : Matrix4x4) : Matrix4x4 #

Multiplies this matrix by another.

The other matrix's row count (M) must be equal to this matrix's column count (N). Produces a new matrix with the row count from this matrix and the column count from other. Matrices can be of any size and type as long as this condition is met.


[View source]
def a : T #

Retrieves the element at (0, 0)


[View source]
def b : T #

Retrieves the element at (0, 1)


[View source]
def c : T #

Retrieves the element at (0, 2)


[View source]
def d : T #

Retrieves the element at (0, 3)


[View source]
def determinant #
Description copied from module Geode::SquareMatrix(T, 4, 4)

Computes the determinant of this matrix.

This method can only be called on square matrices.

matrix = Matrix[[1, 4, 7], [5, 8, 2], [9, 3, 6]]
matrix.determinant # => -405

[View source]
def diagonal : Vector4(T) #
Description copied from module Geode::SquareMatrix(T, 4, 4)

Retrieves the elements of the main diagonal.

Returns the elements as a vector.

This method can only be called on square matrices.

matrix = Matrix[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
matrix.diagonal # => (1, 5, 9)

[View source]
def e : T #

Retrieves the element at (1, 0)


[View source]
def f : T #

Retrieves the element at (1, 1)


[View source]
def g : T #

Retrieves the element at (1, 2)


[View source]
def h : T #

Retrieves the element at (1, 3)


[View source]
def i : T #

Retrieves the element at (2, 0)


[View source]
def j : T #

Retrieves the element at (2, 1)


[View source]
def k : T #

Retrieves the element at (2, 2)


[View source]
def l : T #

Retrieves the element at (2, 3)


[View source]
def m : T #

Retrieves the element at (3, 0)


[View source]
def map(& : T -> U) : Matrix4x4 forall U #

Returns a new matrix with elements mapped by the given block.


[View source]
def n : T #

Retrieves the element at (3, 1)


[View source]
def o : T #

Retrieves the element at (3, 2)


[View source]
def p : T #

Retrieves the element at (3, 3)


[View source]
def sub(i : Int, j : Int) : Matrix3x3(T) #

Returns a smaller matrix by removing a row and column.

The row indicated by i and the column indicated by j are removed in the resulting matrix.


[View source]
def to_slice : Slice(T) #

Returns a slice that points to the elements in this matrix.

NOTE The returned slice is only valid for the caller's scope and sub-calls. The slice points to memory on the stack, it will be invalid after the caller returns.


[View source]
def to_unsafe : Pointer(T) #

Returns a pointer to the data for this matrix.

The elements are tightly packed and ordered consecutively in memory.

NOTE The returned pointer is only valid for the caller's scope and sub-calls. The pointer refers to memory on the stack, it will be invalid after the caller returns.


[View source]
def transpose : Matrix4x4(T) #

Returns a new matrix that is transposed from this one.


[View source]
def unsafe_fetch(index : Int) #

Retrieves the scalar value of the component at the given index, without checking size boundaries.

End-users should never invoke this method directly. Instead, methods like #[] and #[]? should be used.

This method should only be directly invoked if the index is certain to be in bounds.


[View source]
def unsafe_fetch_column(j : Int) : Vector4(T) #
Description copied from module Geode::CommonMatrix(T, 4, 4)

Retrieves the column at the specified index.

Returns the elements as a vector. The vector will have a size equal to the number of rows in this matrix. This method does not perform any bounds checks. It should only be used if the indices are guaranteed to be in bounds.

matrix = Matrix[[1, 2, 3], [4, 5, 6]]
matrix.unsafe_fetch_column(1) # => (2, 5)

[View source]
def unsafe_fetch_row(i : Int) : Vector4(T) #
Description copied from module Geode::CommonMatrix(T, 4, 4)

Retrieves the row at the specified index.

Returns the elements as a vector. The vector will have a size equal to the number of columns in this matrix. This method does not perform any bounds checks. It should only be used if the indices are guaranteed to be in bounds.

matrix = Matrix[[1, 2, 3], [4, 5, 6]]
matrix.unsafe_fetch_row(1) # => (4, 5, 6)

[View source]

Macro Detail

macro [](*rows) #

Constructs a matrix with existing elements.

The type of the elements is derived from the type of each argument. The size of rows must be 4 and the size of each row must be 4.


[View source]