Struct beagle::mat::Mat

pub struct Mat<R, C, S>(_)
 where
    C: Dim<S>,
    R: TwoDim<S, C>,
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>;

An row-major array of vectors, written Mat<R, C, T> but pronounced 'matrix'.

R represents the number of rows. C represents the number of columns.

Matrices support binary operations between two Matrices or between one Matrix and one Scalar. All Arithmetic operators and Bitwise operators are supported, where the two Scalar types involved support the operation. Most operations operate on each component separately.

The exceptions is matrix multiplied by matrix, which requires performs a linear algebraic multiplication and requires the underlying Scalar types to support Add and Mul.

Matrices can be multiplied by a vector, vector multiplied by matrix, both of which also require the underlying Scalar types to support Add and Mul.

Matrices also support Negation and Logical Negation where the underlying Scalar Type supports it.

Methods

impl<S, C: Dim<S>, R: TwoDim<S, C>> Mat<R, C, S> where
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>, 

fn new(m: <R as Array<C::RawType>>::RawType) -> Self where
    R: Array<C::RawType>,
    <R as Array<C::RawType>>::RawType: Into<<R as Array<C::RawType>>::Type>,
    C::RawType: Into<C::Type>, 

Construct a matrix from an array of arrays

fn from_value(s: S) -> Self where
    S: Clone,
    C::Type: Clone, 

Construct a matrix from a single value

impl<S, C: Dim<S>, R: TwoDim<S, C>> Mat<R, C, S> where
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>, 

fn outer_product<Lhs, Rhs>(lhs: Lhs, rhs: Rhs) -> Self where
    C: Dim<Lhs::Scalar> + Array<Rhs::Scalar>,
    R: Dim<Rhs::Scalar> + Array<<C as Array<Lhs::Scalar>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type>,
    <C as Array<Lhs::Scalar>>::Type: Clone,
    Lhs: VecArrayVal<Row = C>,
    Rhs: VecArrayVal<Row = R>,
    Lhs::Scalar: Mul<Rhs::Scalar, Output = S>,
    Rhs::Scalar: Clone,
    C::Smaller: Array<Lhs::Scalar>,
    R::Smaller: Array<Rhs::Scalar>, 

Constructs a matrix via the outer product of lhs and rhs.

Trait Implementations

impl<R: Clone, C: Clone, S: Clone> Clone for Mat<R, C, S> where
    C: Dim<S>,
    R: TwoDim<S, C>,
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>,
    R::Type: Clone, 

fn clone(&self) -> Mat<R, C, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Copy, C: Copy, S: Copy> Copy for Mat<R, C, S> where
    C: Dim<S>,
    R: TwoDim<S, C>,
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>,
    R::Type: Copy, 

impl<R: Debug, C: Debug, S: Debug> Debug for Mat<R, C, S> where
    C: Dim<S>,
    R: TwoDim<S, C>,
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>,
    R::Type: Debug, 

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

Formats the value using the given formatter.

impl<R: Default, C: Default, S: Default> Default for Mat<R, C, S> where
    C: Dim<S>,
    R: TwoDim<S, C>,
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>,
    R::Type: Default, 

fn default() -> Mat<R, C, S>

Returns the "default value" for a type.

impl<R: PartialEq, C: PartialEq, S: PartialEq> PartialEq for Mat<R, C, S> where
    C: Dim<S>,
    R: TwoDim<S, C>,
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>,
    R::Type: PartialEq, 

fn eq(&self, __arg_0: &Mat<R, C, S>) -> bool

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

fn ne(&self, __arg_0: &Mat<R, C, S>) -> bool

This method tests for !=.

impl<R: Eq, C: Eq, S: Eq> Eq for Mat<R, C, S> where
    C: Dim<S>,
    R: TwoDim<S, C>,
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>,
    R::Type: Eq, 

impl<S, C: Dim<S>, R: TwoDim<S, C>> Deref for Mat<R, C, S> where
    R: Dim<Vec<C, S>>,
    <R as Array<Vec<C, S>>>::Type: Deref<Target = <R as Array<Vec<C, S>>>::RawType>,
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<Vec<C, S>>, 

type Target = <R as Array<Vec<C, S>>>::RawType

The resulting type after dereferencing

fn deref(&self) -> &<R as Array<Vec<C, S>>>::RawType

The method called to dereference a value

impl<S, C: Dim<S>, R: TwoDim<S, C>> DerefMut for Mat<R, C, S> where
    R: Dim<Vec<C, S>>,
    <R as Array<Vec<C, S>>>::Type: DerefMut<Target = <R as Array<Vec<C, S>>>::RawType>,
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<Vec<C, S>>, 

