Struct Matrix3

pub struct Matrix3<T> {
    pub m: [[T; 3]; 3],
}

A 3 x 3 Matrix with row major order

Fields

m: [[T; 3]; 3]

Implementations

impl<T> Matrix3<T>

pub fn new(row0: [T; 3], row1: [T; 3], row2: [T; 3]) -> Self

pub fn new_val( r0c0: T, r0c1: T, r0c2: T, r1c0: T, r1c1: T, r1c2: T, r2c0: T, r2c1: T, r2c2: T, ) -> Self

pub fn identity() -> Self

where T: Zero + One,

return the identity

pub fn trace(&self) -> T

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

the trace …

pub fn determinant(&self) -> T

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

Calculate the determinant

Arguments

• self - The Matrix3 the function was called for

pub fn transpose(&self) -> Matrix3<T>

where T: Copy,

Return a transposed matrix transpose matrix (a, b, c) (d, e, f) (g, h, i)

matrix (a, d, g) (b, e, h) (c, f, i)

use feo_math::linear_algebra::matrix3::Matrix3;
let transposed = Matrix3::new(
    [0.0,2.0,2.0],
    [1.0,0.0,2.0],
    [1.0,1.0,0.0]
).transpose();
let result = Matrix3::new(
    [0.0,1.0,1.0],
    [2.0,0.0,1.0],
    [2.0,2.0,0.0]
);
assert_eq!(transposed, result);

pub fn eigen_value(&self) -> [Option<T>; 3]

where T: F32Fmt<F32Fmt = f32> + Add<T, Output = T> + Sub<T, Output = T> + Mul<T, Output = T> + Div<T, Output = T> + Neg<Output = T> + SignOps + F32Fmt + Zero + One + Three + PartialEq + Copy + Rem<T, Output = T> + Two + Primitive + Debug,

Rule: Mv = λv where M = a matrix λ = an eigenvalue v = a eigenvector

as a 3x3 Matrix can have

if v != <0, 0, 0> then: … // self expl todo |M - Iλ| = 0 … // in fn

pub fn eigen_vector(&self, eigen_value: T) -> Vector3<T>

where T: Add<T, Output = T> + Sub<T, Output = T> + Mul<T, Output = T> + Div<T, Output = T> + Debug + Zero + One + Copy,

pub fn cofactor(self) -> Self

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

Get the cofactor matrix of a 3x3 matrix.

pub fn adjugate(self) -> Self

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

Get the adjugate matrix of a 3x3 matrix.

pub fn inverse(&self) -> Self

where T: Add<T, Output = T> + Sub<T, Output = T> + Mul<T, Output = T> + Div<T, Output = T> + Neg<Output = T> + Copy,

Get the inverse of a 3x3 matrix.

use feo_math::linear_algebra::matrix3::Matrix3;
let mat0 = Matrix3::new(
    [1, 1, 0],
    [0, 1, 0],
    [1, 0, 1],
);
let expected = Matrix3::new(
    [ 1, -1,  0],
    [ 0,  1,  0],
    [-1,  1,  1],
);
assert_eq!(mat0.inverse(), expected);

Arguments

• self - The matrix the function is being called for

Trait Implementations

impl<T> Add<T> for Matrix3<T>

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

fn add(self, rhs: T) -> Self::Output

Matrix3 + T = Matrix3

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
let val = 2;
let expected = Matrix3::new(
    [3, 4, 5],
    [4, 5, 3],
    [5, 3, 4]
);
assert_eq!(mat + val, expected);

type Output = Matrix3<T>

The resulting type after applying the + operator.

impl<T> Add for Matrix3<T>

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

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

Matrix3 + Matrix3 = Matrix3

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat0 = Matrix3::new(
    [4, 5, 6],
    [6, 4, 5],
    [5, 6, 4]
);
let mat1 = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
let expected = Matrix3::new(
    [5, 7, 9],
    [8, 7, 6],
    [8, 7, 6] 
);
assert_eq!(mat0 + mat1, expected);

type Output = Matrix3<T>

The resulting type after applying the + operator.

impl<T: Clone> Clone for Matrix3<T>

fn clone(&self) -> Matrix3<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Matrix3<T>

where T: Debug + Copy,

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

Formats the value using the given formatter.

impl<T> Div<T> for Matrix3<T>

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

fn div(self, rhs: T) -> Self::Output

