Trait rug::ops::DivRounding

pub trait DivRounding<Rhs = Self> {
    type Output;
    fn div_trunc(self, rhs: Rhs) -> Self::Output;
    fn div_ceil(self, rhs: Rhs) -> Self::Output;
    fn div_floor(self, rhs: Rhs) -> Self::Output;
    fn div_euc(self, rhs: Rhs) -> Self::Output;
}

Rounding variants of division.

Examples

use rug::ops::DivRounding;
struct I(i32);
impl DivRounding<i32> for I {
    type Output = i32;
    fn div_trunc(self, rhs: i32) -> i32 {
        self.0 / rhs
    }
    fn div_ceil(self, rhs: i32) -> i32 {
        let (q, r) = (self.0 / rhs, self.0 % rhs);
        let change = if rhs > 0 { r > 0 } else { r < 0 };
        if change {
            q + 1
        } else {
            q
        }
    }
    fn div_floor(self, rhs: i32) -> i32 {
        let (q, r) = (self.0 / rhs, self.0 % rhs);
        let change = if rhs > 0 { r < 0 } else { r > 0 };
        if change {
            q - 1
        } else {
            q
        }
    }
    fn div_euc(self, rhs: i32) -> i32 {
        let (q, r) = (self.0 / rhs, self.0 % rhs);
        if r < 0 {
            if rhs < 0 {
                q + 1
            } else {
                q - 1
            }
        } else {
            q
        }
    }
}
assert_eq!(I(-10).div_trunc(-3), 3);
assert_eq!(I(-10).div_ceil(-3), 4);
assert_eq!(I(-10).div_floor(-3), 3);
assert_eq!(I(-10).div_euc(-3), 4);

Associated Types

type Output

The resulting type from the division operation.

Loading content...

Required methods

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

Performs Euclidean division, rounding the quotient so that the remainder cannot be negative.

Loading content...

Implementations on Foreign Types

impl DivRounding<i8> for i8

type Output = i8

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

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

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

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

impl DivRounding<&'_ i8> for i8

type Output = <i8 as DivRounding>::Output

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

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

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

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

impl DivRounding<i8> for &i8

type Output = <i8 as DivRounding>::Output

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

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

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

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

impl DivRounding<&'_ i8> for &i8

type Output = <i8 as DivRounding>::Output

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

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

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

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

impl DivRounding<i16> for i16

type Output = i16

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

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

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

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

impl DivRounding<&'_ i16> for i16

type Output = <i16 as DivRounding>::Output

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

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

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

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

impl DivRounding<i16> for &i16

type Output = <i16 as DivRounding>::Output

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

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

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

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

impl DivRounding<&'_ i16> for &i16

type Output = <i16 as DivRounding>::Output

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

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

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

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

impl DivRounding<i32> for i32

type Output = i32

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

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

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

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

impl DivRounding<&'_ i32> for i32

type Output = <i32 as DivRounding>::Output

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

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

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

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

impl DivRounding<i32> for &i32

type Output = <i32 as DivRounding>::Output

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

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

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

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

impl DivRounding<&'_ i32> for &i32

type Output = <i32 as DivRounding>::Output

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

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

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

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

impl DivRounding<i64> for i64

type Output = i64

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

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

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

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

impl DivRounding<&'_ i64> for i64

type Output = <i64 as DivRounding>::Output

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

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

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

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

impl DivRounding<i64> for &i64

type Output = <i64 as DivRounding>::Output

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

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

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

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

impl DivRounding<&'_ i64> for &i64

type Output = <i64 as DivRounding>::Output

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

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

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

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

impl DivRounding<i128> for i128

type Output = i128

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

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

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

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

impl DivRounding<&'_ i128> for i128

type Output = <i128 as DivRounding>::Output

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

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

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

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

impl DivRounding<i128> for &i128

type Output = <i128 as DivRounding>::Output

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

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

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

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

impl DivRounding<&'_ i128> for &i128

type Output = <i128 as DivRounding>::Output

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

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

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

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

impl DivRounding<isize> for isize

type Output = isize

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

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

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

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

impl DivRounding<&'_ isize> for isize

type Output = <isize as DivRounding>::Output

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

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

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

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

impl DivRounding<isize> for &isize

type Output = <isize as DivRounding>::Output

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

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

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

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