fn deref_mut(&mut self) -> &mut <R as Array<Vec<C, S>>>::RawType

The method called to mutably dereference a value

impl<S, C: Dim<S>, R: TwoDim<S, C>> ScalarArray for Mat<R, C, S> where
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>, 

type Scalar = S

The type of the underlying scalar in the array.

type Row = C

The type of a single element of this type (a single row for matrices/a scalar for vectors).

type Dim = R

The dimension of the scalar array.

impl<S, C: Dim<S>, R: TwoDim<S, C>> ScalarArrayVal for Mat<R, C, S> where
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>, 

fn get_val(self) -> R::Type

Extract the inner array

impl<S, C: DimRef<S>, R: TwoDimRef<S, C>> ScalarArrayRef for Mat<R, C, S> where
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>, 

fn get_ref(&self) -> <R as Array<<C as Array<&S>>::Type>>::Type

Extract the inner array references

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>> ScalarArrayMut for Mat<R, C, S> where
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>, 

fn get_mut(&mut self) -> <R as Array<<C as Array<&mut S>>::Type>>::Type

Extract the inner array mutable references

impl<S, T, C: Dim<S>, C2: Dim<T>, R: TwoDim<S, C>, R2: TwoDim<T, C2>> HasConcreteScalarArray<T, C2, R2> for Mat<R, C, S> where
    C::Smaller: Array<S>,
    C2::Smaller: Array<T>,
    R::Smaller: Array<<C as Array<S>>::Type>,
    R2::Smaller: Array<<C2 as Array<T>>::Type>, 

type Concrete = Mat<R2, C2, T>

The type of a concrete ScalarArray of the specified type

impl<S, C: Dim<S>, R: TwoDim<S, C>> ConcreteScalarArray for Mat<R, C, S> where
    C::Smaller: Array<S>,
    R::Smaller: Array<<C as Array<S>>::Type>, 

fn from_val(v: R::Type) -> Self

Create from an array

impl<S, C: Dim<S>, R: TwoDim<S, C>> Neg for Mat<R, C, S> where
    C: Dim<S::Output>,
    R: TwoDim<S::Output, C>,
    S: Neg,
    C::Smaller: Array<S> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the - operator

fn neg(self) -> Self::Output

The method for the unary - operator

impl<S, C: Dim<S>, R: TwoDim<S, C>> Not for Mat<R, C, S> where
    C: Dim<S::Output>,
    R: TwoDim<S::Output, C>,
    S: Not,
    C::Smaller: Array<S> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the ! operator

fn not(self) -> Self::Output

The method for the unary ! operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> BitAnd<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar> + Dim<S::Output>,
    R: TwoDim<Rhs::Scalar, C> + TwoDim<S::Output, C>,
    S: BitAnd<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the & operator

fn bitand(self, rhs: Rhs) -> Self::Output

The method for the & operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> BitAnd<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs> + Dim<S::Output>,
    R: TwoDim<Rhs, C> + TwoDim<S::Output, C>,
    S: BitAnd<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the & operator

fn bitand(self, rhs: Value<Rhs>) -> Self::Output

The method for the & operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> BitOr<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar> + Dim<S::Output>,
    R: TwoDim<Rhs::Scalar, C> + TwoDim<S::Output, C>,
    S: BitOr<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the | operator

fn bitor(self, rhs: Rhs) -> Self::Output

The method for the | operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> BitOr<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs> + Dim<S::Output>,
    R: TwoDim<Rhs, C> + TwoDim<S::Output, C>,
    S: BitOr<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the | operator

fn bitor(self, rhs: Value<Rhs>) -> Self::Output

The method for the | operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> BitXor<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar> + Dim<S::Output>,
    R: TwoDim<Rhs::Scalar, C> + TwoDim<S::Output, C>,
    S: BitXor<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: Rhs) -> Self::Output

The method for the ^ operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> BitXor<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs> + Dim<S::Output>,
    R: TwoDim<Rhs, C> + TwoDim<S::Output, C>,
    S: BitXor<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the ^ operator

fn bitxor(self, rhs: Value<Rhs>) -> Self::Output

The method for the ^ operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Shl<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar> + Dim<S::Output>,
    R: TwoDim<Rhs::Scalar, C> + TwoDim<S::Output, C>,
    S: Shl<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the << operator

fn shl(self, rhs: Rhs) -> Self::Output