Matrix3 / T = Matrix3

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
let val = 2;
let expected = Matrix3::new(
    [0, 1, 1],
    [1, 1, 0],
    [1, 0, 1]
);
assert_eq!(mat / val, expected);

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
mat / 0;

type Output = Matrix3<T>

The resulting type after applying the / operator.

impl<T> Div for Matrix3<T>

where T: Add<T, Output = T> + Sub<T, Output = T> + Mul<T, Output = T> + Div<T, Output = T> + Neg<Output = T> + Copy,

fn div(self, rhs: Self) -> Self::Output

Matrix3 / Matrix3 = Matrix3

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat0 = Matrix3::new(
    [4, 5, 6],
    [6, 4, 5],
    [5, 6, 4]
);
let mat1 = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
let expected = Matrix3::new(
    [1, 0, 0],
    [0, 0, 1],
    [0, 1, 0] 
);
assert_eq!(mat0 / mat1, expected);

type Output = Matrix3<T>

The resulting type after applying the / operator.

impl<T> F32Fmt for Matrix3<T>

where T: F32Fmt + Copy,

type F32Fmt = Matrix3<<T as F32Fmt>::F32Fmt>

fn intoF32Fmt(self) -> Self::F32Fmt

fn fromF32Fmt(f32_fmt: Self::F32Fmt) -> Self

fn sqrt(self) -> Self

fn cbrt(self) -> Self

fn f32_const_mul(self, constant: f32) -> Self