impl DivRounding<&'_ isize> for &isize

type Output = <isize as DivRounding>::Output

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

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

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

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

impl DivRounding<u8> for u8

type Output = u8

fn div_trunc(self, rhs: u8) -> u8

fn div_ceil(self, rhs: u8) -> u8

fn div_floor(self, rhs: u8) -> u8

fn div_euc(self, rhs: u8) -> u8

impl DivRounding<&'_ u8> for u8

type Output = <u8 as DivRounding>::Output

fn div_trunc(self, rhs: &u8) -> Self::Output

fn div_ceil(self, rhs: &u8) -> Self::Output

fn div_floor(self, rhs: &u8) -> Self::Output

fn div_euc(self, rhs: &u8) -> Self::Output

impl DivRounding<u8> for &u8

type Output = <u8 as DivRounding>::Output

fn div_trunc(self, rhs: u8) -> Self::Output

fn div_ceil(self, rhs: u8) -> Self::Output

fn div_floor(self, rhs: u8) -> Self::Output

fn div_euc(self, rhs: u8) -> Self::Output

impl DivRounding<&'_ u8> for &u8

type Output = <u8 as DivRounding>::Output

fn div_trunc(self, rhs: &u8) -> Self::Output

fn div_ceil(self, rhs: &u8) -> Self::Output

fn div_floor(self, rhs: &u8) -> Self::Output

fn div_euc(self, rhs: &u8) -> Self::Output

impl DivRounding<u16> for u16

type Output = u16

fn div_trunc(self, rhs: u16) -> u16

fn div_ceil(self, rhs: u16) -> u16

fn div_floor(self, rhs: u16) -> u16

fn div_euc(self, rhs: u16) -> u16

impl DivRounding<&'_ u16> for u16

type Output = <u16 as DivRounding>::Output

fn div_trunc(self, rhs: &u16) -> Self::Output

fn div_ceil(self, rhs: &u16) -> Self::Output

fn div_floor(self, rhs: &u16) -> Self::Output

fn div_euc(self, rhs: &u16) -> Self::Output

impl DivRounding<u16> for &u16

type Output = <u16 as DivRounding>::Output

fn div_trunc(self, rhs: u16) -> Self::Output

fn div_ceil(self, rhs: u16) -> Self::Output

fn div_floor(self, rhs: u16) -> Self::Output

fn div_euc(self, rhs: u16) -> Self::Output

impl DivRounding<&'_ u16> for &u16

type Output = <u16 as DivRounding>::Output

fn div_trunc(self, rhs: &u16) -> Self::Output

fn div_ceil(self, rhs: &u16) -> Self::Output

fn div_floor(self, rhs: &u16) -> Self::Output

fn div_euc(self, rhs: &u16) -> Self::Output

impl DivRounding<u32> for u32

type Output = u32

fn div_trunc(self, rhs: u32) -> u32

fn div_ceil(self, rhs: u32) -> u32

fn div_floor(self, rhs: u32) -> u32

fn div_euc(self, rhs: u32) -> u32

impl DivRounding<&'_ u32> for u32

type Output = <u32 as DivRounding>::Output

fn div_trunc(self, rhs: &u32) -> Self::Output

fn div_ceil(self, rhs: &u32) -> Self::Output

fn div_floor(self, rhs: &u32) -> Self::Output

fn div_euc(self, rhs: &u32) -> Self::Output

impl DivRounding<u32> for &u32

type Output = <u32 as DivRounding>::Output

fn div_trunc(self, rhs: u32) -> Self::Output

fn div_ceil(self, rhs: u32) -> Self::Output

fn div_floor(self, rhs: u32) -> Self::Output

fn div_euc(self, rhs: u32) -> Self::Output

impl DivRounding<&'_ u32> for &u32

type Output = <u32 as DivRounding>::Output

fn div_trunc(self, rhs: &u32) -> Self::Output

fn div_ceil(self, rhs: &u32) -> Self::Output

fn div_floor(self, rhs: &u32) -> Self::Output

fn div_euc(self, rhs: &u32) -> Self::Output

impl DivRounding<u64> for u64

type Output = u64

fn div_trunc(self, rhs: u64) -> u64

fn div_ceil(self, rhs: u64) -> u64

