Struct beagle::index::Vec4Ref

pub struct Vec4Ref<D, S, I0, I1, I2, I3>(_)
 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>;

This is a temporary structure until something is done with rust-lang/rfcs#997 Do not rely on this type, just rely on the overloaded operators defined for the cases where

Methods

impl<D, S: Clone, I0, I1, I2, I3> Vec4Ref<D, S, I0, I1, I2, I3> 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>, 

fn vec(&self) -> Vec<Four, S>

Trait Implementations

impl<D, S, I0, I1, J0, J1, J2, J3> Index<Swizzle2<I0, I1>> for Vec4Ref<D, S, J0, J1, J2, J3> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2> + IsLargerThan<J3>,
    I0: SelectFour<J0, J1, J2, J3>,
    I1: SelectFour<J0, J1, J2, J3>,
    Four: Constant + IsLargerThan<I0> + IsLargerThan<I1>,
    (I0::Selected, I1::Selected): SwizzleIndex,
    J0: IsSmallerThan<D>,
    J1: IsSmallerThan<D>,
    J2: IsSmallerThan<D>,
    J3: IsSmallerThan<D>,
    Vec<D, S>: Index<<(I0::Selected, I1::Selected) as SwizzleIndex>::IndexType>,
    D::Smaller: Array<S>, 

type Output = <Vec<D, S> as Index<<(I0::Selected, I1::Selected) as SwizzleIndex>::IndexType>>::Output

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, J0, J1, J2, J3> IndexMut<Swizzle2<I0, I1>> for Vec4Ref<D, S, J0, J1, J2, J3> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2> + IsLargerThan<J3>,
    I0: SelectFour<J0, J1, J2, J3>,
    I1: SelectFour<J0, J1, J2, J3>,
    Four: Constant + IsLargerThan<I0> + IsLargerThan<I1>,
    (I0::Selected, I1::Selected): SwizzleIndex,
    J0: IsSmallerThan<D>,
    J1: IsSmallerThan<D>,
    J2: IsSmallerThan<D>,
    J3: IsSmallerThan<D>,
    Vec<D, S>: IndexMut<<(I0::Selected, I1::Selected) as SwizzleIndex>::IndexType>,
    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, J0, J1, J2, J3> Index<Swizzle3<I0, I1, I2>> for Vec4Ref<D, S, J0, J1, J2, J3> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2> + IsLargerThan<J3>,
    I0: SelectFour<J0, J1, J2, J3>,
    I1: SelectFour<J0, J1, J2, J3>,
    I2: SelectFour<J0, J1, J2, J3>,
    Four: Constant + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    (I0::Selected, I1::Selected, I2::Selected): SwizzleIndex,
    J0: IsSmallerThan<D>,
    J1: IsSmallerThan<D>,
    J2: IsSmallerThan<D>,
    J3: IsSmallerThan<D>,
    Vec<D, S>: Index<<(I0::Selected, I1::Selected, I2::Selected) as SwizzleIndex>::IndexType>,
    D::Smaller: Array<S>, 

type Output = <Vec<D, S> as Index<<(I0::Selected, I1::Selected, I2::Selected) as SwizzleIndex>::IndexType>>::Output

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, J0, J1, J2, J3> IndexMut<Swizzle3<I0, I1, I2>> for Vec4Ref<D, S, J0, J1, J2, J3> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2> + IsLargerThan<J3>,
    I0: SelectFour<J0, J1, J2, J3>,
    I1: SelectFour<J0, J1, J2, J3>,
    I2: SelectFour<J0, J1, J2, J3>,
    Four: Constant + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    (I0::Selected, I1::Selected, I2::Selected): SwizzleIndex,
    J0: IsSmallerThan<D>,
    J1: IsSmallerThan<D>,
    J2: IsSmallerThan<D>,
    J3: IsSmallerThan<D>,
    Vec<D, S>: IndexMut<<(I0::Selected, I1::Selected, I2::Selected) as SwizzleIndex>::IndexType>,
    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, J0, J1, J2, J3> Index<Swizzle4<I0, I1, I2, I3>> for Vec4Ref<D, S, J0, J1, J2, J3> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2> + IsLargerThan<J3>,
    I0: SelectFour<J0, J1, J2, J3>,
    I1: SelectFour<J0, J1, J2, J3>,
    I2: SelectFour<J0, J1, J2, J3>,
    I3: SelectFour<J0, J1, J2, J3>,
    Four: Constant + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    (I0::Selected, I1::Selected, I2::Selected, I3::Selected): SwizzleIndex,
    J0: IsSmallerThan<D>,
    J1: IsSmallerThan<D>,
    J2: IsSmallerThan<D>,
    J3: IsSmallerThan<D>,
    Vec<D, S>: Index<<(I0::Selected, I1::Selected, I2::Selected, I3::Selected) as SwizzleIndex>::IndexType>,
    D::Smaller: Array<S>, 

