Struct beagle::index::Vec2Ref

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

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

Trait Implementations

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

type Scalar = S

The type of the underlying scalar in the array.

type Row = Two

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

type Scalar = S

The type of the underlying scalar in the array.

type Row = Two

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

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

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

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

Extract the inner array

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

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

Extract the inner array

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

fn get_vec_val(self) -> CustomArrayTwo<S>

Extract the inner array

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

fn get_vec_val(self) -> CustomArrayTwo<S>

Extract the inner array

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

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

Extract the inner array references

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

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

Extract the inner array references

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

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

Extract the inner array references

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

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

Extract the inner array references

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Extract the inner array mutable references