Struct beagle::vec::Vec

pub struct Vec<D, S>(_)
 where
    D: Dim<S>,
    D::Smaller: Array<S>;

An array of Scalars, written Vec<D, V> but pronounced 'vector'.

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

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

Methods

impl<S, D: Dim<S>> Vec<D, S> where
    D::Smaller: Array<S>, 

fn new(v: D::RawType) -> Self where
    D::RawType: Into<D::Type>, 

Construct a vector from an array

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

Construct a Vector from a single value

Trait Implementations

impl<D, S, I0, I1> Index<Swizzle2<I0, I1>> for Vec<D, S> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

type Output = Vec2Ref<D, S, I0, I1>

The returned type after indexing

fn index(&self, _: Swizzle2<I0, I1>) -> &Self::Output

The method for the indexing (container[index]) operation

impl<D, S, I0, I1, I2> Index<Swizzle3<I0, I1, I2>> for Vec<D, S> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

type Output = Vec3Ref<D, S, I0, I1, I2>

The returned type after indexing

fn index(&self, _: Swizzle3<I0, I1, I2>) -> &Self::Output

The method for the indexing (container[index]) operation

impl<D, S, I0, I1, I2, I3> Index<Swizzle4<I0, I1, I2, I3>> for Vec<D, S> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

type Output = Vec4Ref<D, S, I0, I1, I2, I3>

The returned type after indexing

fn index(&self, _: Swizzle4<I0, I1, I2, I3>) -> &Self::Output

The method for the indexing (container[index]) operation

impl<D, S, I0, I1> IndexMut<Swizzle2<I0, I1>> for Vec<D, S> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1>,
    I0: IsSmallerThan<D> + NotSame<I1>,
    I1: IsSmallerThan<D> + NotSame<I0>,
    D::Smaller: Array<S>, 

fn index_mut(&mut self, _: Swizzle2<I0, I1>) -> &mut Self::Output

The method for the mutable indexing (container[index]) operation

impl<D, S, I0, I1, I2> IndexMut<Swizzle3<I0, I1, I2>> for Vec<D, S> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D> + NotSame<I1> + NotSame<I2>,
    I1: IsSmallerThan<D> + NotSame<I0> + NotSame<I2>,
    I2: IsSmallerThan<D> + NotSame<I0> + NotSame<I1>,
    D::Smaller: Array<S>, 

fn index_mut(&mut self, _: Swizzle3<I0, I1, I2>) -> &mut Self::Output

The method for the mutable indexing (container[index]) operation

impl<D, S, I0, I1, I2, I3> IndexMut<Swizzle4<I0, I1, I2, I3>> for Vec<D, S> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D> + NotSame<I1> + NotSame<I2> + NotSame<I3>,
    I1: IsSmallerThan<D> + NotSame<I0> + NotSame<I2> + NotSame<I3>,
    I2: IsSmallerThan<D> + NotSame<I0> + NotSame<I1> + NotSame<I3>,
    I3: IsSmallerThan<D> + NotSame<I0> + NotSame<I1> + NotSame<I2>,
    D::Smaller: Array<S>, 

fn index_mut(&mut self, _: Swizzle4<I0, I1, I2, I3>) -> &mut Self::Output

The method for the mutable indexing (container[index]) operation

impl<D, S, I0, I1, I2, I3> Index<SwizzleExtract<I0, I1, I2, I3>> for Vec<D, S> where
    D: Dim<S> + ExtractArray<I0, I3>,
    I0: IsSmallerThan<D> + IsSmallerThan<I3>,
    I3: IsSmallerThan<D> + IsLargerThan<I0>,
    D::Extracted: Dim<S>,
    D::Smaller: Array<S>,
    <D::Extracted as HasSmaller>::Smaller: Array<S>, 

type Output = Vec<D::Extracted, S>

The returned type after indexing

fn index(&self, _: SwizzleExtract<I0, I1, I2, I3>) -> &Self::Output

The method for the indexing (container[index]) operation

impl<D, S, I0, I1, I2, I3> IndexMut<SwizzleExtract<I0, I1, I2, I3>> for Vec<D, S> where
    D: Dim<S> + ExtractArray<I0, I3>,
    I0: IsSmallerThan<D> + IsSmallerThan<I3>,
    I3: IsSmallerThan<D> + IsLargerThan<I0>,
    D::Extracted: Dim<S>,
    D::Smaller: Array<S>,
    <D::Extracted as HasSmaller>::Smaller: Array<S>, 