The method for the << operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Shl<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs> + Dim<S::Output>,
    R: TwoDim<Rhs, C> + TwoDim<S::Output, C>,
    S: Shl<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the << operator

fn shl(self, rhs: Value<Rhs>) -> Self::Output

The method for the << operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Shr<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar> + Dim<S::Output>,
    R: TwoDim<Rhs::Scalar, C> + TwoDim<S::Output, C>,
    S: Shr<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the >> operator

fn shr(self, rhs: Rhs) -> Self::Output

The method for the >> operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Shr<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs> + Dim<S::Output>,
    R: TwoDim<Rhs, C> + TwoDim<S::Output, C>,
    S: Shr<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the >> operator

fn shr(self, rhs: Value<Rhs>) -> Self::Output

The method for the >> operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Add<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar> + Dim<S::Output>,
    R: TwoDim<Rhs::Scalar, C> + TwoDim<S::Output, C>,
    S: Add<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the + operator

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

The method for the + operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Add<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs> + Dim<S::Output>,
    R: TwoDim<Rhs, C> + TwoDim<S::Output, C>,
    S: Add<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the + operator

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

The method for the + operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Div<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar> + Dim<S::Output>,
    R: TwoDim<Rhs::Scalar, C> + TwoDim<S::Output, C>,
    S: Div<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the / operator

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

The method for the / operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Div<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs> + Dim<S::Output>,
    R: TwoDim<Rhs, C> + TwoDim<S::Output, C>,
    S: Div<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the / operator

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

The method for the / operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Rem<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar> + Dim<S::Output>,
    R: TwoDim<Rhs::Scalar, C> + TwoDim<S::Output, C>,
    S: Rem<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the % operator

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

The method for the % operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Rem<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs> + Dim<S::Output>,
    R: TwoDim<Rhs, C> + TwoDim<S::Output, C>,
    S: Rem<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the % operator

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

The method for the % operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Sub<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar> + Dim<S::Output>,
    R: TwoDim<Rhs::Scalar, C> + TwoDim<S::Output, C>,
    S: Sub<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the - operator

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

The method for the - operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Sub<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs> + Dim<S::Output>,
    R: TwoDim<Rhs, C> + TwoDim<S::Output, C>,
    S: Sub<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the - operator

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

The method for the - operator

impl<S, C: Dim<S>, R: TwoDim<S, C>, Rhs> Mul<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs> + Dim<S::Output>,
    R: TwoDim<Rhs, C> + TwoDim<S::Output, C>,
    S: Mul<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<S::Output>>::Type>, 

type Output = Mat<R, C, S::Output>

The resulting type after applying the * operator

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

The method for the * operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> BitAndAssign<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar>,
    R: TwoDim<Rhs::Scalar, C>,
    S: BitAndAssign<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn bitand_assign(&mut self, rhs: Rhs)

The method for the &= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> BitAndAssign<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs>,
    R: TwoDim<Rhs, C>,
    S: BitAndAssign<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn bitand_assign(&mut self, rhs: Value<Rhs>)

The method for the &= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> BitOrAssign<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar>,
    R: TwoDim<Rhs::Scalar, C>,
    S: BitOrAssign<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn bitor_assign(&mut self, rhs: Rhs)

The method for the |= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> BitOrAssign<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs>,
    R: TwoDim<Rhs, C>,
    S: BitOrAssign<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn bitor_assign(&mut self, rhs: Value<Rhs>)

The method for the |= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> BitXorAssign<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar>,
    R: TwoDim<Rhs::Scalar, C>,
    S: BitXorAssign<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn bitxor_assign(&mut self, rhs: Rhs)

The method for the ^= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> BitXorAssign<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs>,
    R: TwoDim<Rhs, C>,
    S: BitXorAssign<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn bitxor_assign(&mut self, rhs: Value<Rhs>)

The method for the ^= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> ShlAssign<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar>,
    R: TwoDim<Rhs::Scalar, C>,
    S: ShlAssign<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn shl_assign(&mut self, rhs: Rhs)

The method for the <<= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> ShlAssign<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs>,
    R: TwoDim<Rhs, C>,
    S: ShlAssign<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn shl_assign(&mut self, rhs: Value<Rhs>)

The method for the <<= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> ShrAssign<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar>,
    R: TwoDim<Rhs::Scalar, C>,
    S: ShrAssign<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn shr_assign(&mut self, rhs: Rhs)

The method for the >>= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> ShrAssign<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs>,
    R: TwoDim<Rhs, C>,
    S: ShrAssign<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn shr_assign(&mut self, rhs: Value<Rhs>)

