Struct Matrix 

#[repr(C)]
pub struct Matrix<T, const ROW: usize, const COL: usize> {
    pub columns: Vector<Vector<T, ROW>, COL>,
}

ROW rows, COL columns.

Can be indexed matrix[row][col]

Fields

columns: Vector<Vector<T, ROW>, COL>

Implementations

impl<T, const ROW: usize> Matrix<T, ROW, 1>

pub const fn from_vector(vector: Vector<T, ROW>) -> Matrix<T, ROW, 1>

From a Mx1 vector

impl<T, const ROW: usize, const COL: usize> Matrix<T, ROW, COL>

pub fn from_fn<F>(column_then_row: F) -> Matrix<T, ROW, COL>

where F: FnMut(Vector<i32, 2>) -> T,

Create a matrix from a fn((columns,row))

pub fn from_col_fn<F>(column_then_row: F) -> Matrix<T, ROW, COL>

where F: FnMut(usize, usize) -> T,

pub fn from_row_fn<F>(row_then_column: F) -> Matrix<T, ROW, COL>

where F: FnMut(usize, usize) -> T,

pub const fn from_col( columns: Vector<Vector<T, ROW>, COL>, ) -> Matrix<T, ROW, COL>

pub fn from_col_array(columns: [[T; ROW]; COL]) -> Matrix<T, ROW, COL>

pub fn from_row(rows: Vector<Vector<T, COL>, ROW>) -> Matrix<T, ROW, COL>

where T: Copy,

pub fn from_row_array(rows: [[T; COL]; ROW]) -> Matrix<T, ROW, COL>

where T: Copy,

pub fn col(&self) -> Vector<Vector<T, ROW>, COL>

where T: Copy,

pub fn row(&self) -> Vector<Vector<T, COL>, ROW>

where T: Copy,

pub fn iter_col(&self) -> impl Iterator<Item = Vector<T, ROW>>

where Vector<Vector<T, ROW>, COL>: Copy, T: Copy,

pub fn iter_row(&self) -> impl Iterator<Item = Vector<T, COL>>

where Vector<Vector<T, ROW>, COL>: Copy, T: Copy,

pub fn transpose(&self) -> Matrix<T, COL, ROW>

where T: Copy,

Transpose the matrix

use hexga_math::prelude::*;

assert_eq!(
    Mat2::from_col(vector2(vec2(1., 2.), vec2(3., 4.))).transpose(),
    Mat2::from_col(vector2(vec2(1., 3.), vec2(2., 4.)))
);

assert_eq!(
    Mat::<3,2>::from_col(vector2(vec3(1., 2., 3.), vec3(4., 5., 6.))).transpose(),
    Mat::<2,3>::from_col(vector3(vec2(1., 4.), vec2(2., 5.), vec2(3., 6.)))
);

impl<T> Matrix<T, 2, 2>

where Matrix<T, 2, 2>: Copy + Mul<Vector<T, 2>, Output = Vector<T, 2>>, Vector<T, 2>: Into<Vector<T, 1>>,

pub fn transform_relative(self, relative: Vector<T, 1>) -> Vector<T, 1>

where T: Zero,

pub fn transform_position(self, position: Vector<T, 1>) -> Vector<T, 1>

where T: One,

impl<T> Matrix<T, 3, 3>

where Matrix<T, 3, 3>: Copy + Mul<Vector<T, 3>, Output = Vector<T, 3>>, Vector<T, 3>: Into<Vector<T, 2>>,

pub fn transform_relative(self, relative: Vector<T, 2>) -> Vector<T, 2>

where T: Zero,

pub fn transform_position(self, position: Vector<T, 2>) -> Vector<T, 2>

where T: One,

impl<T> Matrix<T, 4, 4>

where Matrix<T, 4, 4>: Copy + Mul<Vector<T, 4>, Output = Vector<T, 4>>, Vector<T, 4>: Into<Vector<T, 3>>,

pub fn transform_relative(self, relative: Vector<T, 3>) -> Vector<T, 3>

where T: Zero,

pub fn transform_position(self, position: Vector<T, 3>) -> Vector<T, 3>

where T: One,

impl<T, const N: usize> Matrix<T, N, N>

where Matrix<T, N, N>: Copy + Mul<Vector<T, N>, Output = Vector<T, N>>,

pub fn transform(self, value: Vector<T, N>) -> Vector<T, N>

The last value/component is 0 if it is a relative/vector/delta, 1 if it is fixed/point/position in math terms.

impl<T, const N: usize> Matrix<T, N, N>

where T: One + Zero + Copy,

pub const IDENTITY: Matrix<T, N, N> = Self::ONE

Same as One

impl<T, const N: usize> Matrix<T, N, N>

where T: Float,