fn div_floor(self, rhs: u64) -> u64

fn div_euc(self, rhs: u64) -> u64

impl DivRounding<&'_ u64> for u64

type Output = <u64 as DivRounding>::Output

fn div_trunc(self, rhs: &u64) -> Self::Output

fn div_ceil(self, rhs: &u64) -> Self::Output

fn div_floor(self, rhs: &u64) -> Self::Output

fn div_euc(self, rhs: &u64) -> Self::Output

impl DivRounding<u64> for &u64

type Output = <u64 as DivRounding>::Output

fn div_trunc(self, rhs: u64) -> Self::Output

fn div_ceil(self, rhs: u64) -> Self::Output

fn div_floor(self, rhs: u64) -> Self::Output

fn div_euc(self, rhs: u64) -> Self::Output

impl DivRounding<&'_ u64> for &u64

type Output = <u64 as DivRounding>::Output

fn div_trunc(self, rhs: &u64) -> Self::Output

fn div_ceil(self, rhs: &u64) -> Self::Output

fn div_floor(self, rhs: &u64) -> Self::Output

fn div_euc(self, rhs: &u64) -> Self::Output

impl DivRounding<u128> for u128

type Output = u128

fn div_trunc(self, rhs: u128) -> u128

fn div_ceil(self, rhs: u128) -> u128

fn div_floor(self, rhs: u128) -> u128

fn div_euc(self, rhs: u128) -> u128

impl DivRounding<&'_ u128> for u128

type Output = <u128 as DivRounding>::Output

fn div_trunc(self, rhs: &u128) -> Self::Output

fn div_ceil(self, rhs: &u128) -> Self::Output

fn div_floor(self, rhs: &u128) -> Self::Output

fn div_euc(self, rhs: &u128) -> Self::Output

impl DivRounding<u128> for &u128

type Output = <u128 as DivRounding>::Output

fn div_trunc(self, rhs: u128) -> Self::Output

fn div_ceil(self, rhs: u128) -> Self::Output

fn div_floor(self, rhs: u128) -> Self::Output

fn div_euc(self, rhs: u128) -> Self::Output

impl DivRounding<&'_ u128> for &u128

type Output = <u128 as DivRounding>::Output

fn div_trunc(self, rhs: &u128) -> Self::Output

fn div_ceil(self, rhs: &u128) -> Self::Output

fn div_floor(self, rhs: &u128) -> Self::Output

fn div_euc(self, rhs: &u128) -> Self::Output

impl DivRounding<usize> for usize

type Output = usize

fn div_trunc(self, rhs: usize) -> usize

fn div_ceil(self, rhs: usize) -> usize

fn div_floor(self, rhs: usize) -> usize

fn div_euc(self, rhs: usize) -> usize

impl DivRounding<&'_ usize> for usize

type Output = <usize as DivRounding>::Output

fn div_trunc(self, rhs: &usize) -> Self::Output

fn div_ceil(self, rhs: &usize) -> Self::Output

fn div_floor(self, rhs: &usize) -> Self::Output

fn div_euc(self, rhs: &usize) -> Self::Output

impl DivRounding<usize> for &usize

type Output = <usize as DivRounding>::Output

fn div_trunc(self, rhs: usize) -> Self::Output

fn div_ceil(self, rhs: usize) -> Self::Output

fn div_floor(self, rhs: usize) -> Self::Output

fn div_euc(self, rhs: usize) -> Self::Output

impl DivRounding<&'_ usize> for &usize

type Output = <usize as DivRounding>::Output

fn div_trunc(self, rhs: &usize) -> Self::Output

fn div_ceil(self, rhs: &usize) -> Self::Output

fn div_floor(self, rhs: &usize) -> Self::Output

fn div_euc(self, rhs: &usize) -> Self::Output

impl DivRounding<f32> for f32

type Output = f32

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

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

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

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

impl DivRounding<&'_ f32> for f32

type Output = <f32 as DivRounding>::Output

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

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

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

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

impl DivRounding<f32> for &f32

type Output = <f32 as DivRounding>::Output

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

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

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

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

impl DivRounding<&'_ f32> for &f32

type Output = <f32 as DivRounding>::Output

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

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

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

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

impl DivRounding<f64> for f64

type Output = f64

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

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

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

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