type Output = <Vec<D, S> as Index<<(I0::Selected, I1::Selected, I2::Selected, I3::Selected) as SwizzleIndex>::IndexType>>::Output

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, I2, I3, J0, J1, J2, J3> IndexMut<Swizzle4<I0, I1, I2, I3>> for Vec4Ref<D, S, J0, J1, J2, J3> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2> + IsLargerThan<J3>,
    I0: SelectFour<J0, J1, J2, J3>,
    I1: SelectFour<J0, J1, J2, J3>,
    I2: SelectFour<J0, J1, J2, J3>,
    I3: SelectFour<J0, J1, J2, J3>,
    Four: Constant + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    (I0::Selected, I1::Selected, I2::Selected, I3::Selected): SwizzleIndex,
    J0: IsSmallerThan<D>,
    J1: IsSmallerThan<D>,
    J2: IsSmallerThan<D>,
    J3: IsSmallerThan<D>,
    Vec<D, S>: IndexMut<<(I0::Selected, I1::Selected, I2::Selected, I3::Selected) as SwizzleIndex>::IndexType>,
    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, J0, J1, I0, I1, I2, I3> Index<SwizzleExtract<J0, (), (), J1>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    J0: SelectFour<I0, I1, I2, I3> + IsSmallerThan<J1>,
    J1: SelectFour<I0, I1, I2, I3> + IsLargerThan<J0>,
    Four: Constant + IsLargerThan<J0> + IsLargerThan<J1>,
    (J0::Selected, J1::Selected): SwizzleIndex,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    Vec<D, S>: Index<<(J0::Selected, J1::Selected) as SwizzleIndex>::IndexType>,
    D::Smaller: Array<S>, 

type Output = <Vec<D, S> as Index<<(J0::Selected, J1::Selected) as SwizzleIndex>::IndexType>>::Output

The returned type after indexing

fn index(&self, _: SwizzleExtract<J0, (), (), J1>) -> &Self::Output

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

impl<D, S, J0, J1, I0, I1, I2, I3> IndexMut<SwizzleExtract<J0, (), (), J1>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    J0: SelectFour<I0, I1, I2, I3> + IsSmallerThan<J1>,
    J1: SelectFour<I0, I1, I2, I3> + IsLargerThan<J0>,
    Four: Constant + IsLargerThan<J0> + IsLargerThan<J1>,
    (J0::Selected, J1::Selected): SwizzleIndex,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    Vec<D, S>: IndexMut<<(J0::Selected, J1::Selected) as SwizzleIndex>::IndexType>,
    D::Smaller: Array<S>, 

fn index_mut(&mut self, _: SwizzleExtract<J0, (), (), J1>) -> &mut Self::Output

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

impl<D, S, J0, J1, J2, I0, I1, I2, I3> Index<SwizzleExtract<J0, J1, (), J2>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    J0: SelectFour<I0, I1, I2, I3> + IsSmallerThan<J2>,
    J1: SelectFour<I0, I1, I2, I3>,
    J2: SelectFour<I0, I1, I2, I3> + IsLargerThan<J0>,
    Four: Constant + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2>,
    (J0::Selected, J1::Selected, J2::Selected): SwizzleIndex,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    Vec<D, S>: Index<<(J0::Selected, J1::Selected, J2::Selected) as SwizzleIndex>::IndexType>,
    D::Smaller: Array<S>, 