pub fn inverse(self) -> Option<Matrix<T, N, N>>

Inverse the matrix, or return None if the matrix is singular.

use hexga_math::prelude::*;

assert_eq!(Mat2::IDENTITY.inverse(), Some(Mat2::IDENTITY));

// Non inversible matrix
let mut m2 = Mat2::IDENTITY;
m2.set_y(vec2(0., 0.));
assert_eq!(m2.inverse(), None);

let m2 = Mat2::from_col(vector2(vec2(1., 3.), vec2(2., 4.)));
let m2_inv = m2.inverse().unwrap();

assert_eq!(m2 * m2_inv, Mat2::IDENTITY);

impl<T> Matrix<T, 0, 0>

where T: NumberArithmetic + One,

pub fn det(&self) -> T

impl<T> Matrix<T, 1, 1>

where T: NumberArithmetic + One,

pub fn det(&self) -> T

impl<T> Matrix<T, 2, 2>

where T: NumberArithmetic + One,

pub fn det(&self) -> T

impl<T> Matrix<T, 3, 3>

where T: NumberArithmetic + One,

pub fn det(&self) -> T

impl<T> Matrix<T, 4, 4>

where T: NumberArithmetic + One,

pub fn det(&self) -> T

impl<T, const N: usize> Matrix<T, N, N>

where Matrix<T, N, N>: HaveZ<Vector<T, N>> + Zero, T: Float,

the rotation code is mainly based on glam code

pub fn from_rotation_axis( axis: Vector<T, 3>, angle: AngleOf<T>, ) -> Matrix<T, N, N>

pub fn from_rotation_x(angle: AngleOf<T>) -> Matrix<T, N, N>

pub fn from_rotation_y(angle: AngleOf<T>) -> Matrix<T, N, N>

impl<T, const N: usize> Matrix<T, N, N>

where Matrix<T, N, N>: HaveY<Vector<T, N>> + Zero, T: Float,

pub fn from_rotation_z(angle: AngleOf<T>) -> Matrix<T, N, N>

impl<T, const N: usize> Matrix<T, N, N>

where Matrix<T, N, N>: HaveZ<Vector<T, N>> + One, T: Copy + Zero + One,

pub fn from_scale(scale: Vector<T, N>) -> Matrix<T, N, N>

Put an One for the last component

pub fn from_translation(translation: Vector<T, N>) -> Matrix<T, N, N>

where T: Zero + AddAssign,

Put an Zero for the last component

Methods from Deref<Target = Vector<Vector<T, ROW>, COL>>

pub fn have_x(&self) -> bool

pub fn have_y(&self) -> bool

pub fn have_z(&self) -> bool

pub fn have_w(&self) -> bool

pub fn iter(&self) -> impl Iterator<Item = &T>

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

pub fn normalize(&mut self) -> &mut Vector<T, N>

pub fn set_angle(&mut self, angle: AngleOf<T>) -> &mut Vector<T, N>

where Vector<T, N>: HaveY<T>,

set the angle of the (x, y) axis

pub fn set_length(&mut self, length: T)

pub fn move_to(&mut self, target: Vector<T, N>, speed: T) -> bool

where T: PartialOrd, Vector<T, N>: AddAssign,

return a bool to know if the point reached the destination

Trait Implementations

impl<T, const ROW: usize, const COL: usize> Add for Matrix<T, ROW, COL>

where Vector<Vector<T, ROW>, COL>: Add<Output = Vector<Vector<T, ROW>, COL>>,

type Output = Matrix<T, ROW, COL>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<T, ROW, COL>) -> <Matrix<T, ROW, COL> as Add>::Output

Performs the + operation.

impl<T, const ROW: usize, const COL: usize> AddAssign for Matrix<T, ROW, COL>

where Matrix<T, ROW, COL>: Add<Output = Matrix<T, ROW, COL>> + Copy,

fn add_assign(&mut self, rhs: Matrix<T, ROW, COL>)

Performs the += operation.

impl<T, const ROW: usize, const COL: usize> Binary for Matrix<T, ROW, COL>

where T: Binary,

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

Formats the value using the given formatter.

impl<T, const ROW: usize, const COL: usize> Clone for Matrix<T, ROW, COL>

where T: Clone,

fn clone(&self) -> Matrix<T, ROW, COL>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, const ROW: usize, const COL: usize> Copy for Matrix<T, ROW, COL>

where T: Copy,

impl<T, const ROW: usize, const COL: usize> Debug for Matrix<T, ROW, COL>

where T: Debug,

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

Formats the value using the given formatter.

impl<T, const ROW: usize, const COL: usize> Default for Matrix<T, ROW, COL>

where Vector<Vector<T, ROW>, COL>: Default,

