Trait nom::lib::std::ops::DivAssign1.8.0[−][src]

pub trait DivAssign<Rhs = Self> {
    pub fn div_assign(&mut self, rhs: Rhs);
}
[−]

The division assignment operator /=.

Examples

use std::ops::DivAssign;

#[derive(Debug, PartialEq)]
struct Frequency { hertz: f64 }

impl DivAssign<f64> for Frequency {
    fn div_assign(&mut self, rhs: f64) {
        self.hertz /= rhs;
    }
}

let mut frequency = Frequency { hertz: 200.0 };
frequency /= 4.0;
assert_eq!(Frequency { hertz: 50.0 }, frequency);

Required methods

pub fn div_assign(&mut self, rhs: Rhs)[src][−]

Performs the /= operation.

Example

let mut x: u32 = 12;
x /= 2;
assert_eq!(x, 6);

Implementations on Foreign Types

impl DivAssign<u128> for u128[src]

impl<'_> DivAssign<&'_ Wrapping<i128>> for Wrapping<i128>[src]

impl DivAssign<Wrapping<u8>> for Wrapping<u8>[src]

impl DivAssign<i8> for i8[src]

impl<'_> DivAssign<&'_ i128> for i128[src]

impl DivAssign<i32> for i32[src]

impl DivAssign<isize> for isize[src]

impl DivAssign<f32> for f32[src]

impl DivAssign<Wrapping<i32>> for Wrapping<i32>[src]

impl DivAssign<Wrapping<u64>> for Wrapping<u64>[src]

impl DivAssign<Wrapping<isize>> for Wrapping<isize>[src]

impl DivAssign<Wrapping<i128>> for Wrapping<i128>[src]

impl DivAssign<Wrapping<i8>> for Wrapping<i8>[src]

impl DivAssign<u16> for u16[src]

impl DivAssign<i128> for i128[src]

impl<'_> DivAssign<&'_ Wrapping<u16>> for Wrapping<u16>[src]

impl<'_> DivAssign<&'_ Wrapping<u8>> for Wrapping<u8>[src]

impl DivAssign<usize> for usize[src]

impl<'_> DivAssign<&'_ Wrapping<u64>> for Wrapping<u64>[src]

impl DivAssign<Wrapping<i16>> for Wrapping<i16>[src]

impl DivAssign<Wrapping<i64>> for Wrapping<i64>[src]

impl DivAssign<Wrapping<u32>> for Wrapping<u32>[src]

impl DivAssign<u32> for u32[src]

impl DivAssign<u32> for Duration[src]

impl<'_> DivAssign<&'_ Wrapping<usize>> for Wrapping<usize>[src]

impl<'_> DivAssign<&'_ Wrapping<u32>> for Wrapping<u32>[src]

impl<'_> DivAssign<&'_ f32> for f32[src]

impl<'_> DivAssign<&'_ i32> for i32[src]

impl<'_> DivAssign<&'_ Wrapping<i8>> for Wrapping<i8>[src]

impl<'_> DivAssign<&'_ i8> for i8[src]

impl<'_> DivAssign<&'_ i64> for i64[src]

impl DivAssign<i64> for i64[src]

impl<'_> DivAssign<&'_ u128> for u128[src]

impl<'_> DivAssign<&'_ usize> for usize[src]

impl<'_> DivAssign<&'_ Wrapping<i32>> for Wrapping<i32>[src]

impl DivAssign<Wrapping<u16>> for Wrapping<u16>[src]

impl<'_> DivAssign<&'_ Wrapping<isize>> for Wrapping<isize>[src]

impl<'_> DivAssign<&'_ isize> for isize[src]

impl<'_> DivAssign<&'_ u8> for u8[src]

impl DivAssign<Wrapping<usize>> for Wrapping<usize>[src]

impl DivAssign<i16> for i16[src]

impl<'_> DivAssign<&'_ Wrapping<i16>> for Wrapping<i16>[src]

impl DivAssign<u8> for u8[src]

impl<'_> DivAssign<&'_ Wrapping<u128>> for Wrapping<u128>[src]

impl<'_> DivAssign<&'_ Wrapping<i64>> for Wrapping<i64>[src]

impl<'_> DivAssign<&'_ u16> for u16[src]

impl<'_> DivAssign<&'_ u64> for u64[src]

