Struct linea::Matrix

pub struct Matrix<A, M: ArrayLength<A>, N: ArrayLength<GenericArray<A, M>> = U1>(_);

Rank-2 array of elements of size known at build time

Methods

impl<A: Copy + Zero + AddAssign + Mul + Div, N: ArrayLength<A> + ArrayLength<<A as Div>::Output>> Matrix<A, N> where
    <A as Mul>::Output: Zero + AddAssign + Radical<U2, Root = A>,
    <A as Div>::Output: Copy, 

pub fn norm(self) -> Matrix<<A as Div>::Output, N> where
    <N as ArrayLength<A>>::ArrayType: Copy, 

Normalize.

impl<A: Copy + Zero + AddAssign, N: ArrayLength<A>> Matrix<A, N> where
    N::ArrayType: Copy, 

pub fn proj<B: Copy>(self, other: Matrix<B, N>) -> Self where
    N: ArrayLength<B> + ArrayLength<<B as Mul>::Output> + ArrayLength<<<A as Mul<B>>::Output as Div<<B as Mul>::Output>>::Output>,
    <N as ArrayLength<B>>::ArrayType: Copy,
    A: Mul<B>,
    <A as Mul<B>>::Output: Zero + AddAssign + Div<<B as Mul>::Output>,
    <<A as Mul<B>>::Output as Div<<B as Mul>::Output>>::Output: Copy + Mul<B, Output = A>,
    B: Mul + Mul<<<A as Mul<B>>::Output as Div<<B as Mul>::Output>>::Output, Output = A>,
    <B as Mul>::Output: Zero + AddAssign, 

Project self onto other.

impl<A: Copy + Zero + AddAssign + Sub<Output = A>, N: ArrayLength<A>> Matrix<A, N> where
    N::ArrayType: Copy, 

pub fn rej<B: Copy>(self, other: Matrix<B, N>) -> Self where
    N: ArrayLength<B> + ArrayLength<<B as Mul>::Output> + ArrayLength<<<A as Mul<B>>::Output as Div<<B as Mul>::Output>>::Output>,
    <N as ArrayLength<B>>::ArrayType: Copy,
    A: Mul<B>,
    <A as Mul<B>>::Output: Zero + AddAssign + Div<<B as Mul>::Output>,
    <<A as Mul<B>>::Output as Div<<B as Mul>::Output>>::Output: Copy + Mul<B, Output = A>,
    B: Mul + Mul<<<A as Mul<B>>::Output as Div<<B as Mul>::Output>>::Output, Output = A>,
    <B as Mul>::Output: Zero + AddAssign, 

Reject self from other.

impl<A, M: ArrayLength<A>, N: ArrayLength<GenericArray<A, M>>> Matrix<A, M, N>

pub const fn from_col_major_array(
    a: GenericArray<GenericArray<A, M>, N>
) -> Self

pub const fn to_col_major_array(self) -> GenericArray<GenericArray<A, M>, N>

impl<A: Copy + Zero, M: ArrayLength<A>> Matrix<A, M>

pub fn diag(self) -> Matrix<A, M, M> where
    M: ArrayLength<GenericArray<A, M>>, 

impl<A, M: ArrayLength<A>, N: ArrayLength<GenericArray<A, M>>> Matrix<A, M, N>

pub fn scale<B: Copy>(self, b: B) -> Matrix<A::Output, M, N> where
    A: Mul<B>,
    M: ArrayLength<A::Output>,
    N: ArrayLength<GenericArray<A::Output, M>>, 

pub fn unscale<B: Copy>(self, b: B) -> Matrix<A::Output, M, N> where
    A: Div<B>,
    M: ArrayLength<A::Output>,
    N: ArrayLength<GenericArray<A::Output, M>>, 

impl<A: Copy, M: ArrayLength<A> + ArrayLength<GenericArray<A, N>>, N: ArrayLength<A> + ArrayLength<GenericArray<A, M>>> Matrix<A, M, N>

pub fn transpose(self) -> Matrix<A, N, M>

impl<A: Copy + Zero, M: ArrayLength<A>, N: ArrayLength<GenericArray<A, M>>> Matrix<A, M, N>

pub fn zero() -> Self

impl<A: Copy + Zero + One, N: ArrayLength<A> + ArrayLength<GenericArray<A, N>>> Matrix<A, N, N>