type Output = <Vec<D, S> as Index<<(J0::Selected, J1::Selected, J2::Selected) as SwizzleIndex>::IndexType>>::Output

The returned type after indexing

fn index(&self, _: SwizzleExtract<J0, J1, (), J2>) -> &Self::Output

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

impl<D, S, J0, J1, J2, I0, I1, I2, I3> IndexMut<SwizzleExtract<J0, J1, (), J2>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    J0: SelectFour<I0, I1, I2, I3> + IsSmallerThan<J2>,
    J1: SelectFour<I0, I1, I2, I3>,
    J2: SelectFour<I0, I1, I2, I3> + IsLargerThan<J0>,
    Four: Constant + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2>,
    (J0::Selected, J1::Selected, J2::Selected): SwizzleIndex,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    Vec<D, S>: IndexMut<<(J0::Selected, J1::Selected, J2::Selected) as SwizzleIndex>::IndexType>,
    D::Smaller: Array<S>, 

fn index_mut(&mut self, _: SwizzleExtract<J0, J1, (), J2>) -> &mut Self::Output

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

impl<D, S, J0, J1, J2, J3, I0, I1, I2, I3> Index<SwizzleExtract<J0, J1, J2, J3>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    J0: SelectFour<I0, I1, I2, I3> + IsSmallerThan<J3>,
    J1: SelectFour<I0, I1, I2, I3>,
    J2: SelectFour<I0, I1, I2, I3>,
    J3: SelectFour<I0, I1, I2, I3> + IsLargerThan<J0>,
    Four: Constant + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2> + IsLargerThan<J3>,
    (J0::Selected, J1::Selected, J2::Selected, J3::Selected): SwizzleIndex,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    Vec<D, S>: Index<<(J0::Selected, J1::Selected, J2::Selected, J3::Selected) as SwizzleIndex>::IndexType>,
    D::Smaller: Array<S>, 

type Output = <Vec<D, S> as Index<<(J0::Selected, J1::Selected, J2::Selected, J3::Selected) as SwizzleIndex>::IndexType>>::Output

The returned type after indexing

fn index(&self, _: SwizzleExtract<J0, J1, J2, J3>) -> &Self::Output

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

impl<D, S, J0, J1, J2, J3, I0, I1, I2, I3> IndexMut<SwizzleExtract<J0, J1, J2, J3>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    J0: SelectFour<I0, I1, I2, I3> + IsSmallerThan<J3>,
    J1: SelectFour<I0, I1, I2, I3>,
    J2: SelectFour<I0, I1, I2, I3>,
    J3: SelectFour<I0, I1, I2, I3> + IsLargerThan<J0>,
    Four: Constant + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2> + IsLargerThan<J3>,
    (J0::Selected, J1::Selected, J2::Selected, J3::Selected): SwizzleIndex,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    Vec<D, S>: IndexMut<<(J0::Selected, J1::Selected, J2::Selected, J3::Selected) as SwizzleIndex>::IndexType>,
    D::Smaller: Array<S>, 

fn index_mut(&mut self, _: SwizzleExtract<J0, J1, J2, J3>) -> &mut Self::Output

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

impl<'a, S, D, I0, I1, I2, I3> ScalarArray for &'a Vec4Ref<D, S, I0, I1, I2, I3> 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 Scalar = S

The type of the underlying scalar in the array.

type Row = Four

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<'a, S, D, I0, I1, I2, I3> ScalarArray for &'a mut Vec4Ref<D, S, I0, I1, I2, I3> 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 Scalar = S

The type of the underlying scalar in the array.

type Row = Four

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<'a, S, T, D, D2, I0, I1, I2, I3> HasConcreteScalarArray<T, D2> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    D2: Dim<T>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    D::Smaller: Array<S>,
    D2::Smaller: Array<T>, 

type Concrete = Vec<D2, T>

The type of a concrete ScalarArray of the specified type

impl<'a, S, T, D, D2, I0, I1, I2, I3> HasConcreteScalarArray<T, D2> for &'a mut Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    D2: Dim<T>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    D::Smaller: Array<S>,
    D2::Smaller: Array<T>, 

type Concrete = Vec<D2, T>

The type of a concrete ScalarArray of the specified type

