Struct beagle::index::Vec3Ref

pub struct Vec3Ref<D, S, I0, I1, I2>(_)
 where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: 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> Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

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

Trait Implementations

impl<D, S, I0, I1, J0, J1, J2> Index<Swizzle2<I0, I1>> for Vec3Ref<D, S, J0, J1, J2> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2>,
    I0: SelectThree<J0, J1, J2>,
    I1: SelectThree<J0, J1, J2>,
    Three: Constant + IsLargerThan<I0> + IsLargerThan<I1>,
    (I0::Selected, I1::Selected): SwizzleIndex,
    J0: IsSmallerThan<D>,
    J1: IsSmallerThan<D>,
    J2: 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> IndexMut<Swizzle2<I0, I1>> for Vec3Ref<D, S, J0, J1, J2> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2>,
    I0: SelectThree<J0, J1, J2>,
    I1: SelectThree<J0, J1, J2>,
    Three: Constant + IsLargerThan<I0> + IsLargerThan<I1>,
    (I0::Selected, I1::Selected): SwizzleIndex,
    J0: IsSmallerThan<D>,
    J1: IsSmallerThan<D>,
    J2: 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> Index<Swizzle3<I0, I1, I2>> for Vec3Ref<D, S, J0, J1, J2> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2>,
    I0: SelectThree<J0, J1, J2>,
    I1: SelectThree<J0, J1, J2>,
    I2: SelectThree<J0, J1, J2>,
    Three: Constant + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    (I0::Selected, I1::Selected, I2::Selected): SwizzleIndex,
    J0: IsSmallerThan<D>,
    J1: IsSmallerThan<D>,
    J2: 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> IndexMut<Swizzle3<I0, I1, I2>> for Vec3Ref<D, S, J0, J1, J2> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2>,
    I0: SelectThree<J0, J1, J2>,
    I1: SelectThree<J0, J1, J2>,
    I2: SelectThree<J0, J1, J2>,
    Three: Constant + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    (I0::Selected, I1::Selected, I2::Selected): SwizzleIndex,
    J0: IsSmallerThan<D>,
    J1: IsSmallerThan<D>,
    J2: 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> Index<Swizzle4<I0, I1, I2, I3>> for Vec3Ref<D, S, J0, J1, J2> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2>,
    I0: SelectThree<J0, J1, J2>,
    I1: SelectThree<J0, J1, J2>,
    I2: SelectThree<J0, J1, J2>,
    I3: SelectThree<J0, J1, J2>,
    Three: 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>,
    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> IndexMut<Swizzle4<I0, I1, I2, I3>> for Vec3Ref<D, S, J0, J1, J2> where
    D: Dim<S> + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2>,
    I0: SelectThree<J0, J1, J2>,
    I1: SelectThree<J0, J1, J2>,
    I2: SelectThree<J0, J1, J2>,
    I3: SelectThree<J0, J1, J2>,
    Three: 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>,
    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> Index<SwizzleExtract<J0, (), (), J1>> for Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    J0: SelectThree<I0, I1, I2> + IsSmallerThan<J1>,
    J1: SelectThree<I0, I1, I2> + IsLargerThan<J0>,
    Three: Constant + IsLargerThan<J0> + IsLargerThan<J1>,
    (J0::Selected, J1::Selected): SwizzleIndex,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: 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> IndexMut<SwizzleExtract<J0, (), (), J1>> for Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    J0: SelectThree<I0, I1, I2> + IsSmallerThan<J1>,
    J1: SelectThree<I0, I1, I2> + IsLargerThan<J0>,
    Three: Constant + IsLargerThan<J0> + IsLargerThan<J1>,
    (J0::Selected, J1::Selected): SwizzleIndex,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: 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> Index<SwizzleExtract<J0, J1, (), J2>> for Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    J0: SelectThree<I0, I1, I2> + IsSmallerThan<J2>,
    J1: SelectThree<I0, I1, I2>,
    J2: SelectThree<I0, I1, I2> + IsLargerThan<J0>,
    Three: Constant + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2>,
    (J0::Selected, J1::Selected, J2::Selected): SwizzleIndex,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: 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> IndexMut<SwizzleExtract<J0, J1, (), J2>> for Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    J0: SelectThree<I0, I1, I2> + IsSmallerThan<J2>,
    J1: SelectThree<I0, I1, I2>,
    J2: SelectThree<I0, I1, I2> + IsLargerThan<J0>,
    Three: Constant + IsLargerThan<J0> + IsLargerThan<J1> + IsLargerThan<J2>,
    (J0::Selected, J1::Selected, J2::Selected): SwizzleIndex,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: 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> Index<SwizzleExtract<J0, J1, J2, J3>> for Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    J0: SelectThree<I0, I1, I2> + IsSmallerThan<J3>,
    J1: SelectThree<I0, I1, I2>,
    J2: SelectThree<I0, I1, I2>,
    J3: SelectThree<I0, I1, I2> + IsLargerThan<J0>,
    Three: 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>,
    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> IndexMut<SwizzleExtract<J0, J1, J2, J3>> for Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    J0: SelectThree<I0, I1, I2> + IsSmallerThan<J3>,
    J1: SelectThree<I0, I1, I2>,
    J2: SelectThree<I0, I1, I2>,
    J3: SelectThree<I0, I1, I2> + IsLargerThan<J0>,
    Three: 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>,
    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> ScalarArray for &'a Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

