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

Loading content...

Implementors

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<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<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<&'_ 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<&'_ 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<&'_ 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<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<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 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 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>

Loading content...