impl<'a, S, T, D, D2, I0, I1, I2, I3> HasConcreteVecArray<T, D2> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    D2: Dim<T>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    D::Smaller: Array<S>,
    D2::Smaller: Array<T>, 

impl<'a, S, T, D, D2, I0, I1, I2, I3> HasConcreteVecArray<T, D2> for &'a mut Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    D2: Dim<T>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    D::Smaller: Array<S>,
    D2::Smaller: Array<T>, 

impl<'a, S, D, I0, I1, I2, I3> ScalarArrayVal for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    S: Clone,
    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>, 

fn get_val(self) -> CustomArrayOne<CustomArrayFour<S>>

Extract the inner array

impl<'a, S, D, I0, I1, I2, I3> ScalarArrayVal for &'a mut Vec4Ref<D, S, I0, I1, I2, I3> where
    S: Clone,
    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>, 

fn get_val(self) -> CustomArrayOne<CustomArrayFour<S>>

Extract the inner array

impl<'a, S, D, I0, I1, I2, I3> VecArrayVal for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    S: Clone,
    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>, 

fn get_vec_val(self) -> CustomArrayFour<S>

Extract the inner array

impl<'a, S, D, I0, I1, I2, I3> VecArrayVal for &'a mut Vec4Ref<D, S, I0, I1, I2, I3> where
    S: Clone,
    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>, 

fn get_vec_val(self) -> CustomArrayFour<S>

Extract the inner array

impl<'a, S, D, I0, I1, I2, I3> ScalarArrayRef for &'a Vec4Ref<D, S, I0, I1, I2, I3> 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>, 

fn get_ref(&self) -> CustomArrayOne<CustomArrayFour<&S>>

Extract the inner array references

impl<'a, S, D, I0, I1, I2, I3> ScalarArrayRef for &'a mut Vec4Ref<D, S, I0, I1, I2, I3> 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>, 

fn get_ref(&self) -> CustomArrayOne<CustomArrayFour<&S>>

Extract the inner array references

impl<'a, S, D, I0, I1, I2, I3> VecArrayRef for &'a Vec4Ref<D, S, I0, I1, I2, I3> 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>, 

fn get_vec_ref(&self) -> CustomArrayFour<&S>

Extract the inner array references

impl<'a, S, D, I0, I1, I2, I3> VecArrayRef for &'a mut Vec4Ref<D, S, I0, I1, I2, I3> 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>, 

fn get_vec_ref(&self) -> CustomArrayFour<&S>

Extract the inner array references

impl<'a, S, D, I0, I1, I2, I3> Neg for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Neg + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the - operator

fn neg(self) -> Self::Output

The method for the unary - operator

impl<'a, S, D, I0, I1, I2, I3> Not for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Not + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the ! operator

fn not(self) -> Self::Output

The method for the unary ! operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> BitAnd<Rhs> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: BitAnd<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the & operator

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

The method for the & operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> BitAnd<Value<Rhs>> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: BitAnd<Rhs> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the & operator

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

The method for the & operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> BitOr<Rhs> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: BitOr<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the | operator

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

The method for the | operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> BitOr<Value<Rhs>> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: BitOr<Rhs> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the | operator

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

The method for the | operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> BitXor<Rhs> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: BitXor<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the ^ operator

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

The method for the ^ operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> BitXor<Value<Rhs>> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: BitXor<Rhs> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the ^ operator

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

The method for the ^ operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Shl<Rhs> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Shl<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the << operator

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

The method for the << operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Shl<Value<Rhs>> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Shl<Rhs> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the << operator

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

The method for the << operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Shr<Rhs> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Shr<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the >> operator

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

The method for the >> operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Shr<Value<Rhs>> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Shr<Rhs> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the >> operator

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

The method for the >> operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Add<Rhs> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Add<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the + operator

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

The method for the + operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Add<Value<Rhs>> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Add<Rhs> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the + operator

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

The method for the + operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Div<Rhs> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Div<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the / operator

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

The method for the / operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Div<Value<Rhs>> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Div<Rhs> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the / operator

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

The method for the / operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Mul<Rhs> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Mul<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Mul<Value<Rhs>> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Mul<Rhs> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the * operator

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