fn default() -> Matrix<T, ROW, COL>

Returns the “default value” for a type.

impl<T, const ROW: usize, const COL: usize> Deref for Matrix<T, ROW, COL>

type Target = Vector<Vector<T, ROW>, COL>

The resulting type after dereferencing.

fn deref(&self) -> &<Matrix<T, ROW, COL> as Deref>::Target

Dereferences the value.

impl<T, const ROW: usize, const COL: usize> DerefMut for Matrix<T, ROW, COL>

fn deref_mut(&mut self) -> &mut <Matrix<T, ROW, COL> as Deref>::Target

Mutably dereferences the value.

impl<'de, T, const ROW: usize, const COL: usize> Deserialize<'de> for Matrix<T, ROW, COL>

where T: Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Matrix<T, ROW, COL>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, const ROW: usize, const COL: usize> Display for Matrix<T, ROW, COL>

where T: Display,

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

Formats the value using the given formatter.

impl<T, const ROW: usize, const COL: usize> Div<T> for Matrix<T, ROW, COL>

where T: Copy + Div,

type Output = Matrix<<T as Div>::Output, ROW, COL>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <Matrix<T, ROW, COL> as Div<T>>::Output

Performs the / operation.

impl<T, const ROW: usize, const COL: usize> DivAssign<T> for Matrix<T, ROW, COL>

where T: Copy + Div<Output = T>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T, const ROW: usize, const COL: usize> Eq for Matrix<T, ROW, COL>

where T: Eq,

impl<T, const ROW: usize> From<Matrix<T, ROW, 1>> for Vector<T, ROW>

where Vector<T, ROW>: Default,

fn from(value: Matrix<T, ROW, 1>) -> Vector<T, ROW>

Converts to this type from the input type.

impl<T, const ROW: usize> From<Vector<T, ROW>> for Matrix<T, ROW, 1>

fn from(value: Vector<T, ROW>) -> Matrix<T, ROW, 1>

Converts to this type from the input type.

impl<T, const N: usize> Half for Matrix<T, N, N>

where T: Half + Zero + Copy,

const HALF: Matrix<T, N, N>

fn is_half(self) -> bool

where Self: PartialEq,

fn is_non_half(self) -> bool

where Self: PartialEq,

impl<T, const ROW: usize, const COL: usize> Hash for Matrix<T, ROW, COL>

where T: Hash,

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

where __H: Hasher,

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<T> HaveW<Vector<T, 4>> for Matrix<T, 4, 4>

fn iter_xyzw<'a>(&'a self) -> impl Iterator<Item = &'a Vector<T, 4>>

where Vector<T, 4>: 'a,

fn iter_xyzw_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut Vector<T, 4>>

where Vector<T, 4>: 'a,

const W_INDEX: usize = W_INDEX

impl<T> HaveX<Vector<T, 1>> for Matrix<T, 1, 1>

fn iter_x<'a>(&'a self) -> impl Iterator<Item = &'a Vector<T, 1>>

where Vector<T, 1>: 'a,

fn iter_x_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut Vector<T, 1>>

where Vector<T, 1>: 'a,

const X_INDEX: usize = X_INDEX

impl<T> HaveX<Vector<T, 2>> for Matrix<T, 2, 2>

fn iter_x<'a>(&'a self) -> impl Iterator<Item = &'a Vector<T, 2>>

where Vector<T, 2>: 'a,

fn iter_x_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut Vector<T, 2>>

where Vector<T, 2>: 'a,

const X_INDEX: usize = X_INDEX

impl<T> HaveX<Vector<T, 3>> for Matrix<T, 3, 3>

fn iter_x<'a>(&'a self) -> impl Iterator<Item = &'a Vector<T, 3>>

where Vector<T, 3>: 'a,

fn iter_x_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut Vector<T, 3>>

where Vector<T, 3>: 'a,

const X_INDEX: usize = X_INDEX

impl<T> HaveX<Vector<T, 4>> for Matrix<T, 4, 4>

fn iter_x<'a>(&'a self) -> impl Iterator<Item = &'a Vector<T, 4>>

where Vector<T, 4>: 'a,

fn iter_x_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut Vector<T, 4>>

where Vector<T, 4>: 'a,

const X_INDEX: usize = X_INDEX

impl<T> HaveY<Vector<T, 2>> for Matrix<T, 2, 2>

fn iter_xy<'a>(&'a self) -> impl Iterator<Item = &'a Vector<T, 2>>

where Vector<T, 2>: 'a,

fn iter_xy_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut Vector<T, 2>>

where Vector<T, 2>: 'a,

const Y_INDEX: usize = Y_INDEX

impl<T> HaveY<Vector<T, 3>> for Matrix<T, 3, 3>

