Struct Mat 

#[repr(transparent)]
pub struct Mat<const N: usize, const M: usize, S: Field>(pub [[S; M]; N]);

Tuple Fields

0: [[S; M]; N]

Implementations

impl<S: Field> Mat<4, 4, S>

pub fn affine(linear: Mat<3, 3, S>, translation: Vect<3, S>) -> Self

pub fn linear(linear: Mat<3, 3, S>) -> Self

pub fn translation(translation: Vect<3, S>) -> Self

pub fn perspective_projection(aspect: S, fov: S, n: S, f: S) -> Self

pub fn uniform_scale(scale: S) -> Self

impl<S: Field, const N: usize, const M: usize> Mat<N, M, S>

pub fn from_scs(array: [[Sc<S>; M]; N]) -> Self

pub fn map<T: Field>(self, f: impl Fn(S) -> T) -> Mat<N, M, T>

impl<const N: usize, const M: usize> Mat<N, M, f32>

pub fn to_f64(self) -> Mat<N, M, f64>

impl<const N: usize, const M: usize> Mat<N, M, f64>

pub fn to_f32(self) -> Mat<N, M, f32>

impl<S: Field, const N: usize, const M: usize> Mat<N, M, S>

pub fn try_index(&self, i: usize, j: usize) -> Option<S>

impl<S: Field, const N: usize> Mat<N, N, S>

pub fn inverse(&self) -> Self

impl<S: Field, const N: usize, const M: usize> Mat<N, M, S>

pub const ZERO: Self

pub fn from_fn<F: Fn(usize, usize) -> S>(f: F) -> Self

impl<S: Field, const N: usize> Mat<N, N, S>

pub const IDENT: Self

impl<S: Field, const N: usize, const M: usize> Mat<N, M, S>

pub fn row(&self, i: usize) -> Vect<M, S>

pub fn col(&self, j: usize) -> Vect<N, S>

impl<S: Field> Mat<4, 4, S>

pub fn flatten(self) -> [S; 16]

Trait Implementations

impl<S: Field, const N: usize, const M: usize> Add for Mat<N, M, S>

type Output = Mat<N, M, S>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<const N: usize, const M: usize, S: Clone + Field> Clone for Mat<N, M, S>

fn clone(&self) -> Mat<N, M, S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize, const M: usize, S: Debug + Field> Debug for Mat<N, M, S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: Field, const N: usize, const M: usize> Default for Mat<N, M, S>

fn default() -> Self

Returns the “default value” for a type.

impl<S: Field> Det for Mat<1, 1, S>

type Output = S

fn det(self) -> S

impl<S: Field> Det for Mat<2, 2, S>

type Output = S

fn det(self) -> S

impl<S: Field> Det for Mat<3, 3, S>

type Output = S

fn det(self) -> S

impl<S: Field + Display, const N: usize, const M: usize> Display for Mat<N, M, S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const N: usize, const M: usize, S: Hash + Field> Hash for Mat<N, M, S>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S: Field, const N: usize, const M: usize> Index<usize> for Mat<N, M, S>

type Output = [S; M]

The returned type after indexing.

fn index(&self, i: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<S: Field, const N: usize, const M: usize, const P: usize> Mul<Mat<M, P, S>> for Mat<N, M, S>

type Output = Mat<N, P, S>

The resulting type after applying the * operator.

fn mul(self, other: Mat<M, P, S>) -> Self::Output

Performs the * operation.

impl<S: Field, const N: usize, const M: usize> Mul<Mat<N, M, S>> for Vect<N, S>

type Output = Vect<N, S>

The resulting type after applying the * operator.

fn mul(self, matrix: Mat<N, M, S>) -> Self::Output

Performs the * operation.

impl<S: Field, const N: usize, const M: usize> Mul<S> for Mat<N, M, S>

type Output = Mat<N, M, S>

The resulting type after applying the * operator.

fn mul(self, scalar: S) -> Self::Output

Performs the * operation.

impl<S: Field, const N: usize, const M: usize> Mul<Vect<M, S>> for Mat<N, M, S>

type Output = Vect<N, S>

The resulting type after applying the * operator.

fn mul(self, vector: Vect<M, S>) -> Self::Output

Performs the * operation.

impl<S: Field, const N: usize, const M: usize> Neg for Mat<N, M, S>

type Output = Mat<N, M, S>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const N: usize, const M: usize, S: PartialEq + Field> PartialEq for Mat<N, M, S>

fn eq(&self, other: &Mat<N, M, S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: Field, const N: usize, const M: usize> Sub for Mat<N, M, S>

type Output = Mat<N, M, S>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<const N: usize, const M: usize, S: Copy + Field> Copy for Mat<N, M, S>

impl<const N: usize, const M: usize, S: Eq + Field> Eq for Mat<N, M, S>

impl<const N: usize, const M: usize, S: Field> StructuralPartialEq for Mat<N, M, S>