impl DivAssign<f64> for f64[src]

impl<'_> DivAssign<&'_ u32> for u32[src]

impl<'_> DivAssign<&'_ f64> for f64[src]

impl DivAssign<u64> for u64[src]

impl DivAssign<Wrapping<u128>> for Wrapping<u128>[src]

impl<'_> DivAssign<&'_ i16> for i16[src]

Implementors

impl<N: DivAssign<N>> DivAssign<Deg<N>> for Deg<N>

impl<N: DivAssign<N>> DivAssign<Rad<N>> for Rad<N>

impl<N: DivAssign<N>> DivAssign<N> for Deg<N>

impl<N: DivAssign<N>> DivAssign<N> for Rad<N>

impl<T> DivAssign<Dual<T>> for Dual<T> where
    T: Sub<Output = T> + Mul<Output = T> + Div<Output = T> + Copy, 

impl<T> DivAssign<T> for Dual<T> where
    T: Mul<Output = T> + Div<Output = T> + Copy, 

impl<N: SimdRealField> DivAssign<N> for DualQuaternion<N> where
    N::Element: SimdRealField, 

impl DivAssign<u32> for FloatDuration

impl DivAssign<f64> for FloatDuration

impl<N, R: Dim, C: Dim, S> DivAssign<N> for Matrix<N, R, C, S> where
    N: Scalar + ClosedDiv,
    S: StorageMut<N, R, C>, 

impl<N: Scalar + ClosedDiv, D: DimName> DivAssign<N> for Point<N, D> where
    DefaultAllocator: Allocator<N, D>, 

impl<N, D: DimName> DivAssign<Rotation<N, D>> for Rotation<N, D> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, D, D>, 

impl<'b, N, D: DimName> DivAssign<&'b Rotation<N, D>> for Rotation<N, D> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, D, D>, 

impl<N, R1: DimName, C1: DimName> DivAssign<Rotation<N, C1>> for MatrixMN<N, R1, C1> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>, 

impl<'b, N, R1: DimName, C1: DimName> DivAssign<&'b Rotation<N, C1>> for MatrixMN<N, R1, C1> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    DefaultAllocator: Allocator<N, R1, C1> + Allocator<N, C1, C1>, 

impl<N: SimdRealField> DivAssign<N> for Quaternion<N> where
    N::Element: SimdRealField, 

impl<'b, N: SimdRealField> DivAssign<&'b Unit<Quaternion<N>>> for UnitQuaternion<N> where
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U4, U1>, 

impl<N: SimdRealField> DivAssign<Unit<Quaternion<N>>> for UnitQuaternion<N> where
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U4, U1>, 

impl<'b, N: SimdRealField> DivAssign<&'b Rotation<N, U3>> for UnitQuaternion<N> where
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>, 

impl<N: SimdRealField> DivAssign<Rotation<N, U3>> for UnitQuaternion<N> where
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U4, U1> + Allocator<N, U3, U3>, 

impl<N: SimdRealField> DivAssign<Unit<Complex<N>>> for UnitComplex<N> where
    N::Element: SimdRealField, 

impl<'b, N: SimdRealField> DivAssign<&'b Unit<Complex<N>>> for UnitComplex<N> where
    N::Element: SimdRealField, 

impl<N: SimdRealField> DivAssign<Rotation<N, U2>> for UnitComplex<N> where
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U2, U2>, 

impl<'b, N: SimdRealField> DivAssign<&'b Rotation<N, U2>> for UnitComplex<N> where
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U2, U2>, 

impl<N: SimdRealField> DivAssign<Unit<Complex<N>>> for Rotation<N, U2> where
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U2, U2>, 

impl<'b, N: SimdRealField> DivAssign<&'b Unit<Complex<N>>> for Rotation<N, U2> where
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U2, U2>, 

impl<'b, N, D: DimName> DivAssign<&'b Translation<N, D>> for Translation<N, D> where
    N: Scalar + ClosedSub,
    DefaultAllocator: Allocator<N, D, U1>,
    ShapeConstraint: SameNumberOfRows<D, D> + SameNumberOfColumns<U1, U1>, 

impl<N, D: DimName> DivAssign<Translation<N, D>> for Translation<N, D> where
    N: Scalar + ClosedSub,
    DefaultAllocator: Allocator<N, D, U1>,
    ShapeConstraint: SameNumberOfRows<D, D> + SameNumberOfColumns<U1, U1>, 