fn iter_xy<'a>(&'a self) -> impl Iterator<Item = &'a Vector<T, 3>>

where Vector<T, 3>: 'a,

fn iter_xy_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut Vector<T, 3>>

where Vector<T, 3>: 'a,

const Y_INDEX: usize = Y_INDEX

impl<T> HaveY<Vector<T, 4>> for Matrix<T, 4, 4>

fn iter_xy<'a>(&'a self) -> impl Iterator<Item = &'a Vector<T, 4>>

where Vector<T, 4>: 'a,

fn iter_xy_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut Vector<T, 4>>

where Vector<T, 4>: 'a,

const Y_INDEX: usize = Y_INDEX

impl<T> HaveZ<Vector<T, 3>> for Matrix<T, 3, 3>

fn iter_xyz<'a>(&'a self) -> impl Iterator<Item = &'a Vector<T, 3>>

where Vector<T, 3>: 'a,

fn iter_xyz_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut Vector<T, 3>>

where Vector<T, 3>: 'a,

const Z_INDEX: usize = Z_INDEX

impl<T> HaveZ<Vector<T, 4>> for Matrix<T, 4, 4>

fn iter_xyz<'a>(&'a self) -> impl Iterator<Item = &'a Vector<T, 4>>

where Vector<T, 4>: 'a,

fn iter_xyz_mut<'a>(&'a mut self) -> impl Iterator<Item = &'a mut Vector<T, 4>>

where Vector<T, 4>: 'a,

const Z_INDEX: usize = Z_INDEX

impl<T, const ROW: usize, const COL: usize> IoLoad for Matrix<T, ROW, COL>

where T: IoLoad,

fn load_own_extensions() -> impl Iterator<Item = &'static str>

Dedicated file extension to load the value. ex png, jpeg for image

fn load_from_bytes_with_own_extension( data: &[u8], path: &str, extension: &str, ) -> Result<Self, IoError>

fn load_from_bytes_with_own_extension_pathless( data: &[u8], extension: &str, ) -> Result<Self, IoErrorKind>

const CAN_BE_LOADED_FROM_TEXT: bool = false

fn load_from_str_with_own_extension( data: &str, path: &str, extension: &str, ) -> Result<Self, IoError>

fn load_from_str_with_own_extension_pathless( data: &str, extension: &str, ) -> Result<Self, IoErrorKind>

fn can_open_own_extension(extension: &str) -> bool

Don’t include the markup language extension like json or ron

fn load_extensions() -> impl Iterator<Item = &'static str>

Also include the markup language extension like json or ron

fn can_open_extension(extension: &str) -> bool

Also include the markup language extension like json or ron

fn load_from<Fs>(path: &str, fs: &mut Fs) -> Result<Self, IoError>

where Fs: IoFsRead,

fn load_from_with_extension<Fs>( path: &str, extension: &str, fs: &mut Fs, ) -> Result<Self, IoError>

where Fs: IoFsRead,

fn load_from_reader<R>(r: R, path: &str) -> Result<Self, IoError>

where R: Read,

Support bytes and str

fn load_from_bytes(data: &[u8], path: &str) -> Result<Self, IoError>

Support bytes and str

fn load_from_bytes_with_extension( data: &[u8], path: &str, extension: &str, ) -> Result<Self, IoError>

Support bytes and str

impl<T, const ROW: usize, const COL: usize> IoSave for Matrix<T, ROW, COL>

where T: IoSave,

fn save_own_extensions() -> impl Iterator<Item = &'static str>

Dedicated file extension to save the value. ex png, jpeg for image

fn save_to_with_own_extension<W, Fs>( &self, path: &str, extension: &str, w: W, fs: &mut Fs, ) -> Result<(), IoError>

where W: Write, Fs: IoFsWrite,

fn save_to_with_own_extension_pathless<W, Fs>( &self, extension: &str, w: W, fs: &mut Fs, ) -> Result<(), IoErrorKind>

where W: Write, Fs: IoFsWrite,

fn save_default_extension() -> Option<&'static str>

When saving, if the extension is missing, the file will use this extension by default

fn can_save_own_extension(extension: &str) -> bool

Don’t include the markup language extension like json or ron

fn save_extensions() -> impl Iterator<Item = &'static str>

Also include the markup language extension like json or ron

fn can_save_extension(extension: &str) -> bool

Also include the markup language extension like json or ron

fn save_to<Fs>(&self, path: &str, fs: &mut Fs) -> Result<(), IoError>

where Fs: IoFsWrite,

fn save_to_with_extension<Fs>( &self, path: &str, extension: &str, fs: &mut Fs, ) -> Result<(), IoError>

where Fs: IoFsWrite,