fn index_mut(&mut self, _: SwizzleExtract<I0, I1, I2, I3>) -> &mut Self::Output

The method for the mutable indexing (container[index]) operation

impl<D: Clone, S: Clone> Clone for Vec<D, S> where
    D: Dim<S>,
    D::Smaller: Array<S>,
    D::Type: Clone, 

fn clone(&self) -> Vec<D, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: Copy, S: Copy> Copy for Vec<D, S> where
    D: Dim<S>,
    D::Smaller: Array<S>,
    D::Type: Copy, 

impl<D: Debug, S: Debug> Debug for Vec<D, S> where
    D: Dim<S>,
    D::Smaller: Array<S>,
    D::Type: Debug, 

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

Formats the value using the given formatter.

impl<D: Default, S: Default> Default for Vec<D, S> where
    D: Dim<S>,
    D::Smaller: Array<S>,
    D::Type: Default, 

fn default() -> Vec<D, S>

Returns the "default value" for a type.

impl<D: PartialEq, S: PartialEq> PartialEq for Vec<D, S> where
    D: Dim<S>,
    D::Smaller: Array<S>,
    D::Type: PartialEq, 

fn eq(&self, __arg_0: &Vec<D, S>) -> bool

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

fn ne(&self, __arg_0: &Vec<D, S>) -> bool

This method tests for !=.

impl<D: Eq, S: Eq> Eq for Vec<D, S> where
    D: Dim<S>,
    D::Smaller: Array<S>,
    D::Type: Eq, 

impl<S, D: Dim<S>> Deref for Vec<D, S> where
    D::Type: Deref<Target = D::RawType>,
    D::Smaller: Array<S>, 

type Target = D::RawType

The resulting type after dereferencing

fn deref(&self) -> &D::RawType

The method called to dereference a value

impl<S, D: Dim<S>> DerefMut for Vec<D, S> where
    D::Type: DerefMut<Target = D::RawType>,
    D::Smaller: Array<S>, 

fn deref_mut(&mut self) -> &mut D::RawType

The method called to mutably dereference a value

impl<S, D: Dim<S>> Index<usize> for Vec<D, S> where
    D::Type: AsRef<[S]>,
    D::Smaller: Array<S>, 

type Output = S

The returned type after indexing

fn index(&self, rhs: usize) -> &S

The method for the indexing (container[index]) operation

impl<S, D: Dim<S>> IndexMut<usize> for Vec<D, S> where
    D::Type: AsRef<[S]> + AsMut<[S]>,
    D::Smaller: Array<S>, 

fn index_mut(&mut self, rhs: usize) -> &mut S

The method for the mutable indexing (container[index]) operation

impl<S, D: Dim<S>> ScalarArray for Vec<D, S> where
    D::Smaller: Array<S>, 

type Scalar = S

The type of the underlying scalar in the array.

type Row = D

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

type Dim = One

The dimension of the scalar array.

impl<S, D: Dim<S>> ScalarArrayVal for Vec<D, S> where
    D::Smaller: Array<S>, 

fn get_val(self) -> CustomArrayOne<D::Type>

Extract the inner array

impl<S, D: DimRef<S>> ScalarArrayRef for Vec<D, S> where
    D::Smaller: Array<S> + Array<&'a S>, 

fn get_ref(&self) -> <One as Array<<D as Array<&S>>::Type>>::Type

Extract the inner array references

impl<S, D: DimMut<S>> ScalarArrayMut for Vec<D, S> where
    D::Smaller: Array<S> + Array<&'a S> + Array<&'a mut S>, 

fn get_mut(&mut self) -> <One as Array<<D as Array<&mut S>>::Type>>::Type

Extract the inner array mutable references

impl<S, D: Dim<S>> VecArrayVal for Vec<D, S> where
    D::Smaller: Array<S>, 

fn get_vec_val(self) -> D::Type

Extract the inner array

impl<S, D: DimRef<S>> VecArrayRef for Vec<D, S> where
    D::Smaller: Array<S> + Array<&'a S>, 

fn get_vec_ref(&self) -> <D as Array<&S>>::Type