impl<N: SimdRealField, D: DimName, R> DivAssign<Isometry<N, D, R>> for Isometry<N, D, R> where
    N::Element: SimdRealField,
    R: AbstractRotation<N, D>,
    DefaultAllocator: Allocator<N, D>, 

impl<'b, N: SimdRealField, D: DimName, R> DivAssign<&'b Isometry<N, D, R>> for Isometry<N, D, R> where
    N::Element: SimdRealField,
    R: AbstractRotation<N, D>,
    DefaultAllocator: Allocator<N, D>, 

impl<N, D: DimName> DivAssign<Rotation<N, D>> for Isometry<N, D, Rotation<N, D>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1> + Allocator<N, D, D>, 

impl<'b, N, D: DimName> DivAssign<&'b Rotation<N, D>> for Isometry<N, D, Rotation<N, D>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1> + Allocator<N, D, D>, 

impl<N> DivAssign<Unit<Quaternion<N>>> for Isometry<N, U3, UnitQuaternion<N>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U3, U3>, 

impl<'b, N> DivAssign<&'b Unit<Quaternion<N>>> for Isometry<N, U3, UnitQuaternion<N>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U3, U3>, 

impl<N> DivAssign<Unit<Complex<N>>> for Isometry<N, U2, UnitComplex<N>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U2, U2>, 

impl<'b, N> DivAssign<&'b Unit<Complex<N>>> for Isometry<N, U2, UnitComplex<N>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U2, U2>, 

impl<N: SimdRealField, D: DimName, R> DivAssign<Similarity<N, D, R>> for Similarity<N, D, R> where
    N::Element: SimdRealField,
    R: AbstractRotation<N, D>,
    DefaultAllocator: Allocator<N, D>, 

impl<'b, N: SimdRealField, D: DimName, R> DivAssign<&'b Similarity<N, D, R>> for Similarity<N, D, R> where
    N::Element: SimdRealField,
    R: AbstractRotation<N, D>,
    DefaultAllocator: Allocator<N, D>, 

impl<N: SimdRealField, D: DimName, R> DivAssign<Isometry<N, D, R>> for Similarity<N, D, R> where
    N::Element: SimdRealField,
    R: AbstractRotation<N, D>,
    DefaultAllocator: Allocator<N, D>, 

impl<'b, N: SimdRealField, D: DimName, R> DivAssign<&'b Isometry<N, D, R>> for Similarity<N, D, R> where
    N::Element: SimdRealField,
    R: AbstractRotation<N, D>,
    DefaultAllocator: Allocator<N, D>, 

impl<N, D: DimName> DivAssign<Rotation<N, D>> for Similarity<N, D, Rotation<N, D>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1> + Allocator<N, D, D>, 

impl<'b, N, D: DimName> DivAssign<&'b Rotation<N, D>> for Similarity<N, D, Rotation<N, D>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, D, U1> + Allocator<N, D, D>, 

impl<N> DivAssign<Unit<Quaternion<N>>> for Similarity<N, U3, UnitQuaternion<N>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U3, U3>, 

impl<'b, N> DivAssign<&'b Unit<Quaternion<N>>> for Similarity<N, U3, UnitQuaternion<N>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U3, U3>, 

impl<N> DivAssign<Unit<Complex<N>>> for Similarity<N, U2, UnitComplex<N>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U2, U2>, 

impl<'b, N> DivAssign<&'b Unit<Complex<N>>> for Similarity<N, U2, UnitComplex<N>> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField,
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U2, U2>, 

impl<N, D: DimNameAdd<U1>, CA: SuperTCategoryOf<CB>, CB: SubTCategoryOf<TProjective>> DivAssign<Transform<N, D, CB>> for Transform<N, D, CA> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

impl<'b, N, D: DimNameAdd<U1>, CA: SuperTCategoryOf<CB>, CB: SubTCategoryOf<TProjective>> DivAssign<&'b Transform<N, D, CB>> for Transform<N, D, CA> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>>, 

impl<N, D: DimNameAdd<U1>, C: TCategory> DivAssign<Translation<N, D>> for Transform<N, D, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1>, 

impl<'b, N, D: DimNameAdd<U1>, C: TCategory> DivAssign<&'b Translation<N, D>> for Transform<N, D, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, U1>, 