impl DivRounding<&'_ f64> for f64

type Output = <f64 as DivRounding>::Output

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

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

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

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

impl DivRounding<f64> for &f64

type Output = <f64 as DivRounding>::Output

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

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

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

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

impl DivRounding<&'_ f64> for &f64

type Output = <f64 as DivRounding>::Output

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

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

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

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

impl DivRounding<Integer> for i8

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromI8Incomplete<'i>

fn div_trunc(self, rhs: &Integer) -> DivRoundingFromI8Incomplete<'_>

fn div_ceil(self, rhs: &Integer) -> DivRoundingFromI8Incomplete<'_>

fn div_floor(self, rhs: &Integer) -> DivRoundingFromI8Incomplete<'_>

fn div_euc(self, rhs: &Integer) -> DivRoundingFromI8Incomplete<'_>

impl DivRounding<Integer> for &i8

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromI8Incomplete<'i>

fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI8Incomplete<'i>

fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI8Incomplete<'i>

fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromI8Incomplete<'i>

fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromI8Incomplete<'i>

impl DivRounding<Integer> for i16

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromI16Incomplete<'i>

fn div_trunc(self, rhs: &Integer) -> DivRoundingFromI16Incomplete<'_>

fn div_ceil(self, rhs: &Integer) -> DivRoundingFromI16Incomplete<'_>

fn div_floor(self, rhs: &Integer) -> DivRoundingFromI16Incomplete<'_>

fn div_euc(self, rhs: &Integer) -> DivRoundingFromI16Incomplete<'_>

impl DivRounding<Integer> for &i16

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromI16Incomplete<'i>

fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI16Incomplete<'i>

fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI16Incomplete<'i>

fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromI16Incomplete<'i>

fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromI16Incomplete<'i>

impl DivRounding<Integer> for i32

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromI32Incomplete<'i>

fn div_trunc(self, rhs: &Integer) -> DivRoundingFromI32Incomplete<'_>

fn div_ceil(self, rhs: &Integer) -> DivRoundingFromI32Incomplete<'_>

fn div_floor(self, rhs: &Integer) -> DivRoundingFromI32Incomplete<'_>

fn div_euc(self, rhs: &Integer) -> DivRoundingFromI32Incomplete<'_>

impl DivRounding<Integer> for &i32

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromI32Incomplete<'i>

fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i>

fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i>

fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i>

fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i>

impl DivRounding<Integer> for i64

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromI64Incomplete<'i>

fn div_trunc(self, rhs: &Integer) -> DivRoundingFromI64Incomplete<'_>

fn div_ceil(self, rhs: &Integer) -> DivRoundingFromI64Incomplete<'_>

fn div_floor(self, rhs: &Integer) -> DivRoundingFromI64Incomplete<'_>

fn div_euc(self, rhs: &Integer) -> DivRoundingFromI64Incomplete<'_>

impl DivRounding<Integer> for &i64

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromI64Incomplete<'i>

fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI64Incomplete<'i>

fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI64Incomplete<'i>

fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromI64Incomplete<'i>

fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromI64Incomplete<'i>

impl DivRounding<Integer> for i128

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromI128Incomplete<'i>

fn div_trunc(self, rhs: &Integer) -> DivRoundingFromI128Incomplete<'_>

fn div_ceil(self, rhs: &Integer) -> DivRoundingFromI128Incomplete<'_>

fn div_floor(self, rhs: &Integer) -> DivRoundingFromI128Incomplete<'_>

fn div_euc(self, rhs: &Integer) -> DivRoundingFromI128Incomplete<'_>

impl DivRounding<Integer> for &i128

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromI128Incomplete<'i>

fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI128Incomplete<'i>

fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI128Incomplete<'i>

fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromI128Incomplete<'i>

fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromI128Incomplete<'i>

impl DivRounding<Integer> for u8

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromU8Incomplete<'i>

fn div_trunc(self, rhs: &Integer) -> DivRoundingFromU8Incomplete<'_>

fn div_ceil(self, rhs: &Integer) -> DivRoundingFromU8Incomplete<'_>

fn div_floor(self, rhs: &Integer) -> DivRoundingFromU8Incomplete<'_>

fn div_euc(self, rhs: &Integer) -> DivRoundingFromU8Incomplete<'_>