fn save_with_reader<W, Fs>( &self, path: &str, w: W, fs: &mut Fs, ) -> Result<(), IoError>

where W: Write, Fs: IoFsWrite,

fn save_with_reader_and_extension<W, Fs>( &self, path: &str, extension: &str, w: W, fs: &mut Fs, ) -> Result<(), IoError>

where W: Write, Fs: IoFsWrite,

impl<T, const ROW: usize, const COL: usize> LowerExp for Matrix<T, ROW, COL>

where T: LowerExp,

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

Formats the value using the given formatter.

impl<T, const ROW: usize, const COL: usize> LowerHex for Matrix<T, ROW, COL>

where T: LowerHex,

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

Formats the value using the given formatter.

impl<T, const ROW: usize, const COL: usize> MaxValue for Matrix<T, ROW, COL>

where T: MaxValue + Copy,

const MAX: Matrix<T, ROW, COL>

fn is_max_value(&self) -> bool

where Self: PartialEq,

fn is_non_max_value(&self) -> bool

where Self: PartialEq,

impl<T, const ROW: usize, const COL: usize> MinValue for Matrix<T, ROW, COL>

where T: MinValue + Copy,

const MIN: Matrix<T, ROW, COL>

fn is_min_value(&self) -> bool

where Self: PartialEq,

fn is_not_min_value(&self) -> bool

where Self: PartialEq,

impl<T, const N: usize> MinusOne for Matrix<T, N, N>

where T: MinusOne + Zero + Copy,

const MINUS_ONE: Matrix<T, N, N>

fn minus_one() -> Self

where Self: Sized,

fn set_minus_one(&mut self) -> &mut Self

fn is_minus_one(self) -> bool

where Self: PartialEq + Copy,

fn is_non_minus_one(self) -> bool

where Self: PartialEq + Copy,

impl<T, const ROW: usize, const COL: usize, const COL2: usize> Mul<Matrix<T, COL, COL2>> for Matrix<T, ROW, COL>

where T: NumberArithmetic,

use hexga_math::prelude::*;

let m1  = Mat2P::from_col((point2(7, 6), point2(5, 3)).into());
let m2  = Mat2P::from_col((point2(2, 5), point2(1, 1)).into());
let m3  = Mat2P::from_col((point2(39, 27), point2(12, 9)).into());

assert_eq!(m1 * m2, m3);


let m1 = Matrix::<i32,2,3>::from_col(vector3(vector2(1, 4), vector2(2, 5), vector2(3, 6)));
let m2 = Matrix::<i32,3,2>::from_col(vector2(vector3(7, 9, 11), vector3(8, 10, 12)));
let m3 = Matrix::<i32,2,2>::from_col(vector2(vector2(1*7+2*9+3*11, 4*7+5*9+6*11), vector2(1*8+2*10+3*12, 4*8+5*10+6*12)));

assert_eq!(m1 * m2, m3);

type Output = Matrix<T, ROW, COL2>

The resulting type after applying the * operator.

fn mul( self, rhs: Matrix<T, COL, COL2>, ) -> <Matrix<T, ROW, COL> as Mul<Matrix<T, COL, COL2>>>::Output

Performs the * operation.

impl<T, const ROW: usize, const COL: usize> Mul<T> for Matrix<T, ROW, COL>

where T: Copy + Mul,

type Output = Matrix<<T as Mul>::Output, ROW, COL>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <Matrix<T, ROW, COL> as Mul<T>>::Output

Performs the * operation.

impl<T, const ROW: usize, const COL: usize> Mul<Vector<T, COL>> for Matrix<T, ROW, COL>

where T: NumberArithmetic, Matrix<T, ROW, COL>: Mul<Matrix<T, COL, 1>, Output = Matrix<T, ROW, 1>>, Vector<T, COL>: From<Matrix<T, ROW, 1>>,

type Output = Vector<T, COL>

The resulting type after applying the * operator.

fn mul( self, rhs: Vector<T, COL>, ) -> <Matrix<T, ROW, COL> as Mul<Vector<T, COL>>>::Output

Performs the * operation.

impl<T, const COL: usize> MulAssign for Matrix<T, COL, COL>

where Matrix<T, COL, COL>: Mul<Output = Matrix<T, COL, COL>> + Copy,

fn mul_assign(&mut self, rhs: Matrix<T, COL, COL>)

Performs the *= operation.

impl<T, const ROW: usize, const COL: usize> MulAssign<T> for Matrix<T, ROW, COL>

where T: Copy + Mul<Output = T>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T, const ROW: usize, const COL: usize> NaNValue for Matrix<T, ROW, COL>

where T: NaNValue + Copy,

const NAN: Matrix<T, ROW, COL>

fn is_nan(&self) -> bool

where Self: PartialEq,