pub fn one() -> Self

Trait Implementations

impl<A: Debug, M: ArrayLength<A>, N: ArrayLength<GenericArray<A, M>>> Debug for Matrix<A, M, N>

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<B: Copy, A: Copy + Sub<B>, M: ArrayLength<A> + ArrayLength<B> + ArrayLength<A::Output>, N: ArrayLength<GenericArray<A, M>> + ArrayLength<GenericArray<B, M>> + ArrayLength<GenericArray<A::Output, M>>> Sub<Matrix<B, M, N>> for Matrix<A, M, N>

type Output = Matrix<A::Output, M, N>

The resulting type after applying the - operator.

fn sub(self, other: Matrix<B, M, N>) -> Self::Output

Performs the - operation.

impl<A: PartialEq, M: ArrayLength<A>, N: ArrayLength<GenericArray<A, M>>> PartialEq<Matrix<A, M, N>> for Matrix<A, M, N>

fn eq(&self, Matrix: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<A: Eq, M: ArrayLength<A>, N: ArrayLength<GenericArray<A, M>>> Eq for Matrix<A, M, N>

impl<B: Copy, A: Copy + Add<B>, M: ArrayLength<A> + ArrayLength<B> + ArrayLength<A::Output>, N: ArrayLength<GenericArray<A, M>> + ArrayLength<GenericArray<B, M>> + ArrayLength<GenericArray<A::Output, M>>> Add<Matrix<B, M, N>> for Matrix<A, M, N>

type Output = Matrix<A::Output, M, N>

The resulting type after applying the + operator.

fn add(self, other: Matrix<B, M, N>) -> Self::Output

Performs the + operation.

impl<B: Copy, A: Copy + Mul<B>, K: ArrayLength<B> + ArrayLength<GenericArray<A, M>>, M: ArrayLength<A> + ArrayLength<A::Output>, N: ArrayLength<GenericArray<A::Output, M>> + ArrayLength<GenericArray<B, K>>> Mul<Matrix<B, K, N>> for Matrix<A, M, K> where
    A::Output: Zero + AddAssign, 

type Output = Matrix<A::Output, M, N>

The resulting type after applying the * operator.

fn mul(self, Matrix: Matrix<B, K, N>) -> Self::Output

Performs the * operation.

impl<A: Neg, M: ArrayLength<A> + ArrayLength<A::Output>, N: ArrayLength<GenericArray<A, M>> + ArrayLength<GenericArray<A::Output, M>>> Neg for Matrix<A, M, N>

type Output = Matrix<A::Output, M, N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<B: Copy, A: Copy + AddAssign<B>, M: ArrayLength<A> + ArrayLength<B>, N: ArrayLength<GenericArray<A, M>> + ArrayLength<GenericArray<B, M>>> AddAssign<Matrix<B, M, N>> for Matrix<A, M, N>

fn add_assign(&mut self, Matrix: Matrix<B, M, N>)

Performs the += operation.

impl<B: Copy, A: Copy + SubAssign<B>, M: ArrayLength<A> + ArrayLength<B>, N: ArrayLength<GenericArray<A, M>> + ArrayLength<GenericArray<B, M>>> SubAssign<Matrix<B, M, N>> for Matrix<A, M, N>

fn sub_assign(&mut self, Matrix: Matrix<B, M, N>)

Performs the -= operation.

impl<B: Copy, A: Copy + MulAssign<B>, M: ArrayLength<A>, N: ArrayLength<GenericArray<A, M>>> MulAssign<B> for Matrix<A, M, N>

fn mul_assign(&mut self, rhs: B)

Performs the *= operation.

impl<A, N: ArrayLength<A>> Index<usize> for Matrix<A, N>

type Output = A

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<A, N: ArrayLength<A>> IndexMut<usize> for Matrix<A, N>

fn index_mut(&mut self, i: usize) -> &mut A

Performs the mutable indexing (container[index]) operation.

impl<A: Copy, M: ArrayLength<A>, N: ArrayLength<GenericArray<A, M>>> Copy for Matrix<A, M, N> where
    M::ArrayType: Copy,
    N::ArrayType: Copy, 

impl<A: Clone, M: ArrayLength<A>, N: ArrayLength<GenericArray<A, M>>> Clone for Matrix<A, M, N> where
    M::ArrayType: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.