Trait divrem::RemFloor

pub trait RemFloor<RHS = Self>: Rem<RHS> {
    fn rem_floor(self, other: RHS) -> Self::Output;
}

Floored division remainder.

The sign of the modulus is always the same as the sign of the divisor or zero.

This is equivalent to the mod function in Haskell.

Required Methods

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

Returns the remainder of the floored division operation.

Implementations on Foreign Types

impl RemFloor for Wrapping<i8>

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

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

fn rem_floor(     self,     other: Wrapping<i8> ) -> <Wrapping<i8> as Rem<Wrapping<i8>>>::Output

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

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

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

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

impl RemFloor for Wrapping<i16>

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

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

fn rem_floor(     self,     other: Wrapping<i16> ) -> <Wrapping<i16> as Rem<Wrapping<i16>>>::Output

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

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

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

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

impl RemFloor for Wrapping<i32>

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

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

fn rem_floor(     self,     other: Wrapping<i32> ) -> <Wrapping<i32> as Rem<Wrapping<i32>>>::Output

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

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

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

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

impl RemFloor for Wrapping<i64>

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

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

fn rem_floor(     self,     other: Wrapping<i64> ) -> <Wrapping<i64> as Rem<Wrapping<i64>>>::Output

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

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

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

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

impl RemFloor for Wrapping<i128>

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

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

fn rem_floor(     self,     other: Wrapping<i128> ) -> <Wrapping<i128> as Rem<Wrapping<i128>>>::Output

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

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

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

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

impl RemFloor for Wrapping<isize>

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

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

fn rem_floor(     self,     other: Wrapping<isize> ) -> <Wrapping<isize> as Rem<Wrapping<isize>>>::Output

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

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

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

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

impl RemFloor for Wrapping<u8>

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

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

fn rem_floor(     self,     other: Wrapping<u8> ) -> <Wrapping<u8> as Rem<Wrapping<u8>>>::Output

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

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

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

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

impl RemFloor for Wrapping<u16>

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

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

fn rem_floor(     self,     other: Wrapping<u16> ) -> <Wrapping<u16> as Rem<Wrapping<u16>>>::Output

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

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

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

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

impl RemFloor for Wrapping<u32>

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

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

fn rem_floor(     self,     other: Wrapping<u32> ) -> <Wrapping<u32> as Rem<Wrapping<u32>>>::Output

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

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

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

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

impl RemFloor for Wrapping<u64>

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

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

fn rem_floor(     self,     other: Wrapping<u64> ) -> <Wrapping<u64> as Rem<Wrapping<u64>>>::Output

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

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

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

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

impl RemFloor for Wrapping<u128>

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

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

fn rem_floor(     self,     other: Wrapping<u128> ) -> <Wrapping<u128> as Rem<Wrapping<u128>>>::Output

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

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

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

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

impl RemFloor for Wrapping<usize>

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

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

fn rem_floor(     self,     other: Wrapping<usize> ) -> <Wrapping<usize> as Rem<Wrapping<usize>>>::Output

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

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

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

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

Implementors

• impl RemFloor for i8

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

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

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

• impl RemFloor for i16

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

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

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

• impl RemFloor for i32

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

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

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

• impl RemFloor for i64

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

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

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

• impl RemFloor for i128

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

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

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

• impl RemFloor for isize

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

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

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

• impl RemFloor for u8

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

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

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

• impl RemFloor for u16

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

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

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

• impl RemFloor for u32

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

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

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

• impl RemFloor for u64

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

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

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

• impl RemFloor for u128

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

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

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

• impl RemFloor for usize

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

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

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