The method for the * operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Rem<Rhs> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Rem<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the % operator

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

The method for the % operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Rem<Value<Rhs>> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Rem<Rhs> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the % operator

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

The method for the % operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Sub<Rhs> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Sub<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

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

The resulting type after applying the - operator

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

The method for the - operator

impl<'a, S, D, Rhs, I0, I1, I2, I3> Sub<Value<Rhs>> for &'a Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    S: Sub<Rhs> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Four, 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, Rhs, I0, I1, I2, I3> BitAndAssign<Rhs> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: BitAndAssign<Rhs::Scalar>,
    D::Smaller: Array<S>, 

fn bitand_assign(&mut self, rhs: Rhs)

The method for the &= operator

impl<S, D, Rhs, I0, I1, I2, I3> BitAndAssign<Value<Rhs>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: BitAndAssign<Rhs>,
    D::Smaller: Array<S>, 

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

The method for the &= operator

impl<S, D, Rhs, I0, I1, I2, I3> BitOrAssign<Rhs> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: BitOrAssign<Rhs::Scalar>,
    D::Smaller: Array<S>, 

fn bitor_assign(&mut self, rhs: Rhs)

The method for the |= operator

impl<S, D, Rhs, I0, I1, I2, I3> BitOrAssign<Value<Rhs>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: BitOrAssign<Rhs>,
    D::Smaller: Array<S>, 

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

The method for the |= operator

impl<S, D, Rhs, I0, I1, I2, I3> BitXorAssign<Rhs> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: BitXorAssign<Rhs::Scalar>,
    D::Smaller: Array<S>, 

fn bitxor_assign(&mut self, rhs: Rhs)

The method for the ^= operator

impl<S, D, Rhs, I0, I1, I2, I3> BitXorAssign<Value<Rhs>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: BitXorAssign<Rhs>,
    D::Smaller: Array<S>, 

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

The method for the ^= operator

impl<S, D, Rhs, I0, I1, I2, I3> ShlAssign<Rhs> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: ShlAssign<Rhs::Scalar>,
    D::Smaller: Array<S>, 

fn shl_assign(&mut self, rhs: Rhs)

The method for the <<= operator

impl<S, D, Rhs, I0, I1, I2, I3> ShlAssign<Value<Rhs>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: ShlAssign<Rhs>,
    D::Smaller: Array<S>, 

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

The method for the <<= operator

impl<S, D, Rhs, I0, I1, I2, I3> ShrAssign<Rhs> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: ShrAssign<Rhs::Scalar>,
    D::Smaller: Array<S>, 

fn shr_assign(&mut self, rhs: Rhs)

The method for the >>= operator

impl<S, D, Rhs, I0, I1, I2, I3> ShrAssign<Value<Rhs>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: ShrAssign<Rhs>,
    D::Smaller: Array<S>, 

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

The method for the >>= operator

impl<S, D, Rhs, I0, I1, I2, I3> AddAssign<Rhs> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: AddAssign<Rhs::Scalar>,
    D::Smaller: Array<S>, 

fn add_assign(&mut self, rhs: Rhs)

The method for the += operator

impl<S, D, Rhs, I0, I1, I2, I3> AddAssign<Value<Rhs>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: AddAssign<Rhs>,
    D::Smaller: Array<S>, 

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

The method for the += operator

impl<S, D, Rhs, I0, I1, I2, I3> DivAssign<Rhs> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: DivAssign<Rhs::Scalar>,
    D::Smaller: Array<S>, 

fn div_assign(&mut self, rhs: Rhs)

The method for the /= operator

impl<S, D, Rhs, I0, I1, I2, I3> DivAssign<Value<Rhs>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: DivAssign<Rhs>,
    D::Smaller: Array<S>, 

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

The method for the /= operator

impl<S, D, Rhs, I0, I1, I2, I3> MulAssign<Rhs> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: MulAssign<Rhs::Scalar>,
    D::Smaller: Array<S>, 

fn mul_assign(&mut self, rhs: Rhs)

The method for the *= operator

