Struct beagle::vec::Vec
[−]
[src]
pub struct Vec<D, S>(_)
where
D: Dim<S>,
D::Smaller: Array<S>;
An array of Scalars, written Vec<D, V>
but pronounced 'vector'.
Vectors support binary operations between two Vectors or between one Vector and one Scalar. All Arithmetic operators and Bitwise operators are supported, where the two Scalar types involved support the operation. All operations operate on each component separately.
Vectors also support Negation and Logical Negation where the underlying Scalar Type supports it.
Methods
impl<S, D: Dim<S>> Vec<D, S> where
D::Smaller: Array<S>,
[src]
D::Smaller: Array<S>,
fn new(v: D::RawType) -> Self where
D::RawType: Into<D::Type>,
D::RawType: Into<D::Type>,
Construct a vector from an array
fn from_value(s: S) -> Self where
S: Clone,
S: Clone,
Construct a Vector from a single value
Trait Implementations
impl<D, S, I0, I1> Index<Swizzle2<I0, I1>> for Vec<D, S> where
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1>,
I0: IsSmallerThan<D>,
I1: IsSmallerThan<D>,
D::Smaller: Array<S>,
[src]
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1>,
I0: IsSmallerThan<D>,
I1: IsSmallerThan<D>,
D::Smaller: Array<S>,
type Output = Vec2Ref<D, S, I0, I1>
The returned type after indexing
fn index(&self, _: Swizzle2<I0, I1>) -> &Self::Output
The method for the indexing (container[index]
) operation
impl<D, S, I0, I1, I2> Index<Swizzle3<I0, I1, I2>> for Vec<D, S> where
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
I0: IsSmallerThan<D>,
I1: IsSmallerThan<D>,
I2: IsSmallerThan<D>,
D::Smaller: Array<S>,
[src]
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
I0: IsSmallerThan<D>,
I1: IsSmallerThan<D>,
I2: IsSmallerThan<D>,
D::Smaller: Array<S>,
type Output = Vec3Ref<D, S, I0, I1, I2>
The returned type after indexing
fn index(&self, _: Swizzle3<I0, I1, I2>) -> &Self::Output
The method for the indexing (container[index]
) operation
impl<D, S, I0, I1, I2, I3> Index<Swizzle4<I0, I1, I2, I3>> for Vec<D, S> where
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
I0: IsSmallerThan<D>,
I1: IsSmallerThan<D>,
I2: IsSmallerThan<D>,
I3: IsSmallerThan<D>,
D::Smaller: Array<S>,
[src]
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
I0: IsSmallerThan<D>,
I1: IsSmallerThan<D>,
I2: IsSmallerThan<D>,
I3: IsSmallerThan<D>,
D::Smaller: Array<S>,
type Output = Vec4Ref<D, S, I0, I1, I2, I3>
The returned type after indexing
fn index(&self, _: Swizzle4<I0, I1, I2, I3>) -> &Self::Output
The method for the indexing (container[index]
) operation
impl<D, S, I0, I1> IndexMut<Swizzle2<I0, I1>> for Vec<D, S> where
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1>,
I0: IsSmallerThan<D> + NotSame<I1>,
I1: IsSmallerThan<D> + NotSame<I0>,
D::Smaller: Array<S>,
[src]
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1>,
I0: IsSmallerThan<D> + NotSame<I1>,
I1: IsSmallerThan<D> + NotSame<I0>,
D::Smaller: Array<S>,
fn index_mut(&mut self, _: Swizzle2<I0, I1>) -> &mut Self::Output
The method for the mutable indexing (container[index]
) operation
impl<D, S, I0, I1, I2> IndexMut<Swizzle3<I0, I1, I2>> for Vec<D, S> where
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
I0: IsSmallerThan<D> + NotSame<I1> + NotSame<I2>,
I1: IsSmallerThan<D> + NotSame<I0> + NotSame<I2>,
I2: IsSmallerThan<D> + NotSame<I0> + NotSame<I1>,
D::Smaller: Array<S>,
[src]
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2>,
I0: IsSmallerThan<D> + NotSame<I1> + NotSame<I2>,
I1: IsSmallerThan<D> + NotSame<I0> + NotSame<I2>,
I2: IsSmallerThan<D> + NotSame<I0> + NotSame<I1>,
D::Smaller: Array<S>,
fn index_mut(&mut self, _: Swizzle3<I0, I1, I2>) -> &mut Self::Output
The method for the mutable indexing (container[index]
) operation
impl<D, S, I0, I1, I2, I3> IndexMut<Swizzle4<I0, I1, I2, I3>> for Vec<D, S> where
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
I0: IsSmallerThan<D> + NotSame<I1> + NotSame<I2> + NotSame<I3>,
I1: IsSmallerThan<D> + NotSame<I0> + NotSame<I2> + NotSame<I3>,
I2: IsSmallerThan<D> + NotSame<I0> + NotSame<I1> + NotSame<I3>,
I3: IsSmallerThan<D> + NotSame<I0> + NotSame<I1> + NotSame<I2>,
D::Smaller: Array<S>,
[src]
D: Dim<S> + IsLargerThan<I0> + IsLargerThan<I1> + IsLargerThan<I2> + IsLargerThan<I3>,
I0: IsSmallerThan<D> + NotSame<I1> + NotSame<I2> + NotSame<I3>,
I1: IsSmallerThan<D> + NotSame<I0> + NotSame<I2> + NotSame<I3>,
I2: IsSmallerThan<D> + NotSame<I0> + NotSame<I1> + NotSame<I3>,
I3: IsSmallerThan<D> + NotSame<I0> + NotSame<I1> + NotSame<I2>,
D::Smaller: Array<S>,
fn index_mut(&mut self, _: Swizzle4<I0, I1, I2, I3>) -> &mut Self::Output
The method for the mutable indexing (container[index]
) operation
impl<D, S, I0, I1, I2, I3> Index<SwizzleExtract<I0, I1, I2, I3>> for Vec<D, S> where
D: Dim<S> + ExtractArray<I0, I3>,
I0: IsSmallerThan<D> + IsSmallerThan<I3>,
I3: IsSmallerThan<D> + IsLargerThan<I0>,
D::Extracted: Dim<S>,
D::Smaller: Array<S>,
<D::Extracted as HasSmaller>::Smaller: Array<S>,
[src]
D: Dim<S> + ExtractArray<I0, I3>,
I0: IsSmallerThan<D> + IsSmallerThan<I3>,
I3: IsSmallerThan<D> + IsLargerThan<I0>,
D::Extracted: Dim<S>,
D::Smaller: Array<S>,
<D::Extracted as HasSmaller>::Smaller: Array<S>,
type Output = Vec<D::Extracted, S>
The returned type after indexing
fn index(&self, _: SwizzleExtract<I0, I1, I2, I3>) -> &Self::Output
The method for the indexing (container[index]
) operation
impl<D, S, I0, I1, I2, I3> IndexMut<SwizzleExtract<I0, I1, I2, I3>> for Vec<D, S> where
D: Dim<S> + ExtractArray<I0, I3>,
I0: IsSmallerThan<D> + IsSmallerThan<I3>,
I3: IsSmallerThan<D> + IsLargerThan<I0>,
D::Extracted: Dim<S>,
D::Smaller: Array<S>,
<D::Extracted as HasSmaller>::Smaller: Array<S>,
[src]
D: Dim<S> + ExtractArray<I0, I3>,
I0: IsSmallerThan<D> + IsSmallerThan<I3>,
I3: IsSmallerThan<D> + IsLargerThan<I0>,
D::Extracted: Dim<S>,
D::Smaller: Array<S>,
<D::Extracted as HasSmaller>::Smaller: Array<S>,
fn index_mut(&mut self, _: SwizzleExtract<I0, I1, I2, I3>) -> &mut Self::Output
The method for the mutable indexing (container[index]
) operation
impl<D: Clone, S: Clone> Clone for Vec<D, S> where
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: Clone,
[src]
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: Clone,
fn clone(&self) -> Vec<D, S>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl<D: Copy, S: Copy> Copy for Vec<D, S> where
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: Copy,
[src]
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: Copy,
impl<D: Debug, S: Debug> Debug for Vec<D, S> where
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: Debug,
[src]
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: Debug,
impl<D: Default, S: Default> Default for Vec<D, S> where
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: Default,
[src]
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: Default,
impl<D: PartialEq, S: PartialEq> PartialEq for Vec<D, S> where
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: PartialEq,
[src]
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: PartialEq,
fn eq(&self, __arg_0: &Vec<D, S>) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &Vec<D, S>) -> bool
This method tests for !=
.
impl<D: Eq, S: Eq> Eq for Vec<D, S> where
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: Eq,
[src]
D: Dim<S>,
D::Smaller: Array<S>,
D::Type: Eq,
impl<S, D: Dim<S>> Deref for Vec<D, S> where
D::Type: Deref<Target = D::RawType>,
D::Smaller: Array<S>,
[src]
D::Type: Deref<Target = D::RawType>,
D::Smaller: Array<S>,
type Target = D::RawType
The resulting type after dereferencing
fn deref(&self) -> &D::RawType
The method called to dereference a value
impl<S, D: Dim<S>> DerefMut for Vec<D, S> where
D::Type: DerefMut<Target = D::RawType>,
D::Smaller: Array<S>,
[src]
D::Type: DerefMut<Target = D::RawType>,
D::Smaller: Array<S>,
impl<S, D: Dim<S>> Index<usize> for Vec<D, S> where
D::Type: AsRef<[S]>,
D::Smaller: Array<S>,
[src]
D::Type: AsRef<[S]>,
D::Smaller: Array<S>,
type Output = S
The returned type after indexing
fn index(&self, rhs: usize) -> &S
The method for the indexing (container[index]
) operation
impl<S, D: Dim<S>> IndexMut<usize> for Vec<D, S> where
D::Type: AsRef<[S]> + AsMut<[S]>,
D::Smaller: Array<S>,
[src]
D::Type: AsRef<[S]> + AsMut<[S]>,
D::Smaller: Array<S>,
fn index_mut(&mut self, rhs: usize) -> &mut S
The method for the mutable indexing (container[index]
) operation
impl<S, D: Dim<S>> ScalarArray for Vec<D, S> where
D::Smaller: Array<S>,
[src]
D::Smaller: Array<S>,
type Scalar = S
The type of the underlying scalar in the array.
type Row = D
The type of a single element of this type (a single row for matrices/a scalar for vectors).
type Dim = One
The dimension of the scalar array.
impl<S, D: Dim<S>> ScalarArrayVal for Vec<D, S> where
D::Smaller: Array<S>,
[src]
D::Smaller: Array<S>,
fn get_val(self) -> CustomArrayOne<D::Type>
Extract the inner array
impl<S, D: DimRef<S>> ScalarArrayRef for Vec<D, S> where
D::Smaller: Array<S> + Array<&'a S>,
[src]
D::Smaller: Array<S> + Array<&'a S>,
fn get_ref(&self) -> <One as Array<<D as Array<&S>>::Type>>::Type
Extract the inner array references
impl<S, D: DimMut<S>> ScalarArrayMut for Vec<D, S> where
D::Smaller: Array<S> + Array<&'a S> + Array<&'a mut S>,
[src]
D::Smaller: Array<S> + Array<&'a S> + Array<&'a mut S>,
fn get_mut(&mut self) -> <One as Array<<D as Array<&mut S>>::Type>>::Type
Extract the inner array mutable references
impl<S, D: Dim<S>> VecArrayVal for Vec<D, S> where
D::Smaller: Array<S>,
[src]
D::Smaller: Array<S>,
fn get_vec_val(self) -> D::Type
Extract the inner array
impl<S, D: DimRef<S>> VecArrayRef for Vec<D, S> where
D::Smaller: Array<S> + Array<&'a S>,
[src]
D::Smaller: Array<S> + Array<&'a S>,
fn get_vec_ref(&self) -> <D as Array<&S>>::Type
Extract the inner array references
impl<S, T, D: Dim<S>, D2: Dim<T>> HasConcreteScalarArray<T, D2> for Vec<D, S> where
D::Smaller: Array<S>,
D2::Smaller: Array<T>,
[src]
D::Smaller: Array<S>,
D2::Smaller: Array<T>,
impl<S, D: Dim<S>> ConcreteScalarArray for Vec<D, S> where
D::Smaller: Array<S>,
[src]
D::Smaller: Array<S>,
impl<S, T, D: Dim<S>, D2: Dim<T>> HasConcreteVecArray<T, D2> for Vec<D, S> where
D::Smaller: Array<S>,
D2::Smaller: Array<T>,
[src]
D::Smaller: Array<S>,
D2::Smaller: Array<T>,
impl<S, D: Dim<S>> ConcreteVecArray for Vec<D, S> where
D::Smaller: Array<S>,
[src]
D::Smaller: Array<S>,
fn from_vec_val(v: D::Type) -> Self
Create from an array
impl<S, D: Dim<S>> Neg for Vec<D, S> where
D: Dim<S::Output>,
S: Neg,
D::Smaller: Array<S> + Array<S::Output>,
[src]
D: Dim<S::Output>,
S: Neg,
D::Smaller: Array<S> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the -
operator
fn neg(self) -> Self::Output
The method for the unary -
operator
impl<S, D: Dim<S>> Not for Vec<D, S> where
D: Dim<S::Output>,
S: Not,
D::Smaller: Array<S> + Array<S::Output>,
[src]
D: Dim<S::Output>,
S: Not,
D::Smaller: Array<S> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the !
operator
fn not(self) -> Self::Output
The method for the unary !
operator
impl<S, D: Dim<S>, Rhs> BitAnd<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: BitAnd<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: BitAnd<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the &
operator
fn bitand(self, rhs: Rhs) -> Self::Output
The method for the &
operator
impl<S, D: Dim<S>, Rhs> BitAnd<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: BitAnd<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: BitAnd<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the &
operator
fn bitand(self, rhs: Value<Rhs>) -> Self::Output
The method for the &
operator
impl<S, D: Dim<S>, Rhs> BitOr<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: BitOr<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: BitOr<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the |
operator
fn bitor(self, rhs: Rhs) -> Self::Output
The method for the |
operator
impl<S, D: Dim<S>, Rhs> BitOr<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: BitOr<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: BitOr<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the |
operator
fn bitor(self, rhs: Value<Rhs>) -> Self::Output
The method for the |
operator
impl<S, D: Dim<S>, Rhs> BitXor<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: BitXor<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: BitXor<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the ^
operator
fn bitxor(self, rhs: Rhs) -> Self::Output
The method for the ^
operator
impl<S, D: Dim<S>, Rhs> BitXor<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: BitXor<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: BitXor<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the ^
operator
fn bitxor(self, rhs: Value<Rhs>) -> Self::Output
The method for the ^
operator
impl<S, D: Dim<S>, Rhs> Shl<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Shl<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Shl<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the <<
operator
fn shl(self, rhs: Rhs) -> Self::Output
The method for the <<
operator
impl<S, D: Dim<S>, Rhs> Shl<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Shl<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Shl<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the <<
operator
fn shl(self, rhs: Value<Rhs>) -> Self::Output
The method for the <<
operator
impl<S, D: Dim<S>, Rhs> Shr<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Shr<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Shr<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the >>
operator
fn shr(self, rhs: Rhs) -> Self::Output
The method for the >>
operator
impl<S, D: Dim<S>, Rhs> Shr<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Shr<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Shr<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the >>
operator
fn shr(self, rhs: Value<Rhs>) -> Self::Output
The method for the >>
operator
impl<S, D: Dim<S>, Rhs> Add<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Add<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Add<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the +
operator
fn add(self, rhs: Rhs) -> Self::Output
The method for the +
operator
impl<S, D: Dim<S>, Rhs> Add<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Add<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Add<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the +
operator
fn add(self, rhs: Value<Rhs>) -> Self::Output
The method for the +
operator
impl<S, D: Dim<S>, Rhs> Div<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Div<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Div<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the /
operator
fn div(self, rhs: Rhs) -> Self::Output
The method for the /
operator
impl<S, D: Dim<S>, Rhs> Div<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Div<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Div<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the /
operator
fn div(self, rhs: Value<Rhs>) -> Self::Output
The method for the /
operator
impl<S, D: Dim<S>, Rhs> Mul<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Mul<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Mul<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the *
operator
fn mul(self, rhs: Rhs) -> Self::Output
The method for the *
operator
impl<S, D: Dim<S>, Rhs> Mul<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Mul<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Mul<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the *
operator
fn mul(self, rhs: Value<Rhs>) -> Self::Output
The method for the *
operator
impl<S, D: Dim<S>, Rhs> Rem<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Rem<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Rem<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the %
operator
fn rem(self, rhs: Rhs) -> Self::Output
The method for the %
operator
impl<S, D: Dim<S>, Rhs> Rem<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Rem<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Rem<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the %
operator
fn rem(self, rhs: Value<Rhs>) -> Self::Output
The method for the %
operator
impl<S, D: Dim<S>, Rhs> Sub<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Sub<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar> + Dim<S::Output>,
S: Sub<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the -
operator
fn sub(self, rhs: Rhs) -> Self::Output
The method for the -
operator
impl<S, D: Dim<S>, Rhs> Sub<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Sub<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs> + Dim<S::Output>,
S: Sub<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<S::Output>,
type Output = Vec<D, S::Output>
The resulting type after applying the -
operator
fn sub(self, rhs: Value<Rhs>) -> Self::Output
The method for the -
operator
impl<S, D: DimMut<S>, Rhs> BitAndAssign<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: BitAndAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: BitAndAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
fn bitand_assign(&mut self, rhs: Rhs)
The method for the &=
operator
impl<S, D: DimMut<S>, Rhs> BitAndAssign<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: BitAndAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: BitAndAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
fn bitand_assign(&mut self, rhs: Value<Rhs>)
The method for the &=
operator
impl<S, D: DimMut<S>, Rhs> BitOrAssign<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: BitOrAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: BitOrAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
fn bitor_assign(&mut self, rhs: Rhs)
The method for the |=
operator
impl<S, D: DimMut<S>, Rhs> BitOrAssign<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: BitOrAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: BitOrAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
fn bitor_assign(&mut self, rhs: Value<Rhs>)
The method for the |=
operator
impl<S, D: DimMut<S>, Rhs> BitXorAssign<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: BitXorAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: BitXorAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
fn bitxor_assign(&mut self, rhs: Rhs)
The method for the ^=
operator
impl<S, D: DimMut<S>, Rhs> BitXorAssign<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: BitXorAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: BitXorAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
fn bitxor_assign(&mut self, rhs: Value<Rhs>)
The method for the ^=
operator
impl<S, D: DimMut<S>, Rhs> ShlAssign<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: ShlAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: ShlAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
fn shl_assign(&mut self, rhs: Rhs)
The method for the <<=
operator
impl<S, D: DimMut<S>, Rhs> ShlAssign<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: ShlAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: ShlAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
fn shl_assign(&mut self, rhs: Value<Rhs>)
The method for the <<=
operator
impl<S, D: DimMut<S>, Rhs> ShrAssign<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: ShrAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: ShrAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
fn shr_assign(&mut self, rhs: Rhs)
The method for the >>=
operator
impl<S, D: DimMut<S>, Rhs> ShrAssign<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: ShrAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: ShrAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
fn shr_assign(&mut self, rhs: Value<Rhs>)
The method for the >>=
operator
impl<S, D: DimMut<S>, Rhs> AddAssign<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: AddAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: AddAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
fn add_assign(&mut self, rhs: Rhs)
The method for the +=
operator
impl<S, D: DimMut<S>, Rhs> AddAssign<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: AddAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: AddAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
fn add_assign(&mut self, rhs: Value<Rhs>)
The method for the +=
operator
impl<S, D: DimMut<S>, Rhs> DivAssign<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: DivAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: DivAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
fn div_assign(&mut self, rhs: Rhs)
The method for the /=
operator
impl<S, D: DimMut<S>, Rhs> DivAssign<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: DivAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: DivAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
fn div_assign(&mut self, rhs: Value<Rhs>)
The method for the /=
operator
impl<S, D: DimMut<S>, Rhs> MulAssign<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: MulAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: MulAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
fn mul_assign(&mut self, rhs: Rhs)
The method for the *=
operator
impl<S, D: DimMut<S>, Rhs> MulAssign<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: MulAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: MulAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
fn mul_assign(&mut self, rhs: Value<Rhs>)
The method for the *=
operator
impl<S, D: DimMut<S>, Rhs> RemAssign<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: RemAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: RemAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
fn rem_assign(&mut self, rhs: Rhs)
The method for the %=
operator
impl<S, D: DimMut<S>, Rhs> RemAssign<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: RemAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: RemAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
fn rem_assign(&mut self, rhs: Value<Rhs>)
The method for the %=
operator
impl<S, D: DimMut<S>, Rhs> SubAssign<Rhs> for Vec<D, S> where
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: SubAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: VecArrayVal<Row = D>,
D: Dim<Rhs::Scalar>,
S: SubAssign<Rhs::Scalar>,
D::Smaller: Array<S> + Array<Rhs::Scalar> + Array<&'a S> + Array<&'a mut S>,
fn sub_assign(&mut self, rhs: Rhs)
The method for the -=
operator
impl<S, D: DimMut<S>, Rhs> SubAssign<Value<Rhs>> for Vec<D, S> where
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: SubAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
[src]
Rhs: Clone,
<D as Array<Rhs>>::Type: Clone,
D: Dim<Rhs>,
S: SubAssign<Rhs>,
D::Smaller: Array<S> + Array<Rhs> + Array<&'a S> + Array<&'a mut S>,
fn sub_assign(&mut self, rhs: Value<Rhs>)
The method for the -=
operator
impl<S, T, C, D> Mul<Mat<D, C, T>> for Vec<D, S> where
C: Dim<T> + Dim<S> + Dim<S::Output>,
D: Dim<S> + TwoDim<S, C> + TwoDim<T, C>,
S: Clone,
S: Mul<T>,
S::Output: Add<Output = S::Output>,
C::Smaller: Array<S> + Array<T> + Array<S::Output>,
D::Smaller: Array<S> + Array<<C as Array<S>>::Type> + Array<<C as Array<T>>::Type>,
[src]
C: Dim<T> + Dim<S> + Dim<S::Output>,
D: Dim<S> + TwoDim<S, C> + TwoDim<T, C>,
S: Clone,
S: Mul<T>,
S::Output: Add<Output = S::Output>,
C::Smaller: Array<S> + Array<T> + Array<S::Output>,
D::Smaller: Array<S> + Array<<C as Array<S>>::Type> + Array<<C as Array<T>>::Type>,