impl<N, D: DimNameAdd<U1>, C: TCategory> DivAssign<Rotation<N, D>> for Transform<N, D, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, D>, 

impl<'b, N, D: DimNameAdd<U1>, C: TCategory> DivAssign<&'b Rotation<N, D>> for Transform<N, D, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, DimNameSum<D, U1>, DimNameSum<D, U1>> + Allocator<N, D, D>, 

impl<N, C: TCategory> DivAssign<Unit<Quaternion<N>>> for Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

impl<'b, N, C: TCategory> DivAssign<&'b Unit<Quaternion<N>>> for Transform<N, U3, C> where
    N: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField,
    DefaultAllocator: Allocator<N, U4, U4> + Allocator<N, U4, U1>, 

impl<T: Clone + NumAssign> DivAssign<Complex<T>> for Complex<T>

impl<T: Clone + NumAssign> DivAssign<T> for Complex<T>

impl<'a, T: Clone + NumAssign> DivAssign<&'a Complex<T>> for Complex<T>

impl<'a, T: Clone + NumAssign> DivAssign<&'a T> for Complex<T>

impl<T: Clone + Integer + NumAssign> DivAssign<Ratio<T>> for Ratio<T>

impl<T: Clone + Integer + NumAssign> DivAssign<T> for Ratio<T>

impl<'a, T: Clone + Integer + NumAssign> DivAssign<&'a Ratio<T>> for Ratio<T>

impl<'a, T: Clone + Integer + NumAssign> DivAssign<&'a T> for Ratio<T>

impl<Rhs> DivAssign<Rhs> for U128 where
    Rhs: Into<U128>, 

impl<'a> DivAssign<&'a U128> for U128

impl<Rhs> DivAssign<Rhs> for U160 where
    Rhs: Into<U160>, 

impl<'a> DivAssign<&'a U160> for U160

impl<Rhs> DivAssign<Rhs> for U224 where
    Rhs: Into<U224>, 

impl<'a> DivAssign<&'a U224> for U224

impl<Rhs> DivAssign<Rhs> for U256 where
    Rhs: Into<U256>, 

impl<'a> DivAssign<&'a U256> for U256

impl<Rhs> DivAssign<Rhs> for U384 where
    Rhs: Into<U384>, 

impl<'a> DivAssign<&'a U384> for U384

impl<Rhs> DivAssign<Rhs> for U512 where
    Rhs: Into<U512>, 

impl<'a> DivAssign<&'a U512> for U512

impl<Rhs> DivAssign<Rhs> for U520 where
    Rhs: Into<U520>, 

impl<'a> DivAssign<&'a U520> for U520

impl<Rhs> DivAssign<Rhs> for U1024 where
    Rhs: Into<U1024>, 

impl<'a> DivAssign<&'a U1024> for U1024

impl<Rhs> DivAssign<Rhs> for U2048 where
    Rhs: Into<U2048>, 

impl<'a> DivAssign<&'a U2048> for U2048

impl<Rhs> DivAssign<Rhs> for U4096 where
    Rhs: Into<U4096>, 

impl<'a> DivAssign<&'a U4096> for U4096

impl DivAssign<AutoSimd<[f32; 2]>> for AutoSimd<[f32; 2]>

impl DivAssign<AutoSimd<[f32; 4]>> for AutoSimd<[f32; 4]>

impl DivAssign<AutoSimd<[f32; 8]>> for AutoSimd<[f32; 8]>

impl DivAssign<AutoSimd<[f32; 16]>> for AutoSimd<[f32; 16]>

impl DivAssign<AutoSimd<[f64; 2]>> for AutoSimd<[f64; 2]>

impl DivAssign<AutoSimd<[f64; 4]>> for AutoSimd<[f64; 4]>

impl DivAssign<AutoSimd<[f64; 8]>> for AutoSimd<[f64; 8]>

impl DivAssign<AutoSimd<[i128; 1]>> for AutoSimd<[i128; 1]>

impl DivAssign<AutoSimd<[i128; 2]>> for AutoSimd<[i128; 2]>

impl DivAssign<AutoSimd<[i128; 4]>> for AutoSimd<[i128; 4]>

impl DivAssign<AutoSimd<[i16; 2]>> for AutoSimd<[i16; 2]>

