Trait rug::ops::RemRounding

pub trait RemRounding<Rhs = Self> {
    type Output;
    fn rem_trunc(self, rhs: Rhs) -> Self::Output;
    fn rem_ceil(self, rhs: Rhs) -> Self::Output;
    fn rem_floor(self, rhs: Rhs) -> Self::Output;
    fn rem_euc(self, rhs: Rhs) -> Self::Output;
}

Rounding variants of the remainder operation.

Examples

use rug::ops::RemRounding;
struct I(i32);
impl RemRounding<i32> for I {
    type Output = i32;
    fn rem_trunc(self, rhs: i32) -> i32 {
        self.0 % rhs
    }
    fn rem_ceil(self, rhs: i32) -> i32 {
        let r = self.0 % rhs;
        let change = if rhs > 0 { r > 0 } else { r < 0 };
        if change {
            r - rhs
        } else {
            r
        }
    }
    fn rem_floor(self, rhs: i32) -> i32 {
        let r = self.0 % rhs;
        let change = if rhs > 0 { r < 0 } else { r > 0 };
        if change {
            r + rhs
        } else {
            r
        }
    }
    fn rem_euc(self, rhs: i32) -> i32 {
        let r = self.0 % rhs;
        if r < 0 {
            if rhs < 0 {
                r - rhs
            } else {
                r + rhs
            }
        } else {
            r
        }
    }
}
assert_eq!(I(-10).rem_trunc(-3), -1);
assert_eq!(I(-10).rem_ceil(-3), 2);
assert_eq!(I(-10).rem_floor(-3), -1);
assert_eq!(I(-10).rem_euc(-3), 2);

Associated Types

type Output

The resulting type from the remainder operation.

Loading content...

Required methods

fn rem_trunc(self, rhs: Rhs) -> Self::Output

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Rhs) -> Self::Output

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Rhs) -> Self::Output

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Rhs) -> Self::Output

Finds the positive remainder from Euclidean division.

Loading content...

Implementations on Foreign Types

impl RemRounding<i8> for i8

type Output = i8

fn rem_trunc(self, rhs: i8) -> i8

fn rem_ceil(self, rhs: i8) -> i8

fn rem_floor(self, rhs: i8) -> i8

fn rem_euc(self, rhs: i8) -> i8

impl RemRounding<&'_ i8> for i8

type Output = <i8 as RemRounding>::Output

fn rem_trunc(self, rhs: &i8) -> Self::Output

fn rem_ceil(self, rhs: &i8) -> Self::Output

fn rem_floor(self, rhs: &i8) -> Self::Output

fn rem_euc(self, rhs: &i8) -> Self::Output

impl RemRounding<i8> for &i8

type Output = <i8 as RemRounding>::Output

fn rem_trunc(self, rhs: i8) -> Self::Output

fn rem_ceil(self, rhs: i8) -> Self::Output

fn rem_floor(self, rhs: i8) -> Self::Output

fn rem_euc(self, rhs: i8) -> Self::Output

impl RemRounding<&'_ i8> for &i8

type Output = <i8 as RemRounding>::Output

fn rem_trunc(self, rhs: &i8) -> Self::Output

fn rem_ceil(self, rhs: &i8) -> Self::Output

fn rem_floor(self, rhs: &i8) -> Self::Output

fn rem_euc(self, rhs: &i8) -> Self::Output

impl RemRounding<i16> for i16

type Output = i16

fn rem_trunc(self, rhs: i16) -> i16

fn rem_ceil(self, rhs: i16) -> i16

fn rem_floor(self, rhs: i16) -> i16

fn rem_euc(self, rhs: i16) -> i16

impl RemRounding<&'_ i16> for i16

type Output = <i16 as RemRounding>::Output

fn rem_trunc(self, rhs: &i16) -> Self::Output

fn rem_ceil(self, rhs: &i16) -> Self::Output

fn rem_floor(self, rhs: &i16) -> Self::Output

fn rem_euc(self, rhs: &i16) -> Self::Output

impl RemRounding<i16> for &i16

type Output = <i16 as RemRounding>::Output

fn rem_trunc(self, rhs: i16) -> Self::Output

fn rem_ceil(self, rhs: i16) -> Self::Output