fn is_not_nan(&self) -> bool

where Self: PartialEq,

impl<T, const ROW: usize, const COL: usize> Octal for Matrix<T, ROW, COL>

where T: Octal,

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

Formats the value using the given formatter.

impl<T, const N: usize> One for Matrix<T, N, N>

where T: One + Zero + Copy,

const ONE: Matrix<T, N, N>

The neutral element of the multiplication such that x * X::ONE = x

fn one() -> Self

where Self: Sized,

fn set_one(&mut self) -> &mut Self

fn is_one(&self) -> bool

where Self: PartialEq,

fn is_non_one(&self) -> bool

where Self: PartialEq,

impl<T, const ROW: usize, const COL: usize> Ord for Matrix<T, ROW, COL>

where T: Ord,

fn cmp(&self, other: &Matrix<T, ROW, COL>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl<T, const ROW: usize, const COL: usize> PartialEq for Matrix<T, ROW, COL>

where T: PartialEq,

fn eq(&self, other: &Matrix<T, ROW, COL>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T, const ROW: usize, const COL: usize> PartialOrd for Matrix<T, ROW, COL>

where T: PartialOrd,

fn partial_cmp(&self, other: &Matrix<T, ROW, COL>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, const ROW: usize, const COL: usize> Pointer for Matrix<T, ROW, COL>

where T: Pointer,

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

Formats the value using the given formatter.

impl<T, const N: usize> Position<T, N> for Matrix<T, N, N>

where T: Copy,

fn pos(&self) -> Vector<T, N>

fn set_pos(&mut self, pos: Vector<T, N>) -> &mut Matrix<T, N, N>

fn x(&self) -> T

where Vector<T, N>: HaveX<T>,

fn y(&self) -> T

where Vector<T, N>: HaveY<T>,

fn z(&self) -> T

where Vector<T, N>: HaveZ<T>,

fn w(&self) -> T

where Vector<T, N>: HaveW<T>,

fn set_x(&mut self, x: T) -> &mut Self

where Vector<T, N>: HaveX<T>,

fn set_y(&mut self, y: T) -> &mut Self

where Vector<T, N>: HaveY<T>,

fn set_z(&mut self, z: T) -> &mut Self

where Vector<T, N>: HaveZ<T>,

fn set_w(&mut self, w: T) -> &mut Self

where Vector<T, N>: HaveW<T>,

fn with_pos(self, pos: Vector<T, N>) -> Self

where Self: Sized,

fn with_x(self, x: T) -> Self

where Vector<T, N>: HaveX<T>, Self: Sized,

fn with_y(self, y: T) -> Self

where Vector<T, N>: HaveY<T>, Self: Sized,

fn with_z(self, z: T) -> Self

where Vector<T, N>: HaveZ<T>, Self: Sized,

fn with_w(self, w: T) -> Self

where Vector<T, N>: HaveW<T>, Self: Sized,

fn move_by(&mut self, v: impl Into<Vector<T, N>>) -> &mut Self

where Vector<T, N>: Add<Output = Vector<T, N>>,

fn move_neg_by(&mut self, v: impl Into<Vector<T, N>>) -> &mut Self

where Vector<T, N>: Sub<Output = Vector<T, N>>,

fn move_x(&mut self, x: T) -> &mut Self

where Vector<T, N>: HaveX<T> + Zero + Add<Output = Vector<T, N>>,

fn move_y(&mut self, y: T) -> &mut Self

where Vector<T, N>: HaveY<T> + Zero + Add<Output = Vector<T, N>>,

fn move_z(&mut self, z: T) -> &mut Self

where Vector<T, N>: HaveZ<T> + Zero + Add<Output = Vector<T, N>>,

fn move_w(&mut self, w: T) -> &mut Self

where Vector<T, N>: HaveW<T> + Zero + Add<Output = Vector<T, N>>,

fn move_neg_x(&mut self, x: T) -> &mut Self

where Vector<T, N>: HaveX<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>,

fn move_neg_y(&mut self, y: T) -> &mut Self

where Vector<T, N>: HaveY<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>,

fn move_neg_z(&mut self, z: T) -> &mut Self

where Vector<T, N>: HaveZ<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>,

fn move_neg_w(&mut self, w: T) -> &mut Self

where Vector<T, N>: HaveW<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>,

fn moved_by(self, v: impl Into<Vector<T, N>>) -> Self

where Vector<T, N>: Add<Output = Vector<T, N>>, Self: Sized,

fn moved_neg_by(self, v: impl Into<Vector<T, N>>) -> Self

where Vector<T, N>: Sub<Output = Vector<T, N>>, Self: Sized,

fn moved_x(self, x: T) -> Self

where Vector<T, N>: HaveX<T> + Zero + Add<Output = Vector<T, N>>, Self: Sized,

fn moved_y(self, y: T) -> Self

where Vector<T, N>: HaveY<T> + Zero + Add<Output = Vector<T, N>>, Self: Sized,

fn moved_z(self, z: T) -> Self

where Vector<T, N>: HaveZ<T> + Zero + Add<Output = Vector<T, N>>, Self: Sized,

fn moved_w(self, w: T) -> Self

where Vector<T, N>: HaveW<T> + Zero + Add<Output = Vector<T, N>>, Self: Sized,

fn moved_neg_x(self, x: T) -> Self

where Vector<T, N>: HaveX<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>, Self: Sized,

fn moved_neg_y(self, y: T) -> Self

where Vector<T, N>: HaveY<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>, Self: Sized,

fn moved_neg_z(self, z: T) -> Self

where Vector<T, N>: HaveZ<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>, Self: Sized,

fn moved_neg_w(self, w: T) -> Self

where Vector<T, N>: HaveW<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>, Self: Sized,

impl<T, const N: usize> Position<Vector<T, N>, N> for Matrix<T, N, N>

where T: Copy,

fn pos(&self) -> Vector<Vector<T, N>, N>

fn set_pos(&mut self, pos: Vector<Vector<T, N>, N>) -> &mut Matrix<T, N, N>

fn x(&self) -> T

where Vector<T, N>: HaveX<T>,

fn y(&self) -> T

where Vector<T, N>: HaveY<T>,

fn z(&self) -> T

where Vector<T, N>: HaveZ<T>,

fn w(&self) -> T

where Vector<T, N>: HaveW<T>,

fn set_x(&mut self, x: T) -> &mut Self

where Vector<T, N>: HaveX<T>,

fn set_y(&mut self, y: T) -> &mut Self

where Vector<T, N>: HaveY<T>,

fn set_z(&mut self, z: T) -> &mut Self

where Vector<T, N>: HaveZ<T>,

fn set_w(&mut self, w: T) -> &mut Self

where Vector<T, N>: HaveW<T>,

fn with_pos(self, pos: Vector<T, N>) -> Self

where Self: Sized,

fn with_x(self, x: T) -> Self

where Vector<T, N>: HaveX<T>, Self: Sized,

fn with_y(self, y: T) -> Self

where Vector<T, N>: HaveY<T>, Self: Sized,

fn with_z(self, z: T) -> Self

where Vector<T, N>: HaveZ<T>, Self: Sized,

fn with_w(self, w: T) -> Self

where Vector<T, N>: HaveW<T>, Self: Sized,

fn move_by(&mut self, v: impl Into<Vector<T, N>>) -> &mut Self

where Vector<T, N>: Add<Output = Vector<T, N>>,

fn move_neg_by(&mut self, v: impl Into<Vector<T, N>>) -> &mut Self

where Vector<T, N>: Sub<Output = Vector<T, N>>,

fn move_x(&mut self, x: T) -> &mut Self

where Vector<T, N>: HaveX<T> + Zero + Add<Output = Vector<T, N>>,

fn move_y(&mut self, y: T) -> &mut Self

where Vector<T, N>: HaveY<T> + Zero + Add<Output = Vector<T, N>>,

fn move_z(&mut self, z: T) -> &mut Self

where Vector<T, N>: HaveZ<T> + Zero + Add<Output = Vector<T, N>>,

fn move_w(&mut self, w: T) -> &mut Self

where Vector<T, N>: HaveW<T> + Zero + Add<Output = Vector<T, N>>,

fn move_neg_x(&mut self, x: T) -> &mut Self

where Vector<T, N>: HaveX<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>,

fn move_neg_y(&mut self, y: T) -> &mut Self

where Vector<T, N>: HaveY<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>,

fn move_neg_z(&mut self, z: T) -> &mut Self

where Vector<T, N>: HaveZ<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>,

fn move_neg_w(&mut self, w: T) -> &mut Self

where Vector<T, N>: HaveW<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>,

fn moved_by(self, v: impl Into<Vector<T, N>>) -> Self

where Vector<T, N>: Add<Output = Vector<T, N>>, Self: Sized,

fn moved_neg_by(self, v: impl Into<Vector<T, N>>) -> Self

where Vector<T, N>: Sub<Output = Vector<T, N>>, Self: Sized,

fn moved_x(self, x: T) -> Self

where Vector<T, N>: HaveX<T> + Zero + Add<Output = Vector<T, N>>, Self: Sized,

fn moved_y(self, y: T) -> Self

where Vector<T, N>: HaveY<T> + Zero + Add<Output = Vector<T, N>>, Self: Sized,

fn moved_z(self, z: T) -> Self

where Vector<T, N>: HaveZ<T> + Zero + Add<Output = Vector<T, N>>, Self: Sized,

fn moved_w(self, w: T) -> Self

where Vector<T, N>: HaveW<T> + Zero + Add<Output = Vector<T, N>>, Self: Sized,

fn moved_neg_x(self, x: T) -> Self

where Vector<T, N>: HaveX<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>, Self: Sized,

fn moved_neg_y(self, y: T) -> Self

where Vector<T, N>: HaveY<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>, Self: Sized,

fn moved_neg_z(self, z: T) -> Self

where Vector<T, N>: HaveZ<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>, Self: Sized,

fn moved_neg_w(self, w: T) -> Self

where Vector<T, N>: HaveW<T> + Zero + Add<Output = Vector<T, N>>, T: Neg<Output = T>, Self: Sized,

impl<T, const COL: usize> Product for Matrix<T, COL, COL>

where Matrix<T, COL, COL>: One + Mul<Output = Matrix<T, COL, COL>>,

fn product<I>(iter: I) -> Matrix<T, COL, COL>

where I: Iterator<Item = Matrix<T, COL, COL>>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<T, const N: usize> RotationX<T> for Matrix<T, N, N>

where Matrix<T, N, N>: HaveZ<Vector<T, N>> + Zero + Mul<Output = Matrix<T, N, N>>, T: Float,

fn rotate_x(&mut self, angle: AngleOf<T>) -> &mut Matrix<T, N, N>

fn rot_x(&mut self, angle: AngleOf<T>) -> &mut Self

fn rotated_x(self, angle: AngleOf<T>) -> Self

where Self: Sized,

impl<T, const N: usize> RotationY<T> for Matrix<T, N, N>

where Matrix<T, N, N>: HaveZ<Vector<T, N>> + Zero + Mul<Output = Matrix<T, N, N>>, T: Float,

fn rotate_y(&mut self, angle: AngleOf<T>) -> &mut Matrix<T, N, N>

fn rot_y(&mut self, angle: AngleOf<T>) -> &mut Self

fn rotated_y(self, angle: AngleOf<T>) -> Self

where Self: Sized,

impl<T, const N: usize> RotationZ<T> for Matrix<T, N, N>

where Matrix<T, N, N>: HaveY<Vector<T, N>> + Zero + Mul<Output = Matrix<T, N, N>>, T: Float,

fn rotate_z(&mut self, angle: AngleOf<T>) -> &mut Matrix<T, N, N>

fn rot_z(&mut self, angle: AngleOf<T>) -> &mut Self

fn rotated_z(self, angle: AngleOf<T>) -> Self

where Self: Sized,

impl<T, const ROW: usize, const COL: usize> Serialize for Matrix<T, ROW, COL>

where T: Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, const ROW: usize, const COL: usize> StructuralPartialEq for Matrix<T, ROW, COL>

where T: PartialEq,

impl<T, const ROW: usize, const COL: usize> Sub for Matrix<T, ROW, COL>

where Vector<Vector<T, ROW>, COL>: Sub<Output = Vector<Vector<T, ROW>, COL>>,

type Output = Matrix<T, ROW, COL>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<T, ROW, COL>) -> <Matrix<T, ROW, COL> as Sub>::Output

Performs the - operation.

impl<T, const ROW: usize, const COL: usize> SubAssign for Matrix<T, ROW, COL>

where Matrix<T, ROW, COL>: Sub<Output = Matrix<T, ROW, COL>> + Copy,

fn sub_assign(&mut self, rhs: Matrix<T, ROW, COL>)

Performs the -= operation.

impl<T, const ROW: usize, const COL: usize> Sum for Matrix<T, ROW, COL>

where Matrix<T, ROW, COL>: Zero + Add<Output = Matrix<T, ROW, COL>>,

fn sum<I>(iter: I) -> Matrix<T, ROW, COL>

where I: Iterator<Item = Matrix<T, ROW, COL>>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, const ROW: usize, const COL: usize> UpperExp for Matrix<T, ROW, COL>

where T: UpperExp,

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

Formats the value using the given formatter.

impl<T, const ROW: usize, const COL: usize> UpperHex for Matrix<T, ROW, COL>

where T: UpperHex,

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

Formats the value using the given formatter.

impl<T, const ROW: usize, const COL: usize> Zero for Matrix<T, ROW, COL>

where Vector<Vector<T, ROW>, COL>: Zero,

const ZERO: Matrix<T, ROW, COL>

The absorbing element of the multiplication such that x * X::ZERO = X::ZERO

fn zero() -> Self

fn set_zero(&mut self) -> &mut Self

fn is_zero(&self) -> bool

where Self: PartialEq,

fn is_non_zero(&self) -> bool

where Self: PartialEq,