impl<S, D, Rhs, I0, I1, I2, I3> MulAssign<Value<Rhs>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: MulAssign<Rhs>,
    D::Smaller: Array<S>, 

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

The method for the *= operator

impl<S, D, Rhs, I0, I1, I2, I3> RemAssign<Rhs> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: RemAssign<Rhs::Scalar>,
    D::Smaller: Array<S>, 

fn rem_assign(&mut self, rhs: Rhs)

The method for the %= operator

impl<S, D, Rhs, I0, I1, I2, I3> RemAssign<Value<Rhs>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: RemAssign<Rhs>,
    D::Smaller: Array<S>, 

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

The method for the %= operator

impl<S, D, Rhs, I0, I1, I2, I3> SubAssign<Rhs> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: VecArrayVal<Row = Four>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: SubAssign<Rhs::Scalar>,
    D::Smaller: Array<S>, 

fn sub_assign(&mut self, rhs: Rhs)

The method for the -= operator

impl<S, D, Rhs, I0, I1, I2, I3> SubAssign<Value<Rhs>> for Vec4Ref<D, S, I0, I1, I2, I3> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    I3: IsSmallerThan<D>,
    &'a mut Vec4Ref<D, S, I0, I1, I2, I3>: ScalarArrayMut<Dim = One, Row = Four, Scalar = S>,
    S: SubAssign<Rhs>,
    D::Smaller: Array<S>, 

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

The method for the -= operator

impl<'a, S, D, I0, I1, I2, I3> ScalarArrayMut for &'a mut Vec4Ref<D, S, I0, I1, I2, I3> where
    D: DimMut<S> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3> + ExtractItem<I0>,
    D::Smaller: DimMut<S> + ExtractItem<I1::Result>,
    <D::Smaller as HasSmaller>::Smaller: DimMut<S> + ExtractItem<<I2::Result as DecrementIfLargerThan<I1::Result>>::Result>,
    <<D::Smaller as HasSmaller>::Smaller as HasSmaller>::Smaller: DimMut<S> + ExtractItem<<<I3::Result as DecrementIfLargerThan<I1::Result>>::Result as DecrementIfLargerThan<<I2::Result as DecrementIfLargerThan<I1::Result>>::Result>>::Result>,
    I0: IsSmallerThan<D> + NotSame<I1> + NotSame<I2> + NotSame<I3>,
    I1: IsSmallerThan<D> + NotSame<I0> + NotSame<I2> + NotSame<I3> + DecrementIfLargerThan<I0>,
    I2: IsSmallerThan<D> + NotSame<I0> + NotSame<I1> + NotSame<I3> + DecrementIfLargerThan<I0>,
    I3: IsSmallerThan<D> + NotSame<I0> + NotSame<I1> + NotSame<I2> + DecrementIfLargerThan<I0>,
    I1::Result: IsSmallerThan<D::Smaller> + NotSame<I2::Result> + NotSame<I3::Result>,
    I2::Result: DecrementIfLargerThan<I1::Result> + NotSame<I1::Result>,
    I3::Result: DecrementIfLargerThan<I1::Result> + NotSame<I1::Result>,
    <I2::Result as DecrementIfLargerThan<I1::Result>>::Result: IsSmallerThan<<D::Smaller as HasSmaller>::Smaller> + NotSame<<I3::Result as DecrementIfLargerThan<I1::Result>>::Result>,
    <I3::Result as DecrementIfLargerThan<I1::Result>>::Result: DecrementIfLargerThan<<I2::Result as DecrementIfLargerThan<I1::Result>>::Result> + NotSame<<I2::Result as DecrementIfLargerThan<I1::Result>>::Result>,
    <<I3::Result as DecrementIfLargerThan<I1::Result>>::Result as DecrementIfLargerThan<<I2::Result as DecrementIfLargerThan<I1::Result>>::Result>>::Result: IsSmallerThan<<<D::Smaller as HasSmaller>::Smaller as HasSmaller>::Smaller>,
    <<<D::Smaller as HasSmaller>::Smaller as HasSmaller>::Smaller as HasSmaller>::Smaller: ArrayMut<S>, 

fn get_mut(&mut self) -> CustomArrayOne<CustomArrayFour<&mut S>>

Extract the inner array mutable references