fn sin_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn cos_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn tan_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn asin_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn acos_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn atan_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn atan2_mul(self, _other: Self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn sinh_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn cosh_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

fn tanh_mul(self, _mul_by: Self) -> Self

where Self: Mul<Self, Output = Self> + Sized,

impl<T> From<Axes<T>> for Matrix3<T>

where T: Copy,

fn from(other: Axes<T>) -> Matrix3<T>

Converts to this type from the input type.

impl<T> From<Euler<T>> for Matrix3<T>

fn from(_: Euler<T>) -> Matrix3<T>

Converts to this type from the input type.

impl<T> From<Matrix3<T>> for [[T; 3]; 3]

fn from(other: Matrix3<T>) -> [[T; 3]; 3]

Converts to this type from the input type.

impl<T> From<Matrix3<T>> for Axes<T>

where T: Mul<T, Output = T> + Div<T, Output = T> + F32Fmt + Add<T, Output = T> + Copy,

fn from(mat: Matrix3<T>) -> Self

Converts to this type from the input type.

impl<T> From<Matrix3<T>> for Euler<T>

fn from(_: Matrix3<T>) -> Self

Converts to this type from the input type.

impl<T> From<Matrix3<T>> for Matrix4<T>

where T: One + Zero + Copy,

fn from(mat3: Matrix3<T>) -> Matrix4<T>

Converts to this type from the input type.

impl<T> From<Matrix3<T>> for Quaternion<T>

where T: F32Fmt + Add<T, Output = T> + Sub<T, Output = T> + Div<T, Output = T> + Mul<T, Output = T> + Debug + Two + One + Zero + Copy,

fn from(mat3: Matrix3<T>) -> Self

Converts to this type from the input type.

impl<T> From<Matrix3<T>> for Rotor<T>

fn from(_: Matrix3<T>) -> Self

Converts to this type from the input type.

impl<T> From<Quaternion<T>> for Matrix3<T>

where T: Add<T, Output = T> + Sub<T, Output = T> + Mul<T, Output = T> + Div<T, Output = T> + Neg<Output = T> + Copy + One + Two,

fn from(other: Quaternion<T>) -> Matrix3<T>

Converts to this type from the input type.

impl<T> From<Rotor<T>> for Matrix3<T>

fn from(_: Rotor<T>) -> Matrix3<T>

Converts to this type from the input type.

impl<T> Mul<T> for Matrix3<T>

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

fn mul(self, other: T) -> Self::Output

Matrix3 * T = Matrix3

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
let val = 2;
let expected = Matrix3::new(
    [2, 4, 6],
    [4, 6, 2],
    [6, 2, 4] 
);
assert_eq!(mat * val, expected);

type Output = Matrix3<T>

The resulting type after applying the * operator.

impl<T> Mul<Vector3<T>> for Matrix3<T>

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

fn mul(self, rhs: Vector3<T>) -> Self::Output

Matrix * Vector3 = Vector3

[r0c0, r0c1, r0c2]   [x]   [x']
[r1c0, r1c1, r1c2] * [y] = [y']
[r2c0, r2c1, r2c2]   [z]   [z']

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat = Matrix3::new(
    [3, 2, 1],
    [1, 3, 2],
    [2, 1, 3]
);
let vec = Vector3::new(1, 3, 2);
assert_eq!(mat * vec, Vector3::new(11, 14, 11));

type Output = Vector3<T>

The resulting type after applying the * operator.

impl<T> Mul for Matrix3<T>

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

fn mul(self, rhs: Self) -> Self::Output

Matrix3 * Matrix3 = Matrix3

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat0 = Matrix3::new(
    [4, 5, 6],
    [6, 4, 5],
    [5, 6, 4]
);
let mat1 = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [2, 1, 2]
);
let expected = Matrix3::new(
    [26, 29, 29],
    [24, 29, 32],
    [25, 32, 29] 
);
assert_eq!(mat0 * mat1, expected);

type Output = Matrix3<T>

The resulting type after applying the * operator.

impl<T> Neg for Matrix3<T>

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

fn neg(self) -> Self::Output

-Matrix3 = Matrix3

Examples

use feo_math::linear_algebra::matrix3::Matrix3;
let mat = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
let expected = Matrix3::new(
    [-1, -2, -3],
    [-2, -3, -1],
    [-3, -1, -2]
);
assert_eq!(-mat, expected);

type Output = Matrix3<T>

The resulting type after applying the - operator.

impl<T> One for Matrix3<T>

where T: Zero + One,

const ONE: Self

The identity matrix

impl<T: PartialEq> PartialEq for Matrix3<T>

fn eq(&self, other: &Matrix3<T>) -> 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<T> Rem<T> for Matrix3<T>

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

fn rem(self, rhs: T) -> Self::Output

Matrix3 % T = Matrix3

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
let val = 2;
let expected = Matrix3::new(
    [1, 0, 1],
    [0, 1, 1],
    [1, 1, 0]
);
assert_eq!(mat % val, expected);

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
mat % 0;

type Output = Matrix3<T>

The resulting type after applying the % operator.

impl<T> Rem for Matrix3<T>

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

fn rem(self, rhs: Self) -> Self::Output

Matrix3 % Matrix3 = Matrix3 Finds the remainder after an ELEMENT WISE division

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat0 = Matrix3::new(
    [4, 5, 6],
    [6, 4, 5],
    [5, 6, 4]
);
let mat1 = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
let expected = Matrix3::new(
    [0, 1, 0],
    [0, 1, 0],
    [2, 0, 0] 
);
assert_eq!(mat0 % mat1, expected);

type Output = Matrix3<T>

The resulting type after applying the % operator.

impl<T> SignOps for Matrix3<T>

fn ptcopysign(self, _sign: Self) -> Self

fn ptsignum(self) -> i8

fn abs(self) -> Self

impl<T> Sub<T> for Matrix3<T>

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

fn sub(self, rhs: T) -> Self::Output

Matrix3 - T = Matrix3

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
let val = 2;
let expected = Matrix3::new(
    [-1,  0,  1],
    [ 0,  1, -1],
    [ 1, -1,  0]
);
assert_eq!(mat - val, expected);

type Output = Matrix3<T>

The resulting type after applying the - operator.

impl<T> Sub for Matrix3<T>

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

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

Matrix3 - Matrix3 = Matrix3

Examples

use feo_math::linear_algebra::vector3::Vector3;
use feo_math::linear_algebra::matrix3::Matrix3;
let mat0 = Matrix3::new(
    [4, 5, 6],
    [6, 4, 5],
    [5, 6, 4]
);
let mat1 = Matrix3::new(
    [1, 2, 3],
    [2, 3, 1],
    [3, 1, 2]
);
let expected = Matrix3::new(
    [3, 3, 3],
    [4, 1, 4],
    [2, 5, 2] 
);
assert_eq!(mat0 - mat1, expected);

type Output = Matrix3<T>

The resulting type after applying the - operator.

impl<T> Two for Matrix3<T>

where T: Zero + Two,

const TWO: Self

The identity matrix * 2

impl<T> Zero for Matrix3<T>

where T: Zero + Copy,

const ZERO: Self

impl<T> Construct<T> for Matrix3<T>

where T: Construct<T>,

impl<T: Copy> Copy for Matrix3<T>

impl<T> SqMatrix<T, Vector3<T>> for Matrix3<T>

where T: Construct<T>,

impl<T> StructuralPartialEq for Matrix3<T>