Extract the inner array references

impl<S, T, D: Dim<S>, D2: Dim<T>> HasConcreteScalarArray<T, D2> for Vec<D, S> where
    D::Smaller: Array<S>,
    D2::Smaller: Array<T>, 

type Concrete = Vec<D2, T>

The type of a concrete ScalarArray of the specified type

impl<S, D: Dim<S>> ConcreteScalarArray for Vec<D, S> where
    D::Smaller: Array<S>, 

fn from_val(v: <One as Array<D::Type>>::Type) -> Self

Create from an array

impl<S, T, D: Dim<S>, D2: Dim<T>> HasConcreteVecArray<T, D2> for Vec<D, S> where
    D::Smaller: Array<S>,
    D2::Smaller: Array<T>, 

impl<S, D: Dim<S>> ConcreteVecArray for Vec<D, S> where
    D::Smaller: Array<S>, 

fn from_vec_val(v: D::Type) -> Self

Create from an array

impl<S, D: Dim<S>> Neg for Vec<D, S> where
    D: Dim<S::Output>,
    S: Neg,
    D::Smaller: Array<S> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the - operator

fn neg(self) -> Self::Output

The method for the unary - operator

impl<S, D: Dim<S>> Not for Vec<D, S> where
    D: Dim<S::Output>,
    S: Not,
    D::Smaller: Array<S> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the ! operator

fn not(self) -> Self::Output

The method for the unary ! operator

impl<S, D: Dim<S>, Rhs> BitAnd<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar> + Dim<S::Output>,
    S: BitAnd<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the & operator

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

The method for the & operator

impl<S, D: Dim<S>, Rhs> BitAnd<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs> + Dim<S::Output>,
    S: BitAnd<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the & operator

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

The method for the & operator

impl<S, D: Dim<S>, Rhs> BitOr<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar> + Dim<S::Output>,
    S: BitOr<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the | operator

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

The method for the | operator

impl<S, D: Dim<S>, Rhs> BitOr<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs> + Dim<S::Output>,
    S: BitOr<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the | operator

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

The method for the | operator

impl<S, D: Dim<S>, Rhs> BitXor<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar> + Dim<S::Output>,
    S: BitXor<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the ^ operator

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

The method for the ^ operator

impl<S, D: Dim<S>, Rhs> BitXor<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs> + Dim<S::Output>,
    S: BitXor<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the ^ operator

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

The method for the ^ operator

impl<S, D: Dim<S>, Rhs> Shl<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar> + Dim<S::Output>,
    S: Shl<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the << operator

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

The method for the << operator

impl<S, D: Dim<S>, Rhs> Shl<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs> + Dim<S::Output>,
    S: Shl<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the << operator

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

The method for the << operator

impl<S, D: Dim<S>, Rhs> Shr<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar> + Dim<S::Output>,
    S: Shr<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the >> operator

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

The method for the >> operator

impl<S, D: Dim<S>, Rhs> Shr<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs> + Dim<S::Output>,
    S: Shr<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the >> operator

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

The method for the >> operator

impl<S, D: Dim<S>, Rhs> Add<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar> + Dim<S::Output>,
    S: Add<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the + operator

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

The method for the + operator

impl<S, D: Dim<S>, Rhs> Add<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs> + Dim<S::Output>,
    S: Add<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the + operator

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

The method for the + operator

impl<S, D: Dim<S>, Rhs> Div<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar> + Dim<S::Output>,
    S: Div<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the / operator

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

The method for the / operator

impl<S, D: Dim<S>, Rhs> Div<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs> + Dim<S::Output>,
    S: Div<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the / operator

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

The method for the / operator

impl<S, D: Dim<S>, Rhs> Mul<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar> + Dim<S::Output>,
    S: Mul<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the * operator

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

The method for the * operator

impl<S, D: Dim<S>, Rhs> Mul<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs> + Dim<S::Output>,
    S: Mul<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the * operator

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

The method for the * operator

impl<S, D: Dim<S>, Rhs> Rem<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar> + Dim<S::Output>,
    S: Rem<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the % operator

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

The method for the % operator

impl<S, D: Dim<S>, Rhs> Rem<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs> + Dim<S::Output>,
    S: Rem<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the % operator

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

The method for the % operator

