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.

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.

Implementations on Foreign Types

impl DivRounding 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<'a> DivRounding<&'a 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<'a> DivRounding<i8> for &'a 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<'a, 'b> DivRounding<&'a i8> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<i16> for &'a 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<'a, 'b> DivRounding<&'a i16> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<i32> for &'a 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<'a, 'b> DivRounding<&'a i32> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<i64> for &'a 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<'a, 'b> DivRounding<&'a i64> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<isize> for &'a 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<'a, 'b> DivRounding<&'a isize> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<i128> for &'a 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<'a, 'b> DivRounding<&'a i128> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<u8> for &'a 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<'a, 'b> DivRounding<&'a u8> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<u16> for &'a 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<'a, 'b> DivRounding<&'a u16> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<u32> for &'a 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<'a, 'b> DivRounding<&'a u32> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<u64> for &'a 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<'a, 'b> DivRounding<&'a u64> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<usize> for &'a 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<'a, 'b> DivRounding<&'a usize> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<u128> for &'a 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<'a, 'b> DivRounding<&'a u128> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<f32> for &'a 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<'a, 'b> DivRounding<&'a f32> for &'b 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 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<'a> DivRounding<&'a 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<'a> DivRounding<f64> for &'a 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<'a, 'b> DivRounding<&'a f64> for &'b 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<'t> DivRounding<Integer> for &'t 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, 't> DivRounding<&'i Integer> for &'t 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<'t> DivRounding<Integer> for &'t 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, 't> DivRounding<&'i Integer> for &'t 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>

Implementors

• impl DivRounding for Integer type Output = Integer;
• impl<'i> DivRounding<&'i Integer> for Integer type Output = Integer;
• impl<'i> DivRounding<Integer> for &'i Integer type Output = Integer;
• impl<'i> DivRounding for &'i Integer type Output = DivRoundingIncomplete<'i>;
• impl DivRounding<i32> for Integer type Output = Integer;
• impl<'t> DivRounding<&'t i32> for Integer type Output = Integer;
• impl<'i> DivRounding<i32> for &'i Integer type Output = DivRoundingI32Incomplete<'i>;
• impl<'t, 'i> DivRounding<&'t i32> for &'i Integer type Output = DivRoundingI32Incomplete<'i>;
• impl DivRounding<u32> for Integer type Output = Integer;
• impl<'t> DivRounding<&'t u32> for Integer type Output = Integer;
• impl<'i> DivRounding<u32> for &'i Integer type Output = DivRoundingU32Incomplete<'i>;
• impl<'t, 'i> DivRounding<&'t u32> for &'i Integer type Output = DivRoundingU32Incomplete<'i>;