impl DivRounding<Integer> for &u8

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromU8Incomplete<'i>

fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU8Incomplete<'i>

fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU8Incomplete<'i>

fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromU8Incomplete<'i>

fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromU8Incomplete<'i>

impl DivRounding<Integer> for u16

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromU16Incomplete<'i>

fn div_trunc(self, rhs: &Integer) -> DivRoundingFromU16Incomplete<'_>

fn div_ceil(self, rhs: &Integer) -> DivRoundingFromU16Incomplete<'_>

fn div_floor(self, rhs: &Integer) -> DivRoundingFromU16Incomplete<'_>

fn div_euc(self, rhs: &Integer) -> DivRoundingFromU16Incomplete<'_>

impl DivRounding<Integer> for &u16

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromU16Incomplete<'i>

fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU16Incomplete<'i>

fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU16Incomplete<'i>

fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromU16Incomplete<'i>

fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromU16Incomplete<'i>

impl DivRounding<Integer> for u32

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromU32Incomplete<'i>

fn div_trunc(self, rhs: &Integer) -> DivRoundingFromU32Incomplete<'_>

fn div_ceil(self, rhs: &Integer) -> DivRoundingFromU32Incomplete<'_>

fn div_floor(self, rhs: &Integer) -> DivRoundingFromU32Incomplete<'_>

fn div_euc(self, rhs: &Integer) -> DivRoundingFromU32Incomplete<'_>

impl DivRounding<Integer> for &u32

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromU32Incomplete<'i>

fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i>

fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i>

fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i>

fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i>

impl DivRounding<Integer> for u64

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromU64Incomplete<'i>

fn div_trunc(self, rhs: &Integer) -> DivRoundingFromU64Incomplete<'_>

fn div_ceil(self, rhs: &Integer) -> DivRoundingFromU64Incomplete<'_>

fn div_floor(self, rhs: &Integer) -> DivRoundingFromU64Incomplete<'_>

fn div_euc(self, rhs: &Integer) -> DivRoundingFromU64Incomplete<'_>

impl DivRounding<Integer> for &u64

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromU64Incomplete<'i>

fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU64Incomplete<'i>

fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU64Incomplete<'i>

fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromU64Incomplete<'i>

fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromU64Incomplete<'i>

impl DivRounding<Integer> for u128

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromU128Incomplete<'i>

fn div_trunc(self, rhs: &Integer) -> DivRoundingFromU128Incomplete<'_>

fn div_ceil(self, rhs: &Integer) -> DivRoundingFromU128Incomplete<'_>

fn div_floor(self, rhs: &Integer) -> DivRoundingFromU128Incomplete<'_>

fn div_euc(self, rhs: &Integer) -> DivRoundingFromU128Incomplete<'_>

impl DivRounding<Integer> for &u128

type Output = Integer

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

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

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

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

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

type Output = DivRoundingFromU128Incomplete<'i>

fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU128Incomplete<'i>

fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU128Incomplete<'i>

fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromU128Incomplete<'i>

fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromU128Incomplete<'i>

Loading content...

Implementors

impl DivRounding<&'_ i8> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<&'_ i16> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<&'_ i32> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<&'_ i64> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<&'_ i128> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<&'_ u8> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<&'_ u16> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<&'_ u32> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<&'_ u64> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<&'_ u128> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<&'_ Integer> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<i8> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<i16> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<i32> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<i64> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<i128> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<u8> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<u16> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<u32> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<u64> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<u128> for Integer

type Output = Integer

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

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

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

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

impl DivRounding<Integer> for &Integer

type Output = Integer

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

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

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

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

impl DivRounding<Integer> for Integer

type Output = Integer

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

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

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

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

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

type Output = DivRoundingIncomplete<'i>

