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.

Loading content...

Implementations on Foreign Types

impl RemFloor<Wrapping<i8>> 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<Wrapping<i16>> 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<Wrapping<i32>> 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<Wrapping<i64>> 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<Wrapping<i128>> 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<Wrapping<isize>> 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<Wrapping<u8>> 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<Wrapping<u16>> 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<Wrapping<u32>> 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<Wrapping<u64>> 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<Wrapping<u128>> 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<Wrapping<usize>> 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

Loading content...

Implementors

impl RemFloor<i8> for i8

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

impl RemFloor<i16> for i16

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

impl RemFloor<i32> for i32

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

impl RemFloor<i64> for i64

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

impl RemFloor<i128> for i128

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

impl RemFloor<isize> for isize

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

impl RemFloor<u8> for u8

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

impl RemFloor<u16> for u16

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

impl RemFloor<u32> for u32

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

impl RemFloor<u64> for u64

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

impl RemFloor<u128> for u128

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

impl RemFloor<usize> for usize

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...