fn rem_floor(self, rhs: i16) -> Self::Output

fn rem_euc(self, rhs: i16) -> Self::Output

impl RemRounding<&'_ i16> for &i16

type Output = <i16 as RemRounding>::Output

fn rem_trunc(self, rhs: &i16) -> Self::Output

fn rem_ceil(self, rhs: &i16) -> Self::Output

fn rem_floor(self, rhs: &i16) -> Self::Output

fn rem_euc(self, rhs: &i16) -> Self::Output

impl RemRounding<i32> for i32

type Output = i32

fn rem_trunc(self, rhs: i32) -> i32

fn rem_ceil(self, rhs: i32) -> i32

fn rem_floor(self, rhs: i32) -> i32

fn rem_euc(self, rhs: i32) -> i32

impl RemRounding<&'_ i32> for i32

type Output = <i32 as RemRounding>::Output

fn rem_trunc(self, rhs: &i32) -> Self::Output

fn rem_ceil(self, rhs: &i32) -> Self::Output

fn rem_floor(self, rhs: &i32) -> Self::Output

fn rem_euc(self, rhs: &i32) -> Self::Output

impl RemRounding<i32> for &i32

type Output = <i32 as RemRounding>::Output

fn rem_trunc(self, rhs: i32) -> Self::Output

fn rem_ceil(self, rhs: i32) -> Self::Output

fn rem_floor(self, rhs: i32) -> Self::Output

fn rem_euc(self, rhs: i32) -> Self::Output

impl RemRounding<&'_ i32> for &i32

type Output = <i32 as RemRounding>::Output

fn rem_trunc(self, rhs: &i32) -> Self::Output

fn rem_ceil(self, rhs: &i32) -> Self::Output

fn rem_floor(self, rhs: &i32) -> Self::Output

fn rem_euc(self, rhs: &i32) -> Self::Output

impl RemRounding<i64> for i64

type Output = i64

fn rem_trunc(self, rhs: i64) -> i64

fn rem_ceil(self, rhs: i64) -> i64

fn rem_floor(self, rhs: i64) -> i64

fn rem_euc(self, rhs: i64) -> i64

impl RemRounding<&'_ i64> for i64

type Output = <i64 as RemRounding>::Output

fn rem_trunc(self, rhs: &i64) -> Self::Output

fn rem_ceil(self, rhs: &i64) -> Self::Output

fn rem_floor(self, rhs: &i64) -> Self::Output

fn rem_euc(self, rhs: &i64) -> Self::Output

impl RemRounding<i64> for &i64

type Output = <i64 as RemRounding>::Output

fn rem_trunc(self, rhs: i64) -> Self::Output

fn rem_ceil(self, rhs: i64) -> Self::Output

fn rem_floor(self, rhs: i64) -> Self::Output

fn rem_euc(self, rhs: i64) -> Self::Output

impl RemRounding<&'_ i64> for &i64

type Output = <i64 as RemRounding>::Output

fn rem_trunc(self, rhs: &i64) -> Self::Output

fn rem_ceil(self, rhs: &i64) -> Self::Output

fn rem_floor(self, rhs: &i64) -> Self::Output

fn rem_euc(self, rhs: &i64) -> Self::Output

impl RemRounding<i128> for i128

type Output = i128

fn rem_trunc(self, rhs: i128) -> i128

fn rem_ceil(self, rhs: i128) -> i128

fn rem_floor(self, rhs: i128) -> i128

fn rem_euc(self, rhs: i128) -> i128

impl RemRounding<&'_ i128> for i128

type Output = <i128 as RemRounding>::Output

fn rem_trunc(self, rhs: &i128) -> Self::Output

fn rem_ceil(self, rhs: &i128) -> Self::Output

fn rem_floor(self, rhs: &i128) -> Self::Output

fn rem_euc(self, rhs: &i128) -> Self::Output

impl RemRounding<i128> for &i128

type Output = <i128 as RemRounding>::Output

fn rem_trunc(self, rhs: i128) -> Self::Output

fn rem_ceil(self, rhs: i128) -> Self::Output

fn rem_floor(self, rhs: i128) -> Self::Output

fn rem_euc(self, rhs: i128) -> Self::Output

impl RemRounding<&'_ i128> for &i128