type Scalar = S

The type of the underlying scalar in the array.

type Row = Three

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> ScalarArray for &'a mut Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

type Scalar = S

The type of the underlying scalar in the array.

type Row = Three

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

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

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

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

Extract the inner array

impl<'a, S, D, I0, I1, I2> ScalarArrayVal for &'a mut Vec3Ref<D, S, I0, I1, I2> where
    S: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

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

Extract the inner array

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

fn get_vec_val(self) -> CustomArrayThree<S>

Extract the inner array

impl<'a, S, D, I0, I1, I2> VecArrayVal for &'a mut Vec3Ref<D, S, I0, I1, I2> where
    S: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

fn get_vec_val(self) -> CustomArrayThree<S>

Extract the inner array

impl<'a, S, D, I0, I1, I2> ScalarArrayRef for &'a Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

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

Extract the inner array references

impl<'a, S, D, I0, I1, I2> ScalarArrayRef for &'a mut Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

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

Extract the inner array references

impl<'a, S, D, I0, I1, I2> VecArrayRef for &'a Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

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

Extract the inner array references

impl<'a, S, D, I0, I1, I2> VecArrayRef for &'a mut Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    D::Smaller: Array<S>, 

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

Extract the inner array references

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

type Output = Vec<Three, 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> Not for &'a Vec3Ref<D, S, I0, I1, I2> where
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Not + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> BitAnd<Rhs> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: BitAnd<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> BitAnd<Value<Rhs>> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: BitAnd<Rhs> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> BitOr<Rhs> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: BitOr<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> BitOr<Value<Rhs>> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: BitOr<Rhs> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> BitXor<Rhs> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: BitXor<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> BitXor<Value<Rhs>> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: BitXor<Rhs> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Shl<Rhs> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Shl<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Shl<Value<Rhs>> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Shl<Rhs> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Shr<Rhs> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Shr<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Shr<Value<Rhs>> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Shr<Rhs> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Add<Rhs> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Add<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Add<Value<Rhs>> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Add<Rhs> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Div<Rhs> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Div<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Div<Value<Rhs>> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Div<Rhs> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Mul<Rhs> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Mul<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Mul<Value<Rhs>> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Mul<Rhs> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Rem<Rhs> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Rem<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Rem<Value<Rhs>> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Rem<Rhs> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Sub<Rhs> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Sub<Rhs::Scalar> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> Sub<Value<Rhs>> for &'a Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    S: Sub<Rhs> + Clone,
    D::Smaller: Array<S>, 

type Output = Vec<Three, 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> BitAndAssign<Rhs> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> BitAndAssign<Value<Rhs>> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> BitOrAssign<Rhs> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> BitOrAssign<Value<Rhs>> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> BitXorAssign<Rhs> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> BitXorAssign<Value<Rhs>> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> ShlAssign<Rhs> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> ShlAssign<Value<Rhs>> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> ShrAssign<Rhs> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> ShrAssign<Value<Rhs>> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> AddAssign<Rhs> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> AddAssign<Value<Rhs>> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> DivAssign<Rhs> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> DivAssign<Value<Rhs>> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> MulAssign<Rhs> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> MulAssign<Value<Rhs>> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> RemAssign<Rhs> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> RemAssign<Value<Rhs>> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> SubAssign<Rhs> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: VecArrayVal<Row = Three>,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> SubAssign<Value<Rhs>> for Vec3Ref<D, S, I0, I1, I2> where
    Rhs: Clone,
    D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
    I0: IsSmallerThan<D>,
    I1: IsSmallerThan<D>,
    I2: IsSmallerThan<D>,
    &'a mut Vec3Ref<D, S, I0, I1, I2>: ScalarArrayMut<Dim = One, Row = Three, 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> ScalarArrayMut for &'a mut Vec3Ref<D, S, I0, I1, I2> where
    D: DimMut<S> + IsLargerThan<I1> + IsLargerThan<I2> + ExtractItem<I0>,
    D::Smaller: DimMut<S> + ExtractItem<I1::Result>,
    <D::Smaller as HasSmaller>::Smaller: DimMut<S> + ExtractItem<<I2::Result as DecrementIfLargerThan<I1::Result>>::Result>,
    I0: IsSmallerThan<D> + NotSame<I1> + NotSame<I2>,
    I1: IsSmallerThan<D> + NotSame<I0> + NotSame<I2> + DecrementIfLargerThan<I0>,
    I2: IsSmallerThan<D> + NotSame<I0> + NotSame<I1> + DecrementIfLargerThan<I0>,
    I1::Result: IsSmallerThan<D::Smaller> + NotSame<I2::Result>,
    I2::Result: DecrementIfLargerThan<I1::Result> + NotSame<I1::Result>,
    <I2::Result as DecrementIfLargerThan<I1::Result>>::Result: IsSmallerThan<<D::Smaller as HasSmaller>::Smaller>,
    <<D::Smaller as HasSmaller>::Smaller as HasSmaller>::Smaller: ArrayMut<S>, 

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

Extract the inner array mutable references