Trait rug::ops::RemRounding

source ·
pub trait RemRounding<Rhs = Self> {
    type Output;

    // Required methods
    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;
}
Expand description

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);

Required Associated Types§

source

type Output

The resulting type from the remainder operation.

Required Methods§

source

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

Finds the remainder when the quotient is rounded towards zero.

source

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

Finds the remainder when the quotient is rounded up.

source

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

Finds the remainder when the quotient is rounded down.

source

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

Finds the positive remainder from Euclidean division.

Implementations on Foreign Types§

source§

impl RemRounding<&i16> for i16

§

type Output = <i16 as RemRounding<i16>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<f64> for &f64

§

type Output = <f64 as RemRounding<f64>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for &i128

source§

impl RemRounding<i8> for i8

§

type Output = i8

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<f64> for f64

§

type Output = f64

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromU32Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromI8Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<isize> for isize

§

type Output = isize

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromI16Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<i64> for &i64

§

type Output = <i64 as RemRounding<i64>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for u128

source§

impl RemRounding<&f64> for f64

§

type Output = <f64 as RemRounding<f64>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for u8

source§

impl RemRounding<&i32> for i32

§

type Output = <i32 as RemRounding<i32>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromU128Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<&isize> for isize

§

type Output = <isize as RemRounding<isize>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromU8Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<&f64> for &f64

§

type Output = <f64 as RemRounding<f64>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<f32> for &f32

§

type Output = <f32 as RemRounding<f32>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<i32> for i32

§

type Output = i32

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromU32Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<&isize> for &isize

§

type Output = <isize as RemRounding<isize>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for i8

source§

impl RemRounding<Integer> for i16

source§

impl RemRounding<i16> for i16

§

type Output = i16

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for &i32

source§

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

§

type Output = RemRoundingFromI32Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<i128> for i128

§

type Output = i128

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for i64

source§

impl RemRounding<Integer> for u32

source§

impl RemRounding<i64> for i64

§

type Output = i64

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<f32> for f32

§

type Output = f32

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromI128Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromI64Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<&i64> for &i64

§

type Output = <i64 as RemRounding<i64>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<&i128> for &i128

§

type Output = <i128 as RemRounding<i128>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for i32

source§

impl RemRounding<Integer> for i128

source§

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

§

type Output = RemRoundingFromI64Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for u16

source§

impl RemRounding<Integer> for &u64

source§

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

§

type Output = RemRoundingFromU16Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromU8Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<&f32> for f32

§

type Output = <f32 as RemRounding<f32>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for &u8

source§

impl RemRounding<Integer> for u64

source§

impl RemRounding<Integer> for &i8

source§

impl RemRounding<i16> for &i16

§

type Output = <i16 as RemRounding<i16>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromI8Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromI128Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromU16Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<&i8> for &i8

§

type Output = <i8 as RemRounding<i8>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<&i64> for i64

§

type Output = <i64 as RemRounding<i64>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for &u16

source§

impl RemRounding<&i8> for i8

§

type Output = <i8 as RemRounding<i8>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for &u32

source§

impl RemRounding<Integer> for &u128

source§

impl RemRounding<i128> for &i128

§

type Output = <i128 as RemRounding<i128>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<&i32> for &i32

§

type Output = <i32 as RemRounding<i32>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromU64Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<&f32> for &f32

§

type Output = <f32 as RemRounding<f32>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<&i16> for &i16

§

type Output = <i16 as RemRounding<i16>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for &i16

source§

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

§

type Output = RemRoundingFromI16Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<i8> for &i8

§

type Output = <i8 as RemRounding<i8>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromI32Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<i32> for &i32

§

type Output = <i32 as RemRounding<i32>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromU128Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<Integer> for &i64

source§

impl RemRounding<&i128> for i128

§

type Output = <i128 as RemRounding<i128>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = RemRoundingFromU64Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl RemRounding<isize> for &isize

§

type Output = <isize as RemRounding<isize>>::Output

source§

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

source§

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

source§

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

source§

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

Implementors§

source§

impl RemRounding<&i8> for Integer

source§

impl RemRounding<&i16> for Integer

source§

impl RemRounding<&i32> for Integer

source§

impl RemRounding<&i64> for Integer

source§

impl RemRounding<&i128> for Integer

source§

impl RemRounding<&u8> for Integer

source§

impl RemRounding<&u16> for Integer

source§

impl RemRounding<&u32> for Integer

source§

impl RemRounding<&u64> for Integer

source§

impl RemRounding<&u128> for Integer

source§

impl RemRounding<&Integer> for Integer

source§

impl RemRounding<i8> for Integer

source§

impl RemRounding<i16> for Integer

source§

impl RemRounding<i32> for Integer

source§

impl RemRounding<i64> for Integer

source§

impl RemRounding<i128> for Integer

source§

impl RemRounding<u8> for Integer

source§

impl RemRounding<u16> for Integer

source§

impl RemRounding<u32> for Integer

source§

impl RemRounding<u64> for Integer

source§

impl RemRounding<u128> for Integer

source§

impl RemRounding<Integer> for &Integer

source§

impl RemRounding<Integer> for Integer

source§

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

§

type Output = RemRoundingIncomplete<'i>

source§

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

§

type Output = RemRoundingI8Incomplete<'i>

source§

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

§

type Output = RemRoundingI16Incomplete<'i>

source§

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

§

type Output = RemRoundingI32Incomplete<'i>

source§

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

§

type Output = RemRoundingI64Incomplete<'i>

source§

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

§

type Output = RemRoundingI128Incomplete<'i>

source§

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

§

type Output = RemRoundingU8Incomplete<'i>

source§

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

§

type Output = RemRoundingU16Incomplete<'i>

source§

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

§

type Output = RemRoundingU32Incomplete<'i>

source§

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

§

type Output = RemRoundingU64Incomplete<'i>

source§

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

§

type Output = RemRoundingU128Incomplete<'i>

source§

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

§

type Output = RemRoundingI8Incomplete<'i>

source§

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

§

type Output = RemRoundingI16Incomplete<'i>

source§

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

§

type Output = RemRoundingI32Incomplete<'i>

source§

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

§

type Output = RemRoundingI64Incomplete<'i>

source§

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

§

type Output = RemRoundingI128Incomplete<'i>

source§

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

§

type Output = RemRoundingU8Incomplete<'i>

source§

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

§

type Output = RemRoundingU16Incomplete<'i>

source§

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

§

type Output = RemRoundingU32Incomplete<'i>

source§

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

§

type Output = RemRoundingU64Incomplete<'i>

source§

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

§

type Output = RemRoundingU128Incomplete<'i>