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

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

The multiplication assignment operator *=.

Examples

use std::ops::MulAssign;

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

impl MulAssign<f64> for Frequency {
    fn mul_assign(&mut self, rhs: f64) {
        self.hertz *= rhs;
    }
}

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

Required methods

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

Performs the *= operation.

Example

let mut x: u32 = 12;
x *= 2;
assert_eq!(x, 24);

Implementations on Foreign Types

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

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

impl MulAssign<f64> for f64[src]

impl MulAssign<i8> for i8[src]

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

impl MulAssign<i32> for i32[src]

impl MulAssign<u128> for u128[src]

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

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

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

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

impl MulAssign<u16> for u16[src]

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

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

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

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

impl MulAssign<isize> for isize[src]

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

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

impl MulAssign<u64> for u64[src]

impl MulAssign<i128> for i128[src]

impl MulAssign<u32> for Duration[src]

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

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

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

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

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

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

impl MulAssign<u8> for u8[src]

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

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

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

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

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

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

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

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

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

impl MulAssign<f32> for f32[src]

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

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

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

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

impl MulAssign<i16> for i16[src]

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

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

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

impl MulAssign<usize> for usize[src]

impl MulAssign<i64> for i64[src]

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

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

impl MulAssign<u32> for u32[src]

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

Implementors

impl<N: MulAssign<N>> MulAssign<Deg<N>> for Deg<N>

impl<N: MulAssign<N>> MulAssign<Rad<N>> for Rad<N>

impl<N: MulAssign<N>> MulAssign<N> for Deg<N>

impl<N: MulAssign<N>> MulAssign<N> for Rad<N>

impl<T> MulAssign<Dual<T>> for Dual<T> where
    T: Add<Output = T> + Mul<Output = T> + Copy, 

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

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

impl MulAssign<u32> for FloatDuration

impl MulAssign<f64> for FloatDuration

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

impl<N, R1, C1, R2, SA, SB> MulAssign<Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA> where
    R1: Dim,
    C1: Dim,
    R2: Dim,
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    SB: Storage<N, R2, C1>,
    SA: ContiguousStorageMut<N, R1, C1> + Clone,
    ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
    DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>, 

impl<'b, N, R1, C1, R2, SA, SB> MulAssign<&'b Matrix<N, R2, C1, SB>> for Matrix<N, R1, C1, SA> where
    R1: Dim,
    C1: Dim,
    R2: Dim,
    N: Scalar + Zero + One + ClosedAdd + ClosedMul,
    SB: Storage<N, R2, C1>,
    SA: ContiguousStorageMut<N, R1, C1> + Clone,
    ShapeConstraint: AreMultipliable<R1, C1, R2, C1>,
    DefaultAllocator: Allocator<N, R1, C1, Buffer = SA>, 

impl<N: Scalar + ClosedMul, D: DimName> MulAssign<N> for Point<N, D> where
    DefaultAllocator: Allocator<N, D>, 

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

impl<'b, N, D: DimName> MulAssign<&'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> MulAssign<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> MulAssign<&'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> MulAssign<N> for Quaternion<N> where
    N::Element: SimdRealField, 

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

impl<N: SimdRealField> MulAssign<Quaternion<N>> for Quaternion<N> where
    N::Element: SimdRealField,
    DefaultAllocator: Allocator<N, U4, U1>, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<N: SimdRealField, D: DimName, R> MulAssign<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> MulAssign<&'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> MulAssign<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> MulAssign<&'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> MulAssign<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> MulAssign<&'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> MulAssign<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> MulAssign<&'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> MulAssign<Translation<N, D>> for Similarity<N, D, R> where
    N::Element: SimdRealField,
    R: AbstractRotation<N, D>,
    DefaultAllocator: Allocator<N, D>, 

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

impl<N: SimdRealField, D: DimName, R> MulAssign<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> MulAssign<&'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> MulAssign<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> MulAssign<&'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> MulAssign<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> MulAssign<&'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> MulAssign<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> MulAssign<&'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> MulAssign<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> MulAssign<&'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: TCategory, CB: SubTCategoryOf<CA>> MulAssign<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: TCategory, CB: SubTCategoryOf<CA>> MulAssign<&'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, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> MulAssign<Similarity<N, D, R>> 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, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> MulAssign<&'b Similarity<N, D, R>> 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, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> MulAssign<Isometry<N, D, R>> 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, R: SubsetOf<MatrixN<N, DimNameSum<D, U1>>>> MulAssign<&'b Isometry<N, D, R>> 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> MulAssign<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> MulAssign<&'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> MulAssign<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> MulAssign<&'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> MulAssign<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> MulAssign<&'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> MulAssign<Complex<T>> for Complex<T>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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