impl<S, D: Dim<S>, Rhs> Sub<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar> + Dim<S::Output>,
    S: Sub<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the - operator

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

The method for the - operator

impl<S, D: Dim<S>, Rhs> Sub<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs> + Dim<S::Output>,
    S: Sub<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>, 

type Output = Vec<D, S::Output>

The resulting type after applying the - operator

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

The method for the - operator

impl<S, D: DimMut<S>, Rhs> BitAndAssign<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar>,
    S: BitAndAssign<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>, 

fn bitand_assign(&mut self, rhs: Rhs)

The method for the &= operator

impl<S, D: DimMut<S>, Rhs> BitAndAssign<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs>,
    S: BitAndAssign<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>, 

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

The method for the &= operator

impl<S, D: DimMut<S>, Rhs> BitOrAssign<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar>,
    S: BitOrAssign<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>, 

fn bitor_assign(&mut self, rhs: Rhs)

The method for the |= operator

impl<S, D: DimMut<S>, Rhs> BitOrAssign<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs>,
    S: BitOrAssign<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>, 

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

The method for the |= operator

impl<S, D: DimMut<S>, Rhs> BitXorAssign<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar>,
    S: BitXorAssign<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>, 

fn bitxor_assign(&mut self, rhs: Rhs)

The method for the ^= operator

impl<S, D: DimMut<S>, Rhs> BitXorAssign<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs>,
    S: BitXorAssign<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>, 

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

The method for the ^= operator

impl<S, D: DimMut<S>, Rhs> ShlAssign<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar>,
    S: ShlAssign<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>, 

fn shl_assign(&mut self, rhs: Rhs)

The method for the <<= operator

impl<S, D: DimMut<S>, Rhs> ShlAssign<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs>,
    S: ShlAssign<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>, 

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

The method for the <<= operator

impl<S, D: DimMut<S>, Rhs> ShrAssign<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar>,
    S: ShrAssign<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>, 

fn shr_assign(&mut self, rhs: Rhs)

The method for the >>= operator

impl<S, D: DimMut<S>, Rhs> ShrAssign<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs>,
    S: ShrAssign<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>, 

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

The method for the >>= operator

impl<S, D: DimMut<S>, Rhs> AddAssign<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar>,
    S: AddAssign<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>, 

fn add_assign(&mut self, rhs: Rhs)

The method for the += operator

impl<S, D: DimMut<S>, Rhs> AddAssign<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs>,
    S: AddAssign<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>, 

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

The method for the += operator

impl<S, D: DimMut<S>, Rhs> DivAssign<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar>,
    S: DivAssign<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>, 

fn div_assign(&mut self, rhs: Rhs)

The method for the /= operator

impl<S, D: DimMut<S>, Rhs> DivAssign<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs>,
    S: DivAssign<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>, 

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

The method for the /= operator

impl<S, D: DimMut<S>, Rhs> MulAssign<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar>,
    S: MulAssign<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>, 

fn mul_assign(&mut self, rhs: Rhs)

The method for the *= operator

impl<S, D: DimMut<S>, Rhs> MulAssign<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs>,
    S: MulAssign<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>, 

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

The method for the *= operator

impl<S, D: DimMut<S>, Rhs> RemAssign<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar>,
    S: RemAssign<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>, 

fn rem_assign(&mut self, rhs: Rhs)

The method for the %= operator

impl<S, D: DimMut<S>, Rhs> RemAssign<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs>,
    S: RemAssign<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>, 

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

The method for the %= operator

impl<S, D: DimMut<S>, Rhs> SubAssign<Rhs> for Vec<D, S> where
    Rhs: VecArrayVal<Row = D>,
    D: Dim<Rhs::Scalar>,
    S: SubAssign<Rhs::Scalar>,
    D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>, 

fn sub_assign(&mut self, rhs: Rhs)

The method for the -= operator

impl<S, D: DimMut<S>, Rhs> SubAssign<Value<Rhs>> for Vec<D, S> where
    Rhs: Clone,
    <D as Array<Rhs>>::Type: Clone,
    D: Dim<Rhs>,
    S: SubAssign<Rhs>,
    D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>, 

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

The method for the -= operator

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

type Output = Vec<C, S::Output>

The resulting type after applying the * operator

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

The method for the * operator