Trait rug::ops::DivRounding

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

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

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

Required Associated Types§

source

type Output

The resulting type from the division operation.

Required Methods§

source

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

Performs division, rounding the quotient towards zero.

source

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

Performs division, rounding the quotient up.

source

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

Performs division, rounding the quotient down.

source

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§

source§

impl DivRounding<Integer> for &i32

source§

impl DivRounding<&f32> for f32

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&i128> for i128

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<usize> for usize

§

type Output = usize

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for &u128

source§

impl DivRounding<u32> for &u32

§

type Output = <u32 as DivRounding<u32>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for u32

source§

impl DivRounding<&f64> for &f64

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<f64> for &f64

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<i8> for &i8

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for u64

source§

impl DivRounding<i8> for i8

§

type Output = i8

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&usize> for usize

§

type Output = <usize as DivRounding<usize>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromU8Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&u8> for &u8

§

type Output = <u8 as DivRounding<u8>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromI64Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for &i128

source§

impl DivRounding<Integer> for &u64

source§

impl DivRounding<&u128> for u128

§

type Output = <u128 as DivRounding<u128>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&i32> for i32

§

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

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromU128Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&u128> for &u128

§

type Output = <u128 as DivRounding<u128>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&isize> for isize

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<isize> for &isize

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&f64> for f64

§

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

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromI128Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&u64> for &u64

§

type Output = <u64 as DivRounding<u64>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&i64> for i64

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<u16> for u16

§

type Output = u16

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<u64> for u64

§

type Output = u64

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&i64> for &i64

§

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

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromU64Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for i8

source§

impl DivRounding<Integer> for &u16

source§

impl DivRounding<Integer> for &i8

source§

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

§

type Output = DivRoundingFromI128Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<i16> for i16

§

type Output = i16

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<f32> for f32

§

type Output = f32

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromU64Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&u32> for u32

§

type Output = <u32 as DivRounding<u32>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<i32> for i32

§

type Output = i32

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<i128> for &i128

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<f64> for f64

§

type Output = f64

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&u16> for &u16

§

type Output = <u16 as DivRounding<u16>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&i16> for &i16

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<i32> for &i32

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&isize> for &isize

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&i32> for &i32

§

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

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromI8Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for &u32

source§

impl DivRounding<i16> for &i16

§

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

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromI16Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for &u8

source§

impl DivRounding<i128> for i128

§

type Output = i128

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<u128> for u128

§

type Output = u128

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<i64> for i64

§

type Output = i64

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&u32> for &u32

§

type Output = <u32 as DivRounding<u32>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for i32

source§

impl DivRounding<isize> for isize

§

type Output = isize

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<u8> for u8

§

type Output = u8

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<u32> for u32

§

type Output = u32

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for i64

source§

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

§

type Output = DivRoundingFromI32Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for u16

source§

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

§

type Output = DivRoundingFromU128Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for i128

source§

impl DivRounding<&f32> for &f32

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for &i16

source§

impl DivRounding<&i8> for i8

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<i64> for &i64

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<u8> for &u8

§

type Output = <u8 as DivRounding<u8>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromI8Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for &i64

source§

impl DivRounding<&i16> for i16

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<u16> for &u16

§

type Output = <u16 as DivRounding<u16>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for u8

source§

impl DivRounding<u64> for &u64

§

type Output = <u64 as DivRounding<u64>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromI16Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromI64Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&u8> for u8

§

type Output = <u8 as DivRounding<u8>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for u128

source§

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

§

type Output = DivRoundingFromU8Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&usize> for &usize

§

type Output = <usize as DivRounding<usize>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<f32> for &f32

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<Integer> for i16

source§

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

§

type Output = DivRoundingFromU16Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<u128> for &u128

§

type Output = <u128 as DivRounding<u128>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromU16Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&u16> for u16

§

type Output = <u16 as DivRounding<u16>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromU32Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<usize> for &usize

§

type Output = <usize as DivRounding<usize>>::Output

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromI32Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&i128> for &i128

§

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

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&u64> for u64

§

type Output = <u64 as DivRounding<u64>>::Output

source§

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

source§

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

source§

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

source§

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

source§

impl DivRounding<&i8> for &i8

§

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

source§

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

source§

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

source§

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

source§

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

source§

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

§

type Output = DivRoundingFromU32Incomplete<'i>

source§

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

source§

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

source§

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

source§

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

Implementors§

source§

impl DivRounding<&i8> for Integer

source§

impl DivRounding<&i16> for Integer

source§

impl DivRounding<&i32> for Integer

source§

impl DivRounding<&i64> for Integer

source§

impl DivRounding<&i128> for Integer

source§

impl DivRounding<&u8> for Integer

source§

impl DivRounding<&u16> for Integer

source§

impl DivRounding<&u32> for Integer

source§

impl DivRounding<&u64> for Integer

source§

impl DivRounding<&u128> for Integer

source§

impl DivRounding<&Integer> for Integer

source§

impl DivRounding<i8> for Integer

source§

impl DivRounding<i16> for Integer

source§

impl DivRounding<i32> for Integer

source§

impl DivRounding<i64> for Integer

source§

impl DivRounding<i128> for Integer

source§

impl DivRounding<u8> for Integer

source§

impl DivRounding<u16> for Integer

source§

impl DivRounding<u32> for Integer

source§

impl DivRounding<u64> for Integer

source§

impl DivRounding<u128> for Integer

source§

impl DivRounding<Integer> for &Integer

source§

impl DivRounding<Integer> for Integer

source§

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

§

type Output = DivRoundingIncomplete<'i>

source§

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

§

type Output = DivRoundingI8Incomplete<'i>

source§

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

§

type Output = DivRoundingI16Incomplete<'i>

source§

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

§

type Output = DivRoundingI32Incomplete<'i>

source§

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

§

type Output = DivRoundingI64Incomplete<'i>

source§

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

§

type Output = DivRoundingI128Incomplete<'i>

source§

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

§

type Output = DivRoundingU8Incomplete<'i>

source§

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

§

type Output = DivRoundingU16Incomplete<'i>

source§

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

§

type Output = DivRoundingU32Incomplete<'i>

source§

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

§

type Output = DivRoundingU64Incomplete<'i>

source§

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

§

type Output = DivRoundingU128Incomplete<'i>

source§

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

§

type Output = DivRoundingI8Incomplete<'i>

source§

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

§

type Output = DivRoundingI16Incomplete<'i>

source§

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

§

type Output = DivRoundingI32Incomplete<'i>

source§

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

§

type Output = DivRoundingI64Incomplete<'i>

source§

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

§

type Output = DivRoundingI128Incomplete<'i>

source§

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

§

type Output = DivRoundingU8Incomplete<'i>

source§

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

§

type Output = DivRoundingU16Incomplete<'i>

source§

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

§

type Output = DivRoundingU32Incomplete<'i>

source§

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

§

type Output = DivRoundingU64Incomplete<'i>

source§

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

§

type Output = DivRoundingU128Incomplete<'i>