type Output = <i128 as RemRounding>::Output

fn rem_trunc(self, rhs: &i128) -> Self::Output

fn rem_ceil(self, rhs: &i128) -> Self::Output

fn rem_floor(self, rhs: &i128) -> Self::Output

fn rem_euc(self, rhs: &i128) -> Self::Output

impl RemRounding<isize> for isize

type Output = isize

fn rem_trunc(self, rhs: isize) -> isize

fn rem_ceil(self, rhs: isize) -> isize

fn rem_floor(self, rhs: isize) -> isize

fn rem_euc(self, rhs: isize) -> isize

impl RemRounding<&'_ isize> for isize

type Output = <isize as RemRounding>::Output

fn rem_trunc(self, rhs: &isize) -> Self::Output

fn rem_ceil(self, rhs: &isize) -> Self::Output

fn rem_floor(self, rhs: &isize) -> Self::Output

fn rem_euc(self, rhs: &isize) -> Self::Output

impl RemRounding<isize> for &isize

type Output = <isize as RemRounding>::Output

fn rem_trunc(self, rhs: isize) -> Self::Output

fn rem_ceil(self, rhs: isize) -> Self::Output

fn rem_floor(self, rhs: isize) -> Self::Output

fn rem_euc(self, rhs: isize) -> Self::Output

impl RemRounding<&'_ isize> for &isize

type Output = <isize as RemRounding>::Output

fn rem_trunc(self, rhs: &isize) -> Self::Output

fn rem_ceil(self, rhs: &isize) -> Self::Output

fn rem_floor(self, rhs: &isize) -> Self::Output

fn rem_euc(self, rhs: &isize) -> Self::Output

impl RemRounding<f32> for f32

type Output = f32

fn rem_trunc(self, rhs: f32) -> f32

fn rem_ceil(self, rhs: f32) -> f32

fn rem_floor(self, rhs: f32) -> f32

fn rem_euc(self, rhs: f32) -> f32

impl RemRounding<&'_ f32> for f32

type Output = <f32 as RemRounding>::Output

fn rem_trunc(self, rhs: &f32) -> Self::Output

fn rem_ceil(self, rhs: &f32) -> Self::Output

fn rem_floor(self, rhs: &f32) -> Self::Output

fn rem_euc(self, rhs: &f32) -> Self::Output

impl RemRounding<f32> for &f32

type Output = <f32 as RemRounding>::Output

fn rem_trunc(self, rhs: f32) -> Self::Output

fn rem_ceil(self, rhs: f32) -> Self::Output

fn rem_floor(self, rhs: f32) -> Self::Output

fn rem_euc(self, rhs: f32) -> Self::Output

impl RemRounding<&'_ f32> for &f32

type Output = <f32 as RemRounding>::Output

fn rem_trunc(self, rhs: &f32) -> Self::Output

fn rem_ceil(self, rhs: &f32) -> Self::Output

fn rem_floor(self, rhs: &f32) -> Self::Output

fn rem_euc(self, rhs: &f32) -> Self::Output

impl RemRounding<f64> for f64

type Output = f64

fn rem_trunc(self, rhs: f64) -> f64

fn rem_ceil(self, rhs: f64) -> f64

fn rem_floor(self, rhs: f64) -> f64

fn rem_euc(self, rhs: f64) -> f64

impl RemRounding<&'_ f64> for f64

type Output = <f64 as RemRounding>::Output

fn rem_trunc(self, rhs: &f64) -> Self::Output

fn rem_ceil(self, rhs: &f64) -> Self::Output

fn rem_floor(self, rhs: &f64) -> Self::Output

fn rem_euc(self, rhs: &f64) -> Self::Output

impl RemRounding<f64> for &f64

type Output = <f64 as RemRounding>::Output

fn rem_trunc(self, rhs: f64) -> Self::Output

fn rem_ceil(self, rhs: f64) -> Self::Output

fn rem_floor(self, rhs: f64) -> Self::Output

fn rem_euc(self, rhs: f64) -> Self::Output

impl RemRounding<&'_ f64> for &f64

type Output = <f64 as RemRounding>::Output

fn rem_trunc(self, rhs: &f64) -> Self::Output

fn rem_ceil(self, rhs: &f64) -> Self::Output