impl DivAssign<AutoSimd<[i16; 4]>> for AutoSimd<[i16; 4]>

impl DivAssign<AutoSimd<[i16; 8]>> for AutoSimd<[i16; 8]>

impl DivAssign<AutoSimd<[i16; 16]>> for AutoSimd<[i16; 16]>

impl DivAssign<AutoSimd<[i16; 32]>> for AutoSimd<[i16; 32]>

impl DivAssign<AutoSimd<[i32; 2]>> for AutoSimd<[i32; 2]>

impl DivAssign<AutoSimd<[i32; 4]>> for AutoSimd<[i32; 4]>

impl DivAssign<AutoSimd<[i32; 8]>> for AutoSimd<[i32; 8]>

impl DivAssign<AutoSimd<[i32; 16]>> for AutoSimd<[i32; 16]>

impl DivAssign<AutoSimd<[i64; 2]>> for AutoSimd<[i64; 2]>

impl DivAssign<AutoSimd<[i64; 4]>> for AutoSimd<[i64; 4]>

impl DivAssign<AutoSimd<[i64; 8]>> for AutoSimd<[i64; 8]>

impl DivAssign<AutoSimd<[i8; 2]>> for AutoSimd<[i8; 2]>

impl DivAssign<AutoSimd<[i8; 4]>> for AutoSimd<[i8; 4]>

impl DivAssign<AutoSimd<[i8; 8]>> for AutoSimd<[i8; 8]>

impl DivAssign<AutoSimd<[i8; 16]>> for AutoSimd<[i8; 16]>

impl DivAssign<AutoSimd<[i8; 32]>> for AutoSimd<[i8; 32]>

impl DivAssign<AutoSimd<[isize; 2]>> for AutoSimd<[isize; 2]>

impl DivAssign<AutoSimd<[isize; 4]>> for AutoSimd<[isize; 4]>

impl DivAssign<AutoSimd<[isize; 8]>> for AutoSimd<[isize; 8]>

impl DivAssign<AutoSimd<[u128; 1]>> for AutoSimd<[u128; 1]>

impl DivAssign<AutoSimd<[u128; 2]>> for AutoSimd<[u128; 2]>

impl DivAssign<AutoSimd<[u128; 4]>> for AutoSimd<[u128; 4]>

impl DivAssign<AutoSimd<[u16; 2]>> for AutoSimd<[u16; 2]>

impl DivAssign<AutoSimd<[u16; 4]>> for AutoSimd<[u16; 4]>

impl DivAssign<AutoSimd<[u16; 8]>> for AutoSimd<[u16; 8]>

impl DivAssign<AutoSimd<[u16; 16]>> for AutoSimd<[u16; 16]>

impl DivAssign<AutoSimd<[u16; 32]>> for AutoSimd<[u16; 32]>

impl DivAssign<AutoSimd<[u32; 2]>> for AutoSimd<[u32; 2]>

impl DivAssign<AutoSimd<[u32; 4]>> for AutoSimd<[u32; 4]>

impl DivAssign<AutoSimd<[u32; 8]>> for AutoSimd<[u32; 8]>

impl DivAssign<AutoSimd<[u32; 16]>> for AutoSimd<[u32; 16]>

impl DivAssign<AutoSimd<[u64; 2]>> for AutoSimd<[u64; 2]>

impl DivAssign<AutoSimd<[u64; 4]>> for AutoSimd<[u64; 4]>

impl DivAssign<AutoSimd<[u64; 8]>> for AutoSimd<[u64; 8]>

impl DivAssign<AutoSimd<[u8; 2]>> for AutoSimd<[u8; 2]>

impl DivAssign<AutoSimd<[u8; 4]>> for AutoSimd<[u8; 4]>

impl DivAssign<AutoSimd<[u8; 8]>> for AutoSimd<[u8; 8]>

impl DivAssign<AutoSimd<[u8; 16]>> for AutoSimd<[u8; 16]>

impl DivAssign<AutoSimd<[u8; 32]>> for AutoSimd<[u8; 32]>

impl DivAssign<AutoSimd<[usize; 2]>> for AutoSimd<[usize; 2]>

impl DivAssign<AutoSimd<[usize; 4]>> for AutoSimd<[usize; 4]>

impl DivAssign<AutoSimd<[usize; 8]>> for AutoSimd<[usize; 8]>