The method for the >>= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> AddAssign<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar>,
    R: TwoDim<Rhs::Scalar, C>,
    S: AddAssign<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn add_assign(&mut self, rhs: Rhs)

The method for the += operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> AddAssign<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs>,
    R: TwoDim<Rhs, C>,
    S: AddAssign<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn add_assign(&mut self, rhs: Value<Rhs>)

The method for the += operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> DivAssign<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar>,
    R: TwoDim<Rhs::Scalar, C>,
    S: DivAssign<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn div_assign(&mut self, rhs: Rhs)

The method for the /= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> DivAssign<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs>,
    R: TwoDim<Rhs, C>,
    S: DivAssign<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn div_assign(&mut self, rhs: Value<Rhs>)

The method for the /= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> RemAssign<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar>,
    R: TwoDim<Rhs::Scalar, C>,
    S: RemAssign<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn rem_assign(&mut self, rhs: Rhs)

The method for the %= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> RemAssign<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs>,
    R: TwoDim<Rhs, C>,
    S: RemAssign<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn rem_assign(&mut self, rhs: Value<Rhs>)

The method for the %= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> SubAssign<Rhs> for Mat<R, C, S> where
    Rhs: ScalarArrayVal<Row = C, Dim = R>,
    C: Dim<Rhs::Scalar>,
    R: TwoDim<Rhs::Scalar, C>,
    S: SubAssign<Rhs::Scalar>,
    C::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs::Scalar>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn sub_assign(&mut self, rhs: Rhs)

The method for the -= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> SubAssign<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs>,
    R: TwoDim<Rhs, C>,
    S: SubAssign<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn sub_assign(&mut self, rhs: Value<Rhs>)

The method for the -= operator

impl<S, C: DimMut<S>, R: TwoDimMut<S, C>, Rhs> MulAssign<Value<Rhs>> for Mat<R, C, S> where
    Rhs: Clone,
    <C as Array<Rhs>>::Type: Clone,
    C: Dim<Rhs>,
    R: TwoDim<Rhs, C>,
    S: MulAssign<Rhs>,
    C::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C as Array<Rhs>>::Type> + Array<<C as Array<&'a S>>::Type> + Array<<C as Array<&'a mut S>>::Type>, 

fn mul_assign(&mut self, rhs: Value<Rhs>)

The method for the *= operator

impl<S, C, R, V> Mul<V> for Mat<R, C, S> where
    C: Dim<S> + Dim<V::Scalar>,
    R: TwoDim<S, C> + TwoDim<V::Scalar, V::Row> + Dim<<S as Mul<V::Scalar>>::Output>,
    V: VecArrayVal<Row = C> + HasConcreteVecArray<<S as Mul<<V as ScalarArray>::Scalar>>::Output, R>,
    V::Row: Dim<V::Scalar>,
    <V::Row as Array<V::Scalar>>::Type: Clone,
    S: Mul<V::Scalar>,
    <S as Mul<V::Scalar>>::Output: Add<Output = <S as Mul<V::Scalar>>::Output>,
    <V as HasConcreteScalarArray<<S as Mul<V::Scalar>>::Output, R, One>>::Concrete: ConcreteVecArray,
    C::Smaller: Array<S> + Array<V::Scalar>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<V::Row as Array<V::Scalar>>::Type> + Array<<S as Mul<V::Scalar>>::Output>, 

type Output = V::Concrete

The resulting type after applying the * operator

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

The method for the * operator

impl<S, C, R, C2, T> Mul<Mat<C, C2, T>> for Mat<R, C, S> where
    C: DimMut<S> + TwoDim<T, C2> + Dim<<C2 as Array<S>>::Type>,
    R: TwoDim<S, C> + TwoDim<S::Output, C2> + Array<<C as Array<<C2 as Array<T>>::Type>>::Type>,
    C2: Dim<T> + Dim<S::Output> + Array<S>,
    S: Mul<T> + Clone,
    S::Output: Add<Output = S::Output>,
    <C as Array<<C2 as Array<T>>::Type>>::Type: Clone,
    C::Smaller: Array<S> + Array<<C2 as Array<T>>::Type> + Array<<C2 as Array<S>>::Type>,
    R::Smaller: Array<<C as Array<S>>::Type> + Array<<C2 as Array<S::Output>>::Type>,
    C2::Smaller: Array<T> + Array<S::Output>, 

type Output = Mat<R, C2, S::Output>

The resulting type after applying the * operator

fn mul(self, rhs: Mat<C, C2, T>) -> Self::Output

The method for the * operator