fn div_trunc(self, rhs: &'i Integer) -> DivRoundingIncomplete<'_>

fn div_ceil(self, rhs: &'i Integer) -> DivRoundingIncomplete<'_>

fn div_floor(self, rhs: &'i Integer) -> DivRoundingIncomplete<'_>

fn div_euc(self, rhs: &'i Integer) -> DivRoundingIncomplete<'_>

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

type Output = DivRoundingI8Incomplete<'i>

fn div_trunc(self, rhs: i8) -> DivRoundingI8Incomplete<'i>

fn div_ceil(self, rhs: i8) -> DivRoundingI8Incomplete<'i>

fn div_floor(self, rhs: i8) -> DivRoundingI8Incomplete<'i>

fn div_euc(self, rhs: i8) -> DivRoundingI8Incomplete<'i>

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

type Output = DivRoundingI16Incomplete<'i>

fn div_trunc(self, rhs: i16) -> DivRoundingI16Incomplete<'i>

fn div_ceil(self, rhs: i16) -> DivRoundingI16Incomplete<'i>

fn div_floor(self, rhs: i16) -> DivRoundingI16Incomplete<'i>

fn div_euc(self, rhs: i16) -> DivRoundingI16Incomplete<'i>

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

type Output = DivRoundingI32Incomplete<'i>

fn div_trunc(self, rhs: i32) -> DivRoundingI32Incomplete<'i>

fn div_ceil(self, rhs: i32) -> DivRoundingI32Incomplete<'i>

fn div_floor(self, rhs: i32) -> DivRoundingI32Incomplete<'i>

fn div_euc(self, rhs: i32) -> DivRoundingI32Incomplete<'i>

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

type Output = DivRoundingI64Incomplete<'i>

fn div_trunc(self, rhs: i64) -> DivRoundingI64Incomplete<'i>

fn div_ceil(self, rhs: i64) -> DivRoundingI64Incomplete<'i>

fn div_floor(self, rhs: i64) -> DivRoundingI64Incomplete<'i>

fn div_euc(self, rhs: i64) -> DivRoundingI64Incomplete<'i>

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

type Output = DivRoundingI128Incomplete<'i>

fn div_trunc(self, rhs: i128) -> DivRoundingI128Incomplete<'i>

fn div_ceil(self, rhs: i128) -> DivRoundingI128Incomplete<'i>

fn div_floor(self, rhs: i128) -> DivRoundingI128Incomplete<'i>

fn div_euc(self, rhs: i128) -> DivRoundingI128Incomplete<'i>

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

type Output = DivRoundingU8Incomplete<'i>

fn div_trunc(self, rhs: u8) -> DivRoundingU8Incomplete<'i>

fn div_ceil(self, rhs: u8) -> DivRoundingU8Incomplete<'i>

fn div_floor(self, rhs: u8) -> DivRoundingU8Incomplete<'i>

fn div_euc(self, rhs: u8) -> DivRoundingU8Incomplete<'i>

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

type Output = DivRoundingU16Incomplete<'i>

fn div_trunc(self, rhs: u16) -> DivRoundingU16Incomplete<'i>

fn div_ceil(self, rhs: u16) -> DivRoundingU16Incomplete<'i>

fn div_floor(self, rhs: u16) -> DivRoundingU16Incomplete<'i>

fn div_euc(self, rhs: u16) -> DivRoundingU16Incomplete<'i>

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

type Output = DivRoundingU32Incomplete<'i>

fn div_trunc(self, rhs: u32) -> DivRoundingU32Incomplete<'i>

fn div_ceil(self, rhs: u32) -> DivRoundingU32Incomplete<'i>

fn div_floor(self, rhs: u32) -> DivRoundingU32Incomplete<'i>

fn div_euc(self, rhs: u32) -> DivRoundingU32Incomplete<'i>

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

type Output = DivRoundingU64Incomplete<'i>

fn div_trunc(self, rhs: u64) -> DivRoundingU64Incomplete<'i>

fn div_ceil(self, rhs: u64) -> DivRoundingU64Incomplete<'i>

fn div_floor(self, rhs: u64) -> DivRoundingU64Incomplete<'i>

fn div_euc(self, rhs: u64) -> DivRoundingU64Incomplete<'i>

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

type Output = DivRoundingU128Incomplete<'i>

fn div_trunc(self, rhs: u128) -> DivRoundingU128Incomplete<'i>

fn div_ceil(self, rhs: u128) -> DivRoundingU128Incomplete<'i>

fn div_floor(self, rhs: u128) -> DivRoundingU128Incomplete<'i>

fn div_euc(self, rhs: u128) -> DivRoundingU128Incomplete<'i>

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

type Output = DivRoundingI8Incomplete<'i>

fn div_trunc(self, rhs: &i8) -> DivRoundingI8Incomplete<'i>

fn div_ceil(self, rhs: &i8) -> DivRoundingI8Incomplete<'i>

fn div_floor(self, rhs: &i8) -> DivRoundingI8Incomplete<'i>

fn div_euc(self, rhs: &i8) -> DivRoundingI8Incomplete<'i>

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

type Output = DivRoundingI16Incomplete<'i>

fn div_trunc(self, rhs: &i16) -> DivRoundingI16Incomplete<'i>

fn div_ceil(self, rhs: &i16) -> DivRoundingI16Incomplete<'i>

fn div_floor(self, rhs: &i16) -> DivRoundingI16Incomplete<'i>

fn div_euc(self, rhs: &i16) -> DivRoundingI16Incomplete<'i>

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

type Output = DivRoundingI32Incomplete<'i>

fn div_trunc(self, rhs: &i32) -> DivRoundingI32Incomplete<'i>

fn div_ceil(self, rhs: &i32) -> DivRoundingI32Incomplete<'i>

fn div_floor(self, rhs: &i32) -> DivRoundingI32Incomplete<'i>

fn div_euc(self, rhs: &i32) -> DivRoundingI32Incomplete<'i>

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

type Output = DivRoundingI64Incomplete<'i>

fn div_trunc(self, rhs: &i64) -> DivRoundingI64Incomplete<'i>

fn div_ceil(self, rhs: &i64) -> DivRoundingI64Incomplete<'i>

fn div_floor(self, rhs: &i64) -> DivRoundingI64Incomplete<'i>

fn div_euc(self, rhs: &i64) -> DivRoundingI64Incomplete<'i>

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

type Output = DivRoundingI128Incomplete<'i>

fn div_trunc(self, rhs: &i128) -> DivRoundingI128Incomplete<'i>

fn div_ceil(self, rhs: &i128) -> DivRoundingI128Incomplete<'i>

fn div_floor(self, rhs: &i128) -> DivRoundingI128Incomplete<'i>

fn div_euc(self, rhs: &i128) -> DivRoundingI128Incomplete<'i>

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

type Output = DivRoundingU8Incomplete<'i>

fn div_trunc(self, rhs: &u8) -> DivRoundingU8Incomplete<'i>

fn div_ceil(self, rhs: &u8) -> DivRoundingU8Incomplete<'i>

fn div_floor(self, rhs: &u8) -> DivRoundingU8Incomplete<'i>

fn div_euc(self, rhs: &u8) -> DivRoundingU8Incomplete<'i>

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

type Output = DivRoundingU16Incomplete<'i>

fn div_trunc(self, rhs: &u16) -> DivRoundingU16Incomplete<'i>

fn div_ceil(self, rhs: &u16) -> DivRoundingU16Incomplete<'i>

fn div_floor(self, rhs: &u16) -> DivRoundingU16Incomplete<'i>

fn div_euc(self, rhs: &u16) -> DivRoundingU16Incomplete<'i>

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

type Output = DivRoundingU32Incomplete<'i>

fn div_trunc(self, rhs: &u32) -> DivRoundingU32Incomplete<'i>

fn div_ceil(self, rhs: &u32) -> DivRoundingU32Incomplete<'i>

fn div_floor(self, rhs: &u32) -> DivRoundingU32Incomplete<'i>

fn div_euc(self, rhs: &u32) -> DivRoundingU32Incomplete<'i>

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

type Output = DivRoundingU64Incomplete<'i>

fn div_trunc(self, rhs: &u64) -> DivRoundingU64Incomplete<'i>

fn div_ceil(self, rhs: &u64) -> DivRoundingU64Incomplete<'i>

fn div_floor(self, rhs: &u64) -> DivRoundingU64Incomplete<'i>

fn div_euc(self, rhs: &u64) -> DivRoundingU64Incomplete<'i>

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

type Output = DivRoundingU128Incomplete<'i>

fn div_trunc(self, rhs: &u128) -> DivRoundingU128Incomplete<'i>

fn div_ceil(self, rhs: &u128) -> DivRoundingU128Incomplete<'i>

fn div_floor(self, rhs: &u128) -> DivRoundingU128Incomplete<'i>

fn div_euc(self, rhs: &u128) -> DivRoundingU128Incomplete<'i>

Loading content...