Trait DivAssign

pub trait DivAssign<Rhs = Self> {
    // Required method
    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

fn div_assign(&mut self, rhs: Rhs)

Performs the /= operation.

Example

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

Implementors

impl DivAssign for f16

impl DivAssign for f32

impl DivAssign for f64

impl DivAssign for f128

impl DivAssign for i8

impl DivAssign for i16

impl DivAssign for i32

impl DivAssign for i64

impl DivAssign for i128

impl DivAssign for isize

impl DivAssign for u8

impl DivAssign for u16

impl DivAssign for u32

impl DivAssign for u64

impl DivAssign for u128

impl DivAssign for usize

impl DivAssign for Saturating<i8>

impl DivAssign for Saturating<i16>

impl DivAssign for Saturating<i32>

impl DivAssign for Saturating<i64>

impl DivAssign for Saturating<i128>

impl DivAssign for Saturating<isize>

impl DivAssign for Saturating<u8>

impl DivAssign for Saturating<u16>

impl DivAssign for Saturating<u32>

impl DivAssign for Saturating<u64>

impl DivAssign for Saturating<u128>

impl DivAssign for Saturating<usize>

impl DivAssign for Wrapping<i8>

impl DivAssign for Wrapping<i16>

impl DivAssign for Wrapping<i32>

impl DivAssign for Wrapping<i64>

impl DivAssign for Wrapping<i128>

impl DivAssign for Wrapping<isize>

impl DivAssign for Wrapping<u8>

impl DivAssign for Wrapping<u16>

impl DivAssign for Wrapping<u32>

impl DivAssign for Wrapping<u64>

impl DivAssign for Wrapping<u128>

impl DivAssign for Wrapping<usize>

impl DivAssign<&f16> for f16

impl DivAssign<&f32> for f32

impl DivAssign<&f64> for f64

impl DivAssign<&f128> for f128

impl DivAssign<&i8> for i8

impl DivAssign<&i8> for Saturating<i8>

impl DivAssign<&i8> for Wrapping<i8>

impl DivAssign<&i16> for i16

impl DivAssign<&i16> for Saturating<i16>

impl DivAssign<&i16> for Wrapping<i16>

impl DivAssign<&i32> for i32

impl DivAssign<&i32> for Saturating<i32>

impl DivAssign<&i32> for Wrapping<i32>

impl DivAssign<&i64> for i64

impl DivAssign<&i64> for Saturating<i64>

impl DivAssign<&i64> for Wrapping<i64>

impl DivAssign<&i128> for i128

impl DivAssign<&i128> for Saturating<i128>

impl DivAssign<&i128> for Wrapping<i128>

impl DivAssign<&isize> for isize

impl DivAssign<&isize> for Saturating<isize>

impl DivAssign<&isize> for Wrapping<isize>

impl DivAssign<&u8> for u8

impl DivAssign<&u8> for Saturating<u8>

impl DivAssign<&u8> for Wrapping<u8>

impl DivAssign<&u16> for u16

impl DivAssign<&u16> for Saturating<u16>

impl DivAssign<&u16> for Wrapping<u16>

impl DivAssign<&u32> for u32

impl DivAssign<&u32> for Saturating<u32>

impl DivAssign<&u32> for Wrapping<u32>

impl DivAssign<&u64> for u64

impl DivAssign<&u64> for Saturating<u64>

impl DivAssign<&u64> for Wrapping<u64>

impl DivAssign<&u128> for u128

impl DivAssign<&u128> for Saturating<u128>

impl DivAssign<&u128> for Wrapping<u128>

impl DivAssign<&usize> for usize

impl DivAssign<&usize> for Saturating<usize>

impl DivAssign<&usize> for Wrapping<usize>

impl DivAssign<&Saturating<i8>> for Saturating<i8>

impl DivAssign<&Saturating<i16>> for Saturating<i16>

impl DivAssign<&Saturating<i32>> for Saturating<i32>

impl DivAssign<&Saturating<i64>> for Saturating<i64>

impl DivAssign<&Saturating<i128>> for Saturating<i128>

impl DivAssign<&Saturating<isize>> for Saturating<isize>

impl DivAssign<&Saturating<u8>> for Saturating<u8>

impl DivAssign<&Saturating<u16>> for Saturating<u16>

impl DivAssign<&Saturating<u32>> for Saturating<u32>

impl DivAssign<&Saturating<u64>> for Saturating<u64>

impl DivAssign<&Saturating<u128>> for Saturating<u128>

impl DivAssign<&Saturating<usize>> for Saturating<usize>

impl DivAssign<&Wrapping<i8>> for Wrapping<i8>

impl DivAssign<&Wrapping<i16>> for Wrapping<i16>

impl DivAssign<&Wrapping<i32>> for Wrapping<i32>

impl DivAssign<&Wrapping<i64>> for Wrapping<i64>

impl DivAssign<&Wrapping<i128>> for Wrapping<i128>

impl DivAssign<&Wrapping<isize>> for Wrapping<isize>

impl DivAssign<&Wrapping<u8>> for Wrapping<u8>

impl DivAssign<&Wrapping<u16>> for Wrapping<u16>

impl DivAssign<&Wrapping<u32>> for Wrapping<u32>

impl DivAssign<&Wrapping<u64>> for Wrapping<u64>

impl DivAssign<&Wrapping<u128>> for Wrapping<u128>

impl DivAssign<&Wrapping<usize>> for Wrapping<usize>

impl DivAssign<i8> for Saturating<i8>

impl DivAssign<i8> for Wrapping<i8>

impl DivAssign<i16> for Saturating<i16>

impl DivAssign<i16> for Wrapping<i16>

impl DivAssign<i32> for Saturating<i32>

impl DivAssign<i32> for Wrapping<i32>

impl DivAssign<i64> for Saturating<i64>

impl DivAssign<i64> for Wrapping<i64>

impl DivAssign<i128> for Saturating<i128>

impl DivAssign<i128> for Wrapping<i128>

impl DivAssign<isize> for Saturating<isize>

impl DivAssign<isize> for Wrapping<isize>

impl DivAssign<u8> for Saturating<u8>

impl DivAssign<u8> for Wrapping<u8>

impl DivAssign<u16> for Saturating<u16>

impl DivAssign<u16> for Wrapping<u16>

impl DivAssign<u32> for Saturating<u32>

impl DivAssign<u32> for Wrapping<u32>

impl DivAssign<u32> for Duration

impl DivAssign<u64> for Saturating<u64>

impl DivAssign<u64> for Wrapping<u64>

impl DivAssign<u128> for Saturating<u128>

impl DivAssign<u128> for Wrapping<u128>

impl DivAssign<usize> for Saturating<usize>

impl DivAssign<usize> for Wrapping<usize>

impl DivAssign<NonZero<u8>> for u8

impl DivAssign<NonZero<u16>> for u16

impl DivAssign<NonZero<u32>> for u32

impl DivAssign<NonZero<u64>> for u64

impl DivAssign<NonZero<u128>> for u128

impl DivAssign<NonZero<usize>> for usize

impl<'a, A, S, S2, D, E> DivAssign<&'a ArrayBase<S2, E>> for ArrayBase<S, D>

where A: Clone + DivAssign, S: DataMut<Elem = A>, S2: Data<Elem = A>, D: Dimension, E: Dimension,

Perform self /= rhs as elementwise division (in place). If their shapes disagree, rhs is broadcast to the shape of self.

Panics if broadcasting isn’t possible.

impl<'a, T> DivAssign<&'a Complex<T>> for Complex<T>

where T: Clone + NumAssign,

impl<'a, T> DivAssign<&'a T> for Complex<T>

where T: Clone + NumAssign,

impl<A, S, D> DivAssign<A> for ArrayBase<S, D>

where A: ScalarOperand + DivAssign, S: DataMut<Elem = A>, D: Dimension,

Perform self /= rhs as elementwise division (in place).

impl<E> DivAssign for Quat<E>

where E: MatEl + NdFloat,

impl<E> DivAssign<E> for Quat<E>

where E: MatEl + NdFloat,

impl<E, const LEN: usize> DivAssign for Vector<E, LEN>

where E: MatEl + NdFloat,

impl<E, const LEN: usize> DivAssign<E> for Vector<E, LEN>

where E: MatEl + NdFloat,

impl<E, const ROWS: usize, const COLS: usize, Descriptor> DivAssign<E> for Mat<ROWS, COLS, E, Descriptor>

where Descriptor: Descriptor, E: MatEl + NdFloat, Self: Indexable<Index = Ix2> + ScalarMut<Scalar = E>,

impl<T> DivAssign for Complex<T>

where T: Clone + NumAssign,

impl<T> DivAssign<T> for Complex<T>

where T: Clone + NumAssign,

impl<T, U, const N: usize> DivAssign<U> for Simd<T, N>

where Simd<T, N>: Div<U, Output = Simd<T, N>>, T: SimdElement, LaneCount<N>: SupportedLaneCount,