Trait divrem::DivRemFloor

pub trait DivRemFloor<RHS = Self>: DivRem<RHS> {
    fn div_rem_floor(self, other: RHS) -> Self::Output;
}

Floored division and remainder.

Floors the quotient and effectively rounds towards negative infinity. The sign of the modulus is always the same as the sign of the divisor or zero.

This is equivalent to the divMod function in Haskell.

Required Methods

fn div_rem_floor(self, other: RHS) -> Self::Output

Performs the floored division operation with remainder.

Implementations on Foreign Types

impl DivRemFloor for Wrapping<i8>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<i8>> for &'a Wrapping<i8>

fn div_rem_floor(     self,     other: Wrapping<i8> ) -> <Wrapping<i8> as DivRem<Wrapping<i8>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<i8>> for Wrapping<i8>

fn div_rem_floor(     self,     other: &'a Wrapping<i8> ) -> <Wrapping<i8> as DivRem<Wrapping<i8>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<i8>> for &'b Wrapping<i8>

fn div_rem_floor(     self,     other: &'a Wrapping<i8> ) -> <Wrapping<i8> as DivRem<Wrapping<i8>>>::Output

impl DivRemFloor for Wrapping<i16>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<i16>> for &'a Wrapping<i16>

fn div_rem_floor(     self,     other: Wrapping<i16> ) -> <Wrapping<i16> as DivRem<Wrapping<i16>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<i16>> for Wrapping<i16>

fn div_rem_floor(     self,     other: &'a Wrapping<i16> ) -> <Wrapping<i16> as DivRem<Wrapping<i16>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<i16>> for &'b Wrapping<i16>

fn div_rem_floor(     self,     other: &'a Wrapping<i16> ) -> <Wrapping<i16> as DivRem<Wrapping<i16>>>::Output

impl DivRemFloor for Wrapping<i32>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<i32>> for &'a Wrapping<i32>

fn div_rem_floor(     self,     other: Wrapping<i32> ) -> <Wrapping<i32> as DivRem<Wrapping<i32>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<i32>> for Wrapping<i32>

fn div_rem_floor(     self,     other: &'a Wrapping<i32> ) -> <Wrapping<i32> as DivRem<Wrapping<i32>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<i32>> for &'b Wrapping<i32>

fn div_rem_floor(     self,     other: &'a Wrapping<i32> ) -> <Wrapping<i32> as DivRem<Wrapping<i32>>>::Output

impl DivRemFloor for Wrapping<i64>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<i64>> for &'a Wrapping<i64>

fn div_rem_floor(     self,     other: Wrapping<i64> ) -> <Wrapping<i64> as DivRem<Wrapping<i64>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<i64>> for Wrapping<i64>

fn div_rem_floor(     self,     other: &'a Wrapping<i64> ) -> <Wrapping<i64> as DivRem<Wrapping<i64>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<i64>> for &'b Wrapping<i64>

fn div_rem_floor(     self,     other: &'a Wrapping<i64> ) -> <Wrapping<i64> as DivRem<Wrapping<i64>>>::Output

impl DivRemFloor for Wrapping<i128>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<i128>> for &'a Wrapping<i128>

fn div_rem_floor(     self,     other: Wrapping<i128> ) -> <Wrapping<i128> as DivRem<Wrapping<i128>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<i128>> for Wrapping<i128>

fn div_rem_floor(     self,     other: &'a Wrapping<i128> ) -> <Wrapping<i128> as DivRem<Wrapping<i128>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<i128>> for &'b Wrapping<i128>

fn div_rem_floor(     self,     other: &'a Wrapping<i128> ) -> <Wrapping<i128> as DivRem<Wrapping<i128>>>::Output

impl DivRemFloor for Wrapping<isize>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<isize>> for &'a Wrapping<isize>

fn div_rem_floor(     self,     other: Wrapping<isize> ) -> <Wrapping<isize> as DivRem<Wrapping<isize>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<isize>> for Wrapping<isize>

fn div_rem_floor(     self,     other: &'a Wrapping<isize> ) -> <Wrapping<isize> as DivRem<Wrapping<isize>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<isize>> for &'b Wrapping<isize>

fn div_rem_floor(     self,     other: &'a Wrapping<isize> ) -> <Wrapping<isize> as DivRem<Wrapping<isize>>>::Output

impl DivRemFloor for Wrapping<u8>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<u8>> for &'a Wrapping<u8>

fn div_rem_floor(     self,     other: Wrapping<u8> ) -> <Wrapping<u8> as DivRem<Wrapping<u8>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<u8>> for Wrapping<u8>

fn div_rem_floor(     self,     other: &'a Wrapping<u8> ) -> <Wrapping<u8> as DivRem<Wrapping<u8>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<u8>> for &'b Wrapping<u8>

fn div_rem_floor(     self,     other: &'a Wrapping<u8> ) -> <Wrapping<u8> as DivRem<Wrapping<u8>>>::Output

impl DivRemFloor for Wrapping<u16>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<u16>> for &'a Wrapping<u16>

fn div_rem_floor(     self,     other: Wrapping<u16> ) -> <Wrapping<u16> as DivRem<Wrapping<u16>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<u16>> for Wrapping<u16>

fn div_rem_floor(     self,     other: &'a Wrapping<u16> ) -> <Wrapping<u16> as DivRem<Wrapping<u16>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<u16>> for &'b Wrapping<u16>

fn div_rem_floor(     self,     other: &'a Wrapping<u16> ) -> <Wrapping<u16> as DivRem<Wrapping<u16>>>::Output

impl DivRemFloor for Wrapping<u32>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<u32>> for &'a Wrapping<u32>

fn div_rem_floor(     self,     other: Wrapping<u32> ) -> <Wrapping<u32> as DivRem<Wrapping<u32>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<u32>> for Wrapping<u32>

fn div_rem_floor(     self,     other: &'a Wrapping<u32> ) -> <Wrapping<u32> as DivRem<Wrapping<u32>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<u32>> for &'b Wrapping<u32>

fn div_rem_floor(     self,     other: &'a Wrapping<u32> ) -> <Wrapping<u32> as DivRem<Wrapping<u32>>>::Output

impl DivRemFloor for Wrapping<u64>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<u64>> for &'a Wrapping<u64>

fn div_rem_floor(     self,     other: Wrapping<u64> ) -> <Wrapping<u64> as DivRem<Wrapping<u64>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<u64>> for Wrapping<u64>

fn div_rem_floor(     self,     other: &'a Wrapping<u64> ) -> <Wrapping<u64> as DivRem<Wrapping<u64>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<u64>> for &'b Wrapping<u64>

fn div_rem_floor(     self,     other: &'a Wrapping<u64> ) -> <Wrapping<u64> as DivRem<Wrapping<u64>>>::Output

impl DivRemFloor for Wrapping<u128>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<u128>> for &'a Wrapping<u128>

fn div_rem_floor(     self,     other: Wrapping<u128> ) -> <Wrapping<u128> as DivRem<Wrapping<u128>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<u128>> for Wrapping<u128>

fn div_rem_floor(     self,     other: &'a Wrapping<u128> ) -> <Wrapping<u128> as DivRem<Wrapping<u128>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<u128>> for &'b Wrapping<u128>

fn div_rem_floor(     self,     other: &'a Wrapping<u128> ) -> <Wrapping<u128> as DivRem<Wrapping<u128>>>::Output

impl DivRemFloor for Wrapping<usize>

fn div_rem_floor(self, other: Self) -> (Self, Self)

impl<'a> DivRemFloor<Wrapping<usize>> for &'a Wrapping<usize>

fn div_rem_floor(     self,     other: Wrapping<usize> ) -> <Wrapping<usize> as DivRem<Wrapping<usize>>>::Output

impl<'a> DivRemFloor<&'a Wrapping<usize>> for Wrapping<usize>

fn div_rem_floor(     self,     other: &'a Wrapping<usize> ) -> <Wrapping<usize> as DivRem<Wrapping<usize>>>::Output

impl<'a, 'b> DivRemFloor<&'a Wrapping<usize>> for &'b Wrapping<usize>

fn div_rem_floor(     self,     other: &'a Wrapping<usize> ) -> <Wrapping<usize> as DivRem<Wrapping<usize>>>::Output

Implementors

• impl DivRemFloor for i8

• impl<'a> DivRemFloor<i8> for &'a i8

• impl<'a> DivRemFloor<&'a i8> for i8

• impl<'a, 'b> DivRemFloor<&'a i8> for &'b i8

• impl DivRemFloor for i16

• impl<'a> DivRemFloor<i16> for &'a i16

• impl<'a> DivRemFloor<&'a i16> for i16

• impl<'a, 'b> DivRemFloor<&'a i16> for &'b i16

• impl DivRemFloor for i32

• impl<'a> DivRemFloor<i32> for &'a i32

• impl<'a> DivRemFloor<&'a i32> for i32

• impl<'a, 'b> DivRemFloor<&'a i32> for &'b i32

• impl DivRemFloor for i64

• impl<'a> DivRemFloor<i64> for &'a i64

• impl<'a> DivRemFloor<&'a i64> for i64

• impl<'a, 'b> DivRemFloor<&'a i64> for &'b i64

• impl DivRemFloor for i128

• impl<'a> DivRemFloor<i128> for &'a i128

• impl<'a> DivRemFloor<&'a i128> for i128

• impl<'a, 'b> DivRemFloor<&'a i128> for &'b i128

• impl DivRemFloor for isize

• impl<'a> DivRemFloor<isize> for &'a isize

• impl<'a> DivRemFloor<&'a isize> for isize

• impl<'a, 'b> DivRemFloor<&'a isize> for &'b isize

• impl DivRemFloor for u8

• impl<'a> DivRemFloor<u8> for &'a u8

• impl<'a> DivRemFloor<&'a u8> for u8

• impl<'a, 'b> DivRemFloor<&'a u8> for &'b u8

• impl DivRemFloor for u16

• impl<'a> DivRemFloor<u16> for &'a u16

• impl<'a> DivRemFloor<&'a u16> for u16

• impl<'a, 'b> DivRemFloor<&'a u16> for &'b u16

• impl DivRemFloor for u32

• impl<'a> DivRemFloor<u32> for &'a u32

• impl<'a> DivRemFloor<&'a u32> for u32

• impl<'a, 'b> DivRemFloor<&'a u32> for &'b u32

• impl DivRemFloor for u64

• impl<'a> DivRemFloor<u64> for &'a u64

• impl<'a> DivRemFloor<&'a u64> for u64

• impl<'a, 'b> DivRemFloor<&'a u64> for &'b u64

• impl DivRemFloor for u128

• impl<'a> DivRemFloor<u128> for &'a u128

• impl<'a> DivRemFloor<&'a u128> for u128

• impl<'a, 'b> DivRemFloor<&'a u128> for &'b u128

• impl DivRemFloor for usize

• impl<'a> DivRemFloor<usize> for &'a usize

• impl<'a> DivRemFloor<&'a usize> for usize

• impl<'a, 'b> DivRemFloor<&'a usize> for &'b usize