fn rem_floor(self, rhs: &f64) -> Self::Output

fn rem_euc(self, rhs: &f64) -> Self::Output

impl RemRounding<Integer> for i8

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for i8

type Output = RemRoundingFromI8Incomplete<'i>

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>

impl RemRounding<Integer> for &i8

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for &i8

type Output = RemRoundingFromI8Incomplete<'i>

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>

impl RemRounding<Integer> for i16

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for i16

type Output = RemRoundingFromI16Incomplete<'i>

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>

impl RemRounding<Integer> for &i16

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for &i16

type Output = RemRoundingFromI16Incomplete<'i>

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>

impl RemRounding<Integer> for i32

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for i32

type Output = RemRoundingFromI32Incomplete<'i>

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>

impl RemRounding<Integer> for &i32

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for &i32

type Output = RemRoundingFromI32Incomplete<'i>

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>

impl RemRounding<Integer> for i64

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for i64

type Output = RemRoundingFromI64Incomplete<'i>

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>

impl RemRounding<Integer> for &i64

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for &i64

type Output = RemRoundingFromI64Incomplete<'i>

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>

impl RemRounding<Integer> for i128

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for i128

type Output = RemRoundingFromI128Incomplete<'i>

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>

impl RemRounding<Integer> for &i128

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for &i128

type Output = RemRoundingFromI128Incomplete<'i>

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>

impl RemRounding<Integer> for u8

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for u8

type Output = RemRoundingFromU8Incomplete<'i>

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>

impl RemRounding<Integer> for &u8

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for &u8

type Output = RemRoundingFromU8Incomplete<'i>

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>

impl RemRounding<Integer> for u16

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for u16

type Output = RemRoundingFromU16Incomplete<'i>

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>

impl RemRounding<Integer> for &u16

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for &u16

type Output = RemRoundingFromU16Incomplete<'i>

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>

impl RemRounding<Integer> for u32

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for u32

type Output = RemRoundingFromU32Incomplete<'i>

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>

impl RemRounding<Integer> for &u32

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for &u32

type Output = RemRoundingFromU32Incomplete<'i>

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>

impl RemRounding<Integer> for u64

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for u64

type Output = RemRoundingFromU64Incomplete<'i>

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>

impl RemRounding<Integer> for &u64

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for &u64

type Output = RemRoundingFromU64Incomplete<'i>

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>

impl RemRounding<Integer> for u128

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for u128

type Output = RemRoundingFromU128Incomplete<'i>

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>

impl RemRounding<Integer> for &u128

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for &u128

type Output = RemRoundingFromU128Incomplete<'i>

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>

Loading content...

Implementors

impl RemRounding<&'_ i8> for Integer

type Output = Integer

fn rem_trunc(self, rhs: &i8) -> Integer

fn rem_ceil(self, rhs: &i8) -> Integer

fn rem_floor(self, rhs: &i8) -> Integer

fn rem_euc(self, rhs: &i8) -> Integer

impl RemRounding<&'_ i16> for Integer

type Output = Integer

fn rem_trunc(self, rhs: &i16) -> Integer

fn rem_ceil(self, rhs: &i16) -> Integer

fn rem_floor(self, rhs: &i16) -> Integer

fn rem_euc(self, rhs: &i16) -> Integer

impl RemRounding<&'_ i32> for Integer

type Output = Integer

fn rem_trunc(self, rhs: &i32) -> Integer

fn rem_ceil(self, rhs: &i32) -> Integer

fn rem_floor(self, rhs: &i32) -> Integer

fn rem_euc(self, rhs: &i32) -> Integer

impl RemRounding<&'_ i64> for Integer

type Output = Integer

fn rem_trunc(self, rhs: &i64) -> Integer

fn rem_ceil(self, rhs: &i64) -> Integer

fn rem_floor(self, rhs: &i64) -> Integer

fn rem_euc(self, rhs: &i64) -> Integer

impl RemRounding<&'_ i128> for Integer

type Output = Integer

fn rem_trunc(self, rhs: &i128) -> Integer

fn rem_ceil(self, rhs: &i128) -> Integer

fn rem_floor(self, rhs: &i128) -> Integer

fn rem_euc(self, rhs: &i128) -> Integer

impl RemRounding<&'_ u8> for Integer

type Output = Integer

fn rem_trunc(self, rhs: &u8) -> Integer

fn rem_ceil(self, rhs: &u8) -> Integer

fn rem_floor(self, rhs: &u8) -> Integer

fn rem_euc(self, rhs: &u8) -> Integer

impl RemRounding<&'_ u16> for Integer

type Output = Integer

fn rem_trunc(self, rhs: &u16) -> Integer

fn rem_ceil(self, rhs: &u16) -> Integer

fn rem_floor(self, rhs: &u16) -> Integer

fn rem_euc(self, rhs: &u16) -> Integer

impl RemRounding<&'_ u32> for Integer

type Output = Integer

fn rem_trunc(self, rhs: &u32) -> Integer

fn rem_ceil(self, rhs: &u32) -> Integer

fn rem_floor(self, rhs: &u32) -> Integer

fn rem_euc(self, rhs: &u32) -> Integer

impl RemRounding<&'_ u64> for Integer

type Output = Integer

fn rem_trunc(self, rhs: &u64) -> Integer

fn rem_ceil(self, rhs: &u64) -> Integer

fn rem_floor(self, rhs: &u64) -> Integer

fn rem_euc(self, rhs: &u64) -> Integer

impl RemRounding<&'_ u128> for Integer

type Output = Integer

fn rem_trunc(self, rhs: &u128) -> Integer

fn rem_ceil(self, rhs: &u128) -> Integer

fn rem_floor(self, rhs: &u128) -> Integer

fn rem_euc(self, rhs: &u128) -> Integer

impl RemRounding<&'_ Integer> for Integer

type Output = Integer

fn rem_trunc(self, rhs: &Integer) -> Integer

fn rem_ceil(self, rhs: &Integer) -> Integer

fn rem_floor(self, rhs: &Integer) -> Integer

fn rem_euc(self, rhs: &Integer) -> Integer

impl RemRounding<i8> for Integer

type Output = Integer

fn rem_trunc(self, rhs: i8) -> Integer

fn rem_ceil(self, rhs: i8) -> Integer

fn rem_floor(self, rhs: i8) -> Integer

fn rem_euc(self, rhs: i8) -> Integer

impl RemRounding<i16> for Integer

type Output = Integer

fn rem_trunc(self, rhs: i16) -> Integer

fn rem_ceil(self, rhs: i16) -> Integer

fn rem_floor(self, rhs: i16) -> Integer

fn rem_euc(self, rhs: i16) -> Integer

impl RemRounding<i32> for Integer

type Output = Integer

fn rem_trunc(self, rhs: i32) -> Integer

fn rem_ceil(self, rhs: i32) -> Integer

fn rem_floor(self, rhs: i32) -> Integer

fn rem_euc(self, rhs: i32) -> Integer

impl RemRounding<i64> for Integer

type Output = Integer

fn rem_trunc(self, rhs: i64) -> Integer

fn rem_ceil(self, rhs: i64) -> Integer

fn rem_floor(self, rhs: i64) -> Integer

fn rem_euc(self, rhs: i64) -> Integer

impl RemRounding<i128> for Integer

type Output = Integer

fn rem_trunc(self, rhs: i128) -> Integer

fn rem_ceil(self, rhs: i128) -> Integer

fn rem_floor(self, rhs: i128) -> Integer

fn rem_euc(self, rhs: i128) -> Integer

impl RemRounding<u8> for Integer

type Output = Integer

fn rem_trunc(self, rhs: u8) -> Integer

fn rem_ceil(self, rhs: u8) -> Integer

fn rem_floor(self, rhs: u8) -> Integer

fn rem_euc(self, rhs: u8) -> Integer

impl RemRounding<u16> for Integer

type Output = Integer

fn rem_trunc(self, rhs: u16) -> Integer

fn rem_ceil(self, rhs: u16) -> Integer

fn rem_floor(self, rhs: u16) -> Integer

fn rem_euc(self, rhs: u16) -> Integer

impl RemRounding<u32> for Integer

type Output = Integer

fn rem_trunc(self, rhs: u32) -> Integer

fn rem_ceil(self, rhs: u32) -> Integer

fn rem_floor(self, rhs: u32) -> Integer

fn rem_euc(self, rhs: u32) -> Integer

impl RemRounding<u64> for Integer

type Output = Integer

fn rem_trunc(self, rhs: u64) -> Integer

fn rem_ceil(self, rhs: u64) -> Integer

fn rem_floor(self, rhs: u64) -> Integer

fn rem_euc(self, rhs: u64) -> Integer

impl RemRounding<u128> for Integer

type Output = Integer

fn rem_trunc(self, rhs: u128) -> Integer

fn rem_ceil(self, rhs: u128) -> Integer

fn rem_floor(self, rhs: u128) -> Integer

fn rem_euc(self, rhs: u128) -> Integer

impl RemRounding<Integer> for &Integer

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl RemRounding<Integer> for Integer

type Output = Integer

fn rem_trunc(self, rhs: Integer) -> Integer

fn rem_ceil(self, rhs: Integer) -> Integer

fn rem_floor(self, rhs: Integer) -> Integer

fn rem_euc(self, rhs: Integer) -> Integer

impl<'i> RemRounding<&'i Integer> for &'i Integer

type Output = RemRoundingIncomplete<'i>

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>

impl<'i> RemRounding<i8> for &'i Integer

type Output = RemRoundingI8Incomplete<'i>

fn rem_trunc(self, rhs: i8) -> RemRoundingI8Incomplete<'i>

fn rem_ceil(self, rhs: i8) -> RemRoundingI8Incomplete<'i>

fn rem_floor(self, rhs: i8) -> RemRoundingI8Incomplete<'i>

fn rem_euc(self, rhs: i8) -> RemRoundingI8Incomplete<'i>

impl<'i> RemRounding<i16> for &'i Integer

type Output = RemRoundingI16Incomplete<'i>

fn rem_trunc(self, rhs: i16) -> RemRoundingI16Incomplete<'i>

fn rem_ceil(self, rhs: i16) -> RemRoundingI16Incomplete<'i>

fn rem_floor(self, rhs: i16) -> RemRoundingI16Incomplete<'i>

fn rem_euc(self, rhs: i16) -> RemRoundingI16Incomplete<'i>

impl<'i> RemRounding<i32> for &'i Integer

type Output = RemRoundingI32Incomplete<'i>

fn rem_trunc(self, rhs: i32) -> RemRoundingI32Incomplete<'i>

fn rem_ceil(self, rhs: i32) -> RemRoundingI32Incomplete<'i>

fn rem_floor(self, rhs: i32) -> RemRoundingI32Incomplete<'i>

fn rem_euc(self, rhs: i32) -> RemRoundingI32Incomplete<'i>

impl<'i> RemRounding<i64> for &'i Integer

type Output = RemRoundingI64Incomplete<'i>

fn rem_trunc(self, rhs: i64) -> RemRoundingI64Incomplete<'i>

fn rem_ceil(self, rhs: i64) -> RemRoundingI64Incomplete<'i>

fn rem_floor(self, rhs: i64) -> RemRoundingI64Incomplete<'i>

fn rem_euc(self, rhs: i64) -> RemRoundingI64Incomplete<'i>

impl<'i> RemRounding<i128> for &'i Integer

type Output = RemRoundingI128Incomplete<'i>

fn rem_trunc(self, rhs: i128) -> RemRoundingI128Incomplete<'i>

fn rem_ceil(self, rhs: i128) -> RemRoundingI128Incomplete<'i>

fn rem_floor(self, rhs: i128) -> RemRoundingI128Incomplete<'i>

fn rem_euc(self, rhs: i128) -> RemRoundingI128Incomplete<'i>

impl<'i> RemRounding<u8> for &'i Integer

type Output = RemRoundingU8Incomplete<'i>

fn rem_trunc(self, rhs: u8) -> RemRoundingU8Incomplete<'i>

fn rem_ceil(self, rhs: u8) -> RemRoundingU8Incomplete<'i>

fn rem_floor(self, rhs: u8) -> RemRoundingU8Incomplete<'i>

fn rem_euc(self, rhs: u8) -> RemRoundingU8Incomplete<'i>

impl<'i> RemRounding<u16> for &'i Integer

type Output = RemRoundingU16Incomplete<'i>

fn rem_trunc(self, rhs: u16) -> RemRoundingU16Incomplete<'i>

fn rem_ceil(self, rhs: u16) -> RemRoundingU16Incomplete<'i>

fn rem_floor(self, rhs: u16) -> RemRoundingU16Incomplete<'i>

fn rem_euc(self, rhs: u16) -> RemRoundingU16Incomplete<'i>

impl<'i> RemRounding<u32> for &'i Integer

type Output = RemRoundingU32Incomplete<'i>

fn rem_trunc(self, rhs: u32) -> RemRoundingU32Incomplete<'i>

fn rem_ceil(self, rhs: u32) -> RemRoundingU32Incomplete<'i>

fn rem_floor(self, rhs: u32) -> RemRoundingU32Incomplete<'i>

fn rem_euc(self, rhs: u32) -> RemRoundingU32Incomplete<'i>

impl<'i> RemRounding<u64> for &'i Integer

type Output = RemRoundingU64Incomplete<'i>

fn rem_trunc(self, rhs: u64) -> RemRoundingU64Incomplete<'i>

fn rem_ceil(self, rhs: u64) -> RemRoundingU64Incomplete<'i>

fn rem_floor(self, rhs: u64) -> RemRoundingU64Incomplete<'i>

fn rem_euc(self, rhs: u64) -> RemRoundingU64Incomplete<'i>

impl<'i> RemRounding<u128> for &'i Integer

type Output = RemRoundingU128Incomplete<'i>

fn rem_trunc(self, rhs: u128) -> RemRoundingU128Incomplete<'i>

fn rem_ceil(self, rhs: u128) -> RemRoundingU128Incomplete<'i>

fn rem_floor(self, rhs: u128) -> RemRoundingU128Incomplete<'i>

fn rem_euc(self, rhs: u128) -> RemRoundingU128Incomplete<'i>

impl<'t, 'i> RemRounding<&'t i8> for &'i Integer

type Output = RemRoundingI8Incomplete<'i>

fn rem_trunc(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>

fn rem_ceil(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>

fn rem_floor(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>

fn rem_euc(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>

impl<'t, 'i> RemRounding<&'t i16> for &'i Integer

type Output = RemRoundingI16Incomplete<'i>

fn rem_trunc(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>

fn rem_ceil(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>

fn rem_floor(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>

fn rem_euc(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>

impl<'t, 'i> RemRounding<&'t i32> for &'i Integer

type Output = RemRoundingI32Incomplete<'i>

fn rem_trunc(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>

fn rem_ceil(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>

fn rem_floor(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>

fn rem_euc(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>

impl<'t, 'i> RemRounding<&'t i64> for &'i Integer

type Output = RemRoundingI64Incomplete<'i>

fn rem_trunc(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>

fn rem_ceil(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>

fn rem_floor(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>

fn rem_euc(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>

impl<'t, 'i> RemRounding<&'t i128> for &'i Integer

type Output = RemRoundingI128Incomplete<'i>

fn rem_trunc(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>

fn rem_ceil(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>

fn rem_floor(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>

fn rem_euc(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>

impl<'t, 'i> RemRounding<&'t u8> for &'i Integer

type Output = RemRoundingU8Incomplete<'i>

fn rem_trunc(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>

fn rem_ceil(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>

fn rem_floor(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>

fn rem_euc(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>

impl<'t, 'i> RemRounding<&'t u16> for &'i Integer

type Output = RemRoundingU16Incomplete<'i>

fn rem_trunc(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>

fn rem_ceil(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>

fn rem_floor(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>

fn rem_euc(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>

impl<'t, 'i> RemRounding<&'t u32> for &'i Integer

type Output = RemRoundingU32Incomplete<'i>

fn rem_trunc(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>

fn rem_ceil(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>

fn rem_floor(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>

fn rem_euc(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>

impl<'t, 'i> RemRounding<&'t u64> for &'i Integer

type Output = RemRoundingU64Incomplete<'i>

fn rem_trunc(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>

fn rem_ceil(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>

fn rem_floor(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>

fn rem_euc(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>

impl<'t, 'i> RemRounding<&'t u128> for &'i Integer

type Output = RemRoundingU128Incomplete<'i>

fn rem_trunc(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>

fn rem_ceil(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>

fn rem_floor(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>

fn rem_euc(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>

Loading content...