Struct rug::Integer

pub struct Integer { /* private fields */ }

An arbitrary-precision integer.

Standard arithmetic operations, bitwise operations and comparisons are supported. In standard arithmetic operations such as addition, you can mix Integer and primitive integer types; the result will be an Integer.

Internally the integer is not stored using a two’s-complement representation, however, for bitwise operations and shifts, the functionality is the same as if the representation was using two’s complement.

Examples

use rug::{Assign, Integer};
// Create an integer initialized as zero.
let mut int = Integer::new();
assert_eq!(int, 0);
assert_eq!(int.to_u32(), Some(0));
int.assign(-14);
assert_eq!(int, -14);
assert_eq!(int.to_u32(), None);
assert_eq!(int.to_i32(), Some(-14));

Arithmetic operations with mixed arbitrary and primitive types are allowed. Note that in the following example, there is only one allocation. The Integer instance is moved into the shift operation so that the result can be stored in the same instance, then that result is similarly consumed by the addition operation.

use rug::Integer;
let mut a = Integer::from(0xc);
a = (a << 80) + 0xffee;
assert_eq!(a.to_string_radix(16), "c0000000000000000ffee");
//                                 ↑   ↑   ↑   ↑   ↑   ↑
//                                80  64  48  32  16   0

Bitwise operations on Integer values behave as if the value uses a two’s-complement representation.

use rug::Integer;

let mut i = Integer::from(1);
i = i << 1000;
// i is now 1000000... (1000 zeros)
assert_eq!(i.significant_bits(), 1001);
assert_eq!(i.find_one(0), Some(1000));
i -= 1;
// i is now 111111... (1000 ones)
assert_eq!(i.count_ones(), Some(1000));

let a = Integer::from(0xf00d);
// -1 is all ones in two’s complement
let all_ones_xor_a = Integer::from(-1 ^ &a);
// a is unchanged as we borrowed it
let complement_a = !a;
// now a has been moved, so this would cause an error:
// assert!(a > 0);
assert_eq!(all_ones_xor_a, complement_a);
assert_eq!(complement_a, -0xf00e);
assert_eq!(format!("{:x}", complement_a), "-f00e");

To initialize a large Integer that does not fit in a primitive type, you can parse a string.

use rug::Integer;
let s1 = "123456789012345678901234567890";
let i1 = s1.parse::<Integer>().unwrap();
assert_eq!(i1.significant_bits(), 97);
let s2 = "ffff0000ffff0000ffff0000ffff0000ffff0000";
let i2 = Integer::from_str_radix(s2, 16).unwrap();
assert_eq!(i2.significant_bits(), 160);
assert_eq!(i2.count_ones(), Some(80));

Operations on two borrowed Integer values result in an incomplete-computation value that has to be assigned to a new Integer value.

use rug::Integer;
let a = Integer::from(10);
let b = Integer::from(3);
let a_b_ref = &a + &b;
let a_b = Integer::from(a_b_ref);
assert_eq!(a_b, 13);

As a special case, when an incomplete-computation value is obtained from multiplying two Integer references, it can be added to or subtracted from another Integer (or reference). This can be useful for multiply-accumulate operations.

use rug::Integer;
let mut acc = Integer::from(100);
let m1 = Integer::from(3);
let m2 = Integer::from(7);
// 100 + 3 × 7 = 121
acc += &m1 * &m2;
assert_eq!(acc, 121);
let other = Integer::from(2000);
// Do not consume any values here:
// 2000 - 3 × 7 = 1979
let sub = Integer::from(&other - &m1 * &m2);
assert_eq!(sub, 1979);

The Integer type supports various functions. Most methods have three versions:

1. The first method consumes the operand.
2. The second method has a “_mut” suffix and mutates the operand.
3. The third method has a “_ref” suffix and borrows the operand. The returned item is an incomplete-computation value that can be assigned to an Integer.

use rug::Integer;

// 1. consume the operand
let a = Integer::from(-15);
let abs_a = a.abs();
assert_eq!(abs_a, 15);

// 2. mutate the operand
let mut b = Integer::from(-16);
b.abs_mut();
assert_eq!(b, 16);

// 3. borrow the operand
let c = Integer::from(-17);
let r = c.abs_ref();
let abs_c = Integer::from(r);
assert_eq!(abs_c, 17);
// c was not consumed
assert_eq!(c, -17);

Implementations

impl Integer

pub const ZERO: Integer = _

Zero.

Examples

use rug::Integer;
assert_eq!(Integer::ZERO, 0);

pub const ONE: &'static Integer = _

One.

Examples

use rug::Integer;
assert_eq!(*Integer::ONE, 1);

pub const NEG_ONE: &'static Integer = _

Negative one (−1).

Examples

use rug::Integer;
assert_eq!(*Integer::NEG_ONE, -1);

pub const fn new() -> Self

Constructs a new arbitrary-precision Integer with value 0.

The created Integer will have no allocated memory yet.

Examples

use rug::Integer;
let i = Integer::new();
assert_eq!(i, 0);

pub fn with_capacity(bits: usize) -> Self

Constructs a new arbitrary-precision Integer with at least the specified capacity.

Examples

use rug::Integer;
let i = Integer::with_capacity(137);
assert!(i.capacity() >= 137);

pub fn capacity(&self) -> usize

Returns the capacity in bits that can be stored without reallocating.

Examples

use rug::Integer;
let i = Integer::with_capacity(137);
assert!(i.capacity() >= 137);

pub fn reserve(&mut self, additional: usize)

Reserves capacity for at least additional more bits in the Integer.

If the integer already has enough excess capacity, this function does nothing.

Examples

use rug::Integer;
// 0x2000_0000 needs 30 bits.
let mut i = Integer::from(0x2000_0000);
assert_eq!(i.significant_bits(), 30);
i.reserve(290);
let capacity = i.capacity();
assert!(capacity >= 320);
i.reserve(0);
assert_eq!(i.capacity(), capacity);
i.reserve(291);
assert!(i.capacity() >= 321);

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the Integer as much as possible.

The capacity can still be larger than the number of significant bits.

Examples

use rug::Integer;
// let i be 100 bits wide
let mut i = Integer::from_str_radix("fffff12345678901234567890", 16)
    .unwrap();
assert_eq!(i.significant_bits(), 100);
assert!(i.capacity() >= 100);
i >>= 80;
i.shrink_to_fit();
assert!(i.capacity() >= 20);

pub fn shrink_to(&mut self, min_capacity: usize)

Shrinks the capacity of the Integer with a lower bound in bits.

The capacity will remain at least as large as both the current number of siginificant bits and the supplied value.

If the current capacity is less than the lower limit, this method has no effect.

Examples

use rug::Integer;
// let i be 100 bits wide
let mut i = Integer::from_str_radix("fffff12345678901234567890", 16)
    .unwrap();
assert_eq!(i.significant_bits(), 100);
assert!(i.capacity() >= 100);
i >>= 80;
i.shrink_to(50);
assert!(i.capacity() >= 50);
i.shrink_to(0);
assert!(i.capacity() >= 20);

pub const unsafe fn from_raw(raw: mpz_t) -> Self

Creates an Integer from an initialized GMP integer.

Safety

• The function must not be used to create a constant Integer, though it can be used to create a static Integer. This is because constant values are copied on use, leading to undefined behavior when they are dropped.
• The value must be initialized as a valid mpz_t.
• The mpz_t type can be considered as a kind of pointer, so there can be multiple copies of it. Since this function takes over ownership, no other copies of the passed value should exist.

Examples

use core::mem::MaybeUninit;
use gmp_mpfr_sys::gmp;
use rug::Integer;
let i = unsafe {
    let mut z = MaybeUninit::uninit();
    gmp::mpz_init_set_ui(z.as_mut_ptr(), 15);
    let z = z.assume_init();
    // z is initialized and unique
    Integer::from_raw(z)
};
assert_eq!(i, 15);
// since i is an Integer now, deallocation is automatic

This can be used to create a static Integer using MPZ_ROINIT_N to initialize the raw value. See the GMP documentation for details.

use gmp_mpfr_sys::gmp;
use gmp_mpfr_sys::gmp::{limb_t, mpz_t};
use rug::Integer;
const LIMBS: [limb_t; 2] = [123, 456];
const MPZ: mpz_t =
    unsafe { gmp::MPZ_ROINIT_N(LIMBS.as_ptr().cast_mut(), -2) };
// Must *not* be const, otherwise it would lead to undefined
// behavior on use, as it would create a copy that is dropped.
static I: Integer = unsafe { Integer::from_raw(MPZ) };
let check = -((Integer::from(LIMBS[1]) << gmp::NUMB_BITS) + LIMBS[0]);
assert_eq!(I, check);

pub const fn into_raw(self) -> mpz_t

Converts an Integer into a GMP integer.

The returned object should be freed to avoid memory leaks.

Examples

use gmp_mpfr_sys::gmp;
use rug::Integer;
let i = Integer::from(15);
let mut z = i.into_raw();
unsafe {
    let u = gmp::mpz_get_ui(&z);
    assert_eq!(u, 15);
    // free object to prevent memory leak
    gmp::mpz_clear(&mut z);
}

pub const fn as_raw(&self) -> *const mpz_t

Returns a pointer to the inner GMP integer.

The returned pointer will be valid for as long as self is valid.

Examples

use gmp_mpfr_sys::gmp;
use rug::Integer;
let i = Integer::from(15);
let z_ptr = i.as_raw();
unsafe {
    let u = gmp::mpz_get_ui(z_ptr);
    assert_eq!(u, 15);
}
// i is still valid
assert_eq!(i, 15);

pub fn as_raw_mut(&mut self) -> *mut mpz_t

Returns an unsafe mutable pointer to the inner GMP integer.

The returned pointer will be valid for as long as self is valid.

Examples

use gmp_mpfr_sys::gmp;
use rug::Integer;
let mut i = Integer::from(15);
let z_ptr = i.as_raw_mut();
unsafe {
    gmp::mpz_add_ui(z_ptr, z_ptr, 20);
}
assert_eq!(i, 35);

pub fn from_digits<T: UnsignedPrimitive>(digits: &[T], order: Order) -> Self

Creates an Integer from a slice of digits of type T, where T can be any unsigned integer primitive type.

The resulting value cannot be negative.

Examples

use rug::integer::Order;
use rug::Integer;
let digits = [0x5678u16, 0x1234u16];
let i = Integer::from_digits(&digits, Order::Lsf);
assert_eq!(i, 0x1234_5678);

pub fn assign_digits<T: UnsignedPrimitive>( &mut self, digits: &[T], order: Order )

Assigns from a slice of digits of type T, where T can be any unsigned integer primitive type.

The resulting value cannot be negative.

Examples

use rug::integer::Order;
use rug::Integer;
let digits = [0x5678u16, 0x1234u16];
let mut i = Integer::new();
i.assign_digits(&digits, Order::Lsf);
assert_eq!(i, 0x1234_5678);

pub unsafe fn assign_digits_unaligned<T: UnsignedPrimitive>( &mut self, src: *const T, len: usize, order: Order )

Assigns from digits of type T in a memory area, where T can be any unsigned integer primitive type.

The memory area is addressed using a pointer and a length. The len parameter is the number of digits, not the number of bytes.

There are no data alignment restrictions on src, any address is allowed.

The resulting value cannot be negative.

Safety

To avoid undefined behavior, src must be valid for reading len digits, that is len × size_of::<T>() bytes.

Examples

use rug::integer::Order;
use rug::Integer;
// hex bytes: [ fe dc ba 98 87 87 87 87 76 54 32 10 ]
let digits = [
    0xfedc_ba98u32.to_be(),
    0x8787_8787u32.to_be(),
    0x7654_3210u32.to_be(),
];
let ptr = digits.as_ptr();
let mut i = Integer::new();
unsafe {
    let unaligned = (ptr.cast::<u8>()).offset(2).cast::<u32>();
    i.assign_digits_unaligned(unaligned, 2, Order::MsfBe);
}
assert_eq!(i, 0xba98_8787_8787_7654u64);

pub fn significant_digits<T: UnsignedPrimitive>(&self) -> usize

Returns the number of digits of type T required to represent the absolute value.

T can be any unsigned integer primitive type.

Examples

use rug::Integer;

let i: Integer = Integer::from(1) << 256;
assert_eq!(i.significant_digits::<bool>(), 257);
assert_eq!(i.significant_digits::<u8>(), 33);
assert_eq!(i.significant_digits::<u16>(), 17);
assert_eq!(i.significant_digits::<u32>(), 9);
assert_eq!(i.significant_digits::<u64>(), 5);

pub fn to_digits<T: UnsignedPrimitive>(&self, order: Order) -> Vec<T>

Converts the absolute value to a Vec of digits of type T, where T can be any unsigned integer primitive type.

The Integer type also has the as_limbs method, which can be used to borrow the digits without copying them. This does come with some more constraints compared to to_digits:

1. The digit width is not optional and depends on the implementation: limb_t is typically u64 on 64-bit systems and u32 on 32-bit systems.
2. The order is not optional and is least significant digit first, with each digit in the target’s endianness, equivalent to Order::Lsf.

Examples

use rug::integer::Order;
use rug::Integer;
let i = Integer::from(0x1234_5678_9abc_def0u64);
let digits = i.to_digits::<u32>(Order::MsfBe);
assert_eq!(digits, [0x1234_5678u32.to_be(), 0x9abc_def0u32.to_be()]);

let zero = Integer::new();
let digits_zero = zero.to_digits::<u32>(Order::MsfBe);
assert!(digits_zero.is_empty());

pub fn write_digits<T: UnsignedPrimitive>(&self, digits: &mut [T], order: Order)

Writes the absolute value into a slice of digits of type T, where T can be any unsigned integer primitive type.

The slice must be large enough to hold the digits; the minimum size can be obtained using the significant_digits method.

Panics

Panics if the slice does not have sufficient capacity.

Examples

use rug::integer::Order;
use rug::Integer;
let i = Integer::from(0x1234_5678_9abc_def0u64);
let mut digits = [0xffff_ffffu32; 4];
i.write_digits(&mut digits, Order::MsfBe);
let word0 = 0x9abc_def0u32;
let word1 = 0x1234_5678u32;
assert_eq!(digits, [0, 0, word1.to_be(), word0.to_be()]);

pub unsafe fn write_digits_unaligned<T: UnsignedPrimitive>( &self, dst: *mut T, len: usize, order: Order )

Writes the absolute value into a memory area of digits of type T, where T can be any unsigned integer primitive type.

The memory area is addressed using a pointer and a length. The len parameter is the number of digits, not the number of bytes.

The length must be large enough to hold the digits; the minimum length can be obtained using the significant_digits method.

There are no data alignment restrictions on dst, any address is allowed.

The memory locations can be uninitialized before this method is called; this method sets all len elements, padding with zeros if the length is larger than required.

Safety

To avoid undefined behavior, dst must be valid for writing len digits, that is len × size_of::<T>() bytes.

Panics

Panics if the length is less than the number of digits.

Examples

use rug::integer::Order;
use rug::Integer;
let i = Integer::from(0xfedc_ba98_7654_3210u64);
let mut digits = [0xffff_ffffu32; 4];
let ptr = digits.as_mut_ptr();
unsafe {
    let unaligned = (ptr.cast::<u8>()).offset(2).cast::<u32>();
    i.write_digits_unaligned(unaligned, 3, Order::MsfBe);
}
assert_eq!(
    digits,
    [
        0xffff_0000u32.to_be(),
        0x0000_fedcu32.to_be(),
        0xba98_7654u32.to_be(),
        0x3210_ffffu32.to_be(),
    ]
);

The following example shows how to write into uninitialized memory. In practice, the following code could be replaced by a call to the safe method to_digits.

use rug::integer::Order;
use rug::Integer;
let i = Integer::from(0x1234_5678_9abc_def0u64);
let len = i.significant_digits::<u32>();
assert_eq!(len, 2);

// The following code is equivalent to:
//     let digits = i.to_digits::<u32>(Order::MsfBe);
let mut digits = Vec::<u32>::with_capacity(len);
let ptr = digits.as_mut_ptr();
unsafe {
    i.write_digits_unaligned(ptr, len, Order::MsfBe);
    digits.set_len(len);
}

assert_eq!(digits, [0x1234_5678u32.to_be(), 0x9abc_def0u32.to_be()]);

pub const fn as_limbs(&self) -> &[limb_t]

Extracts a slice of limbs used to store the value.

The slice contains the absolute value of self, with the least significant limb first.

The Integer type also implements AsRef<[limb_t]>, which is equivalent to this method.

Examples

use rug::Integer;
assert!(Integer::new().as_limbs().is_empty());
assert_eq!(Integer::from(13).as_limbs(), &[13]);
assert_eq!(Integer::from(-23).as_limbs(), &[23]);

int.as_limbs() is like a borrowing non-copy version of int.to_digits::<[limb_t]>(Order::Lsf).

use gmp_mpfr_sys::gmp::limb_t;
use rug::integer::Order;
use rug::Integer;
let int = Integer::from(0x1234_5678_9abc_def0u64);
// no copying for int_slice, which is borrowing int
let int_slice = int.as_limbs();
// digits is a copy and does not borrow int
let digits = int.to_digits::<limb_t>(Order::Lsf);
// no copying for digits_slice, which is borrowing digits
let digits_slice = &digits[..];
assert_eq!(int_slice, digits_slice);

pub fn from_f32(value: f32) -> Option<Self>

Creates an Integer from an f32 if it is finite, rounding towards zero.

This conversion can also be performed using value.checked_as::<Integer>().

Examples

use rug::Integer;
let i = Integer::from_f32(-5.6).unwrap();
assert_eq!(i, -5);
let neg_inf = Integer::from_f32(f32::NEG_INFINITY);
assert!(neg_inf.is_none());

pub fn from_f64(value: f64) -> Option<Self>

Creates an Integer from an f64 if it is finite, rounding towards zero.

This conversion can also be performed using value.checked_as::<Integer>().

Examples

use rug::Integer;
let i = Integer::from_f64(1e20).unwrap();
assert_eq!(i, "100000000000000000000".parse::<Integer>().unwrap());
let inf = Integer::from_f64(f64::INFINITY);
assert!(inf.is_none());

pub fn from_str_radix(src: &str, radix: i32) -> Result<Self, ParseIntegerError>

Parses an Integer using the given radix.

Panics

Panics if radix is less than 2 or greater than 36.

Examples

use rug::Integer;
let i = Integer::from_str_radix("-ff", 16).unwrap();
assert_eq!(i, -0xff);

pub fn parse<S: AsRef<[u8]>>( src: S ) -> Result<ParseIncomplete, ParseIntegerError>

Parses a decimal string slice (&str) or byte slice (&[u8]) into an Integer.

The following are implemented with the unwrapped returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

The string can start with an optional minus or plus sign. ASCII whitespace is ignored everywhere in the string. Underscores anywhere except before the first digit are ignored as well.

Examples

use rug::{Complete, Integer};

assert_eq!(Integer::parse("1223").unwrap().complete(), 1223);
assert_eq!(Integer::parse("123 456 789").unwrap().complete(), 123_456_789);

let invalid = Integer::parse("789a");
assert!(invalid.is_err());

pub fn parse_radix<S: AsRef<[u8]>>( src: S, radix: i32 ) -> Result<ParseIncomplete, ParseIntegerError>

Parses a string slice (&str) or byte slice (&[u8]) into an Integer.

The following are implemented with the unwrapped returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

The string can start with an optional minus or plus sign. ASCII whitespace is ignored everywhere in the string. Underscores anywhere except before the first digit are ignored as well.

See also assign_bytes_radix_unchecked, which is an unsafe low-level method that can be used if parsing is already done by an external function.

Panics

Panics if radix is less than 2 or greater than 36.

Examples

use rug::{Complete, Integer};

let valid1 = Integer::parse_radix("1223", 4);
assert_eq!(valid1.unwrap().complete(), 3 + 4 * (2 + 4 * (2 + 4 * 1)));
let valid2 = Integer::parse_radix("1234 abcd", 16);
assert_eq!(valid2.unwrap().complete(), 0x1234_abcd);

let invalid = Integer::parse_radix("123", 3);
assert!(invalid.is_err());

pub unsafe fn assign_bytes_radix_unchecked( &mut self, bytes: &[u8], radix: i32, is_negative: bool )

Assigns from bytes in the given radix.

The radix must be between 2 and 256 inclusive.

Each byte must be a value from 0 to radix - 1, not an ASCII character. The bytes must be ordered most-significant byte first.

If is_negative is true, the returned value is negative (unless it is 0).

Safety

The caller must ensure that

• 2 ≤ radix ≤ 256
• all bytes are in the range 0 ≤ x < radix

Examples

use rug::Integer;
let bytes = &[0, 3, 9, 2];
let radix = 10;
let neg = true;
let mut i = Integer::new();
// SAFETY: radix and bytes are in the required ranges
unsafe {
    i.assign_bytes_radix_unchecked(bytes, radix, neg);
}
assert_eq!(i, -392);

pub fn to_i8(&self) -> Option<i8>

Converts to an i8 if the value fits.

This conversion can also be performed using

• i8::try_from(&integer)
• i8::try_from(integer)
• (&integer).checked_as::<i8>()
• integer.borrow().checked_as::<i8>()
• integer.checked_as::<i8>()

Examples

use rug::Integer;
let fits = Integer::from(-100);
assert_eq!(fits.to_i8(), Some(-100));
let small = Integer::from(-200);
assert_eq!(small.to_i8(), None);
let large = Integer::from(200);
assert_eq!(large.to_i8(), None);

pub fn to_i16(&self) -> Option<i16>

Converts to an i16 if the value fits.

This conversion can also be performed using

• i16::try_from(&integer)
• i16::try_from(integer)
• (&integer).checked_as::<i16>()
• integer.borrow().checked_as::<i16>()
• integer.checked_as::<i16>()

Examples

use rug::Integer;
let fits = Integer::from(-30_000);
assert_eq!(fits.to_i16(), Some(-30_000));
let small = Integer::from(-40_000);
assert_eq!(small.to_i16(), None);
let large = Integer::from(40_000);
assert_eq!(large.to_i16(), None);

pub fn to_i32(&self) -> Option<i32>

Converts to an i32 if the value fits.

This conversion can also be performed using

• i32::try_from(&integer)
• i32::try_from(integer)
• (&integer).checked_as::<i32>()
• integer.borrow().checked_as::<i32>()
• integer.checked_as::<i32>()

Examples

use rug::Integer;
let fits = Integer::from(-50);
assert_eq!(fits.to_i32(), Some(-50));
let small = Integer::from(-123456789012345_i64);
assert_eq!(small.to_i32(), None);
let large = Integer::from(123456789012345_i64);
assert_eq!(large.to_i32(), None);

pub fn to_i64(&self) -> Option<i64>

Converts to an i64 if the value fits.

This conversion can also be performed using

• i64::try_from(&integer)
• i64::try_from(integer)
• (&integer).checked_as::<i64>()
• integer.borrow().checked_as::<i64>()
• integer.checked_as::<i64>()

Examples

use rug::Integer;
let fits = Integer::from(-50);
assert_eq!(fits.to_i64(), Some(-50));
let small = Integer::from_str_radix("-fedcba9876543210", 16).unwrap();
assert_eq!(small.to_i64(), None);
let large = Integer::from_str_radix("fedcba9876543210", 16).unwrap();
assert_eq!(large.to_i64(), None);

pub fn to_i128(&self) -> Option<i128>

Converts to an i128 if the value fits.

This conversion can also be performed using

• i128::try_from(&integer)
• i128::try_from(integer)
• (&integer).checked_as::<i128>()
• integer.borrow().checked_as::<i128>()
• integer.checked_as::<i128>()

Examples

use rug::Integer;
let fits = Integer::from(-50);
assert_eq!(fits.to_i128(), Some(-50));
let small: Integer = Integer::from(-1) << 130;
assert_eq!(small.to_i128(), None);
let large: Integer = Integer::from(1) << 130;
assert_eq!(large.to_i128(), None);

pub fn to_isize(&self) -> Option<isize>

Converts to an isize if the value fits.

This conversion can also be performed using

• isize::try_from(&integer)
• isize::try_from(integer)
• (&integer).checked_as::<isize>()
• integer.borrow().checked_as::<isize>()
• integer.checked_as::<isize>()

Examples

use rug::Integer;
let fits = Integer::from(0x1000);
assert_eq!(fits.to_isize(), Some(0x1000));
let large: Integer = Integer::from(0x1000) << 128;
assert_eq!(large.to_isize(), None);

pub fn to_u8(&self) -> Option<u8>

Converts to an u8 if the value fits.

This conversion can also be performed using

• u8::try_from(&integer)
• u8::try_from(integer)
• (&integer).checked_as::<u8>()
• integer.borrow().checked_as::<u8>()
• integer.checked_as::<u8>()

Examples

use rug::Integer;
let fits = Integer::from(200);
assert_eq!(fits.to_u8(), Some(200));
let neg = Integer::from(-1);
assert_eq!(neg.to_u8(), None);
let large = Integer::from(300);
assert_eq!(large.to_u8(), None);

pub fn to_u16(&self) -> Option<u16>

Converts to an u16 if the value fits.

This conversion can also be performed using

• u16::try_from(&integer)
• u16::try_from(integer)
• (&integer).checked_as::<u16>()
• integer.borrow().checked_as::<u16>()
• integer.checked_as::<u16>()

Examples

use rug::Integer;
let fits = Integer::from(60_000);
assert_eq!(fits.to_u16(), Some(60_000));
let neg = Integer::from(-1);
assert_eq!(neg.to_u16(), None);
let large = Integer::from(70_000);
assert_eq!(large.to_u16(), None);

pub fn to_u32(&self) -> Option<u32>

Converts to an u32 if the value fits.

This conversion can also be performed using

• u32::try_from(&integer)
• u32::try_from(integer)
• (&integer).checked_as::<u32>()
• integer.borrow().checked_as::<u32>()
• integer.checked_as::<u32>()

Examples

use rug::Integer;
let fits = Integer::from(1234567890);
assert_eq!(fits.to_u32(), Some(1234567890));
let neg = Integer::from(-1);
assert_eq!(neg.to_u32(), None);
let large = Integer::from(123456789012345_u64);
assert_eq!(large.to_u32(), None);

pub fn to_u64(&self) -> Option<u64>

Converts to an u64 if the value fits.

This conversion can also be performed using

• u64::try_from(&integer)
• u64::try_from(integer)
• (&integer).checked_as::<u64>()
• integer.borrow().checked_as::<u64>()
• integer.checked_as::<u64>()

Examples

use rug::Integer;
let fits = Integer::from(123456789012345_u64);
assert_eq!(fits.to_u64(), Some(123456789012345));
let neg = Integer::from(-1);
assert_eq!(neg.to_u64(), None);
let large = "1234567890123456789012345".parse::<Integer>().unwrap();
assert_eq!(large.to_u64(), None);

pub fn to_u128(&self) -> Option<u128>

Converts to an u128 if the value fits.

This conversion can also be performed using

• u128::try_from(&integer)
• u128::try_from(integer)
• (&integer).checked_as::<u128>()
• integer.borrow().checked_as::<u128>()
• integer.checked_as::<u128>()

Examples

use rug::Integer;
let fits = Integer::from(12345678901234567890_u128);
assert_eq!(fits.to_u128(), Some(12345678901234567890));
let neg = Integer::from(-1);
assert_eq!(neg.to_u128(), None);
let large = "1234567890123456789012345678901234567890"
    .parse::<Integer>()
    .unwrap();
assert_eq!(large.to_u128(), None);

pub fn to_usize(&self) -> Option<usize>

Converts to an usize if the value fits.

This conversion can also be performed using

• usize::try_from(&integer)
• usize::try_from(integer)
• (&integer).checked_as::<usize>()
• integer.borrow().checked_as::<usize>()
• integer.checked_as::<usize>()

Examples

use rug::Integer;
let fits = Integer::from(0x1000);
assert_eq!(fits.to_usize(), Some(0x1000));
let neg = Integer::from(-1);
assert_eq!(neg.to_usize(), None);
let large: Integer = Integer::from(0x1000) << 128;
assert_eq!(large.to_usize(), None);

pub fn to_i8_wrapping(&self) -> i8

Converts to an i8, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<i8>()
• integer.borrow().wrapping_as::<i8>()
• integer.wrapping_as::<i8>()

Examples

use rug::Integer;
let large = Integer::from(0x1234);
assert_eq!(large.to_i8_wrapping(), 0x34);

pub fn to_i16_wrapping(&self) -> i16

Converts to an i16, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<i16>()
• integer.borrow().wrapping_as::<i16>()
• integer.wrapping_as::<i16>()

Examples

use rug::Integer;
let large = Integer::from(0x1234_5678);
assert_eq!(large.to_i16_wrapping(), 0x5678);

pub fn to_i32_wrapping(&self) -> i32

Converts to an i32, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<i32>()
• integer.borrow().wrapping_as::<i32>()
• integer.wrapping_as::<i32>()

Examples

use rug::Integer;
let large = Integer::from(0x1234_5678_9abc_def0_u64);
assert_eq!(large.to_i32_wrapping(), 0x9abc_def0_u32 as i32);

pub fn to_i64_wrapping(&self) -> i64

Converts to an i64, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<i64>()
• integer.borrow().wrapping_as::<i64>()
• integer.wrapping_as::<i64>()

Examples

use rug::Integer;
let large = Integer::from_str_radix("f123456789abcdef0", 16).unwrap();
assert_eq!(large.to_i64_wrapping(), 0x1234_5678_9abc_def0);

pub fn to_i128_wrapping(&self) -> i128

Converts to an i128, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<i128>()
• integer.borrow().wrapping_as::<i128>()
• integer.wrapping_as::<i128>()

Examples

use rug::Integer;
let s = "f123456789abcdef0123456789abcdef0";
let large = Integer::from_str_radix(s, 16).unwrap();
assert_eq!(
    large.to_i128_wrapping(),
    0x1234_5678_9abc_def0_1234_5678_9abc_def0
);

pub fn to_isize_wrapping(&self) -> isize

Converts to an isize, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<isize>()
• integer.borrow().wrapping_as::<isize>()
• integer.wrapping_as::<isize>()

Examples

use rug::Integer;
let large: Integer = (Integer::from(0x1000) << 128) | 0x1234;
assert_eq!(large.to_isize_wrapping(), 0x1234);

pub fn to_u8_wrapping(&self) -> u8

Converts to a u8, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<u8>()
• integer.borrow().wrapping_as::<u8>()
• integer.wrapping_as::<u8>()

Examples

use rug::Integer;
let neg = Integer::from(-1);
assert_eq!(neg.to_u8_wrapping(), 0xff);
let large = Integer::from(0x1234);
assert_eq!(large.to_u8_wrapping(), 0x34);

pub fn to_u16_wrapping(&self) -> u16

Converts to a u16, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<u16>()
• integer.borrow().wrapping_as::<u16>()
• integer.wrapping_as::<u16>()

Examples

use rug::Integer;
let neg = Integer::from(-1);
assert_eq!(neg.to_u16_wrapping(), 0xffff);
let large = Integer::from(0x1234_5678);
assert_eq!(large.to_u16_wrapping(), 0x5678);

pub fn to_u32_wrapping(&self) -> u32

Converts to a u32, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<u32>()
• integer.borrow().wrapping_as::<u32>()
• integer.wrapping_as::<u32>()

Examples

use rug::Integer;
let neg = Integer::from(-1);
assert_eq!(neg.to_u32_wrapping(), 0xffff_ffff);
let large = Integer::from(0x1234_5678_9abc_def0_u64);
assert_eq!(large.to_u32_wrapping(), 0x9abc_def0);

pub fn to_u64_wrapping(&self) -> u64

Converts to a u64, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<u64>()
• integer.borrow().wrapping_as::<u64>()
• integer.wrapping_as::<u64>()

Examples

use rug::Integer;
let neg = Integer::from(-1);
assert_eq!(neg.to_u64_wrapping(), 0xffff_ffff_ffff_ffff);
let large = Integer::from_str_radix("f123456789abcdef0", 16).unwrap();
assert_eq!(large.to_u64_wrapping(), 0x1234_5678_9abc_def0);

pub fn to_u128_wrapping(&self) -> u128

Converts to a u128, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<u128>()
• integer.borrow().wrapping_as::<u128>()
• integer.wrapping_as::<u128>()

Examples

use rug::Integer;
let neg = Integer::from(-1);
assert_eq!(
    neg.to_u128_wrapping(),
    0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff
);
let s = "f123456789abcdef0123456789abcdef0";
let large = Integer::from_str_radix(s, 16).unwrap();
assert_eq!(
    large.to_u128_wrapping(),
    0x1234_5678_9abc_def0_1234_5678_9abc_def0
);

pub fn to_usize_wrapping(&self) -> usize

Converts to a usize, wrapping if the value does not fit.

This conversion can also be performed using

• (&integer).wrapping_as::<usize>()
• integer.borrow().wrapping_as::<usize>()
• integer.wrapping_as::<usize>()

Examples

use rug::Integer;
let large: Integer = (Integer::from(0x1000) << 128) | 0x1234;
assert_eq!(large.to_usize_wrapping(), 0x1234);

pub fn to_f32(&self) -> f32

Converts to an f32, rounding towards zero.

This conversion can also be performed using

• (&integer).az::<f32>()
• integer.borrow().az::<f32>()
• integer.az::<f32>()

Examples

use rug::Integer;
let min = Integer::from_f32(f32::MIN).unwrap();
let min_minus_one = min - 1u32;
// min_minus_one is truncated to f32::MIN
assert_eq!(min_minus_one.to_f32(), f32::MIN);
let times_two = min_minus_one * 2u32;
// times_two is too small
assert_eq!(times_two.to_f32(), f32::NEG_INFINITY);

pub fn to_f64(&self) -> f64

Converts to an f64, rounding towards zero.

This conversion can also be performed using

• (&integer).az::<f64>()
• integer.borrow().az::<f64>()
• integer.az::<f64>()

Examples

use rug::Integer;

// An `f64` has 53 bits of precision.
let exact = 0x1f_ffff_ffff_ffff_u64;
let i = Integer::from(exact);
assert_eq!(i.to_f64(), exact as f64);

// large has 56 ones
let large = 0xff_ffff_ffff_ffff_u64;
// trunc has 53 ones followed by 3 zeros
let trunc = 0xff_ffff_ffff_fff8_u64;
let j = Integer::from(large);
assert_eq!(j.to_f64() as u64, trunc);

let max = Integer::from_f64(f64::MAX).unwrap();
let max_plus_one = max + 1u32;
// max_plus_one is truncated to f64::MAX
assert_eq!(max_plus_one.to_f64(), f64::MAX);
let times_two = max_plus_one * 2u32;
// times_two is too large
assert_eq!(times_two.to_f64(), f64::INFINITY);

pub fn to_f32_exp(&self) -> (f32, u32)

Converts to an f32 and an exponent, rounding towards zero.

The returned f32 is in the range 0.5 ≤ x < 1. If the value is zero, (0.0, 0) is returned.

Examples

use rug::Integer;
let zero = Integer::new();
let (d0, exp0) = zero.to_f32_exp();
assert_eq!((d0, exp0), (0.0, 0));
let fifteen = Integer::from(15);
let (d15, exp15) = fifteen.to_f32_exp();
assert_eq!((d15, exp15), (15.0 / 16.0, 4));

pub fn to_f64_exp(&self) -> (f64, u32)

Converts to an f64 and an exponent, rounding towards zero.

The returned f64 is in the range 0.5 ≤ x < 1. If the value is zero, (0.0, 0) is returned.

Examples

use rug::Integer;
let zero = Integer::new();
let (d0, exp0) = zero.to_f64_exp();
assert_eq!((d0, exp0), (0.0, 0));
let fifteen = Integer::from(15);
let (d15, exp15) = fifteen.to_f64_exp();
assert_eq!((d15, exp15), (15.0 / 16.0, 4));

pub fn to_string_radix(&self, radix: i32) -> String

Returns a string representation of the number for the specified radix.

Panics

Panics if radix is less than 2 or greater than 36.

Examples

use rug::{Assign, Integer};
let mut i = Integer::new();
assert_eq!(i.to_string_radix(10), "0");
i.assign(-10);
assert_eq!(i.to_string_radix(16), "-a");
i.assign(0x1234cdef);
assert_eq!(i.to_string_radix(4), "102031030313233");
i.assign(Integer::parse_radix("123456789aAbBcCdDeEfF", 16).unwrap());
assert_eq!(i.to_string_radix(16), "123456789aabbccddeeff");

pub fn assign_f32(&mut self, val: f32) -> Result<(), ()>

Assigns from an f32 if it is finite, rounding towards zero.

Examples

use rug::Integer;
let mut i = Integer::new();
let ret = i.assign_f64(-12.7);
assert!(ret.is_ok());
assert_eq!(i, -12);
let ret = i.assign_f32(f32::NAN);
assert!(ret.is_err());
assert_eq!(i, -12);

pub fn assign_f64(&mut self, val: f64) -> Result<(), ()>

Assigns from an f64 if it is finite, rounding towards zero.

Examples

use rug::Integer;
let mut i = Integer::new();
let ret = i.assign_f64(12.7);
assert!(ret.is_ok());
assert_eq!(i, 12);
let ret = i.assign_f64(1.0 / 0.0);
assert!(ret.is_err());
assert_eq!(i, 12);

pub const fn as_neg(&self) -> BorrowInteger<'_>

Borrows a negated copy of the Integer.

The returned object implements Deref<Target = Integer>.

This method performs a shallow copy and negates it, and negation does not change the allocated data.

Examples

use rug::Integer;
let i = Integer::from(42);
let neg_i = i.as_neg();
assert_eq!(*neg_i, -42);
// methods taking &self can be used on the returned object
let reneg_i = neg_i.as_neg();
assert_eq!(*reneg_i, 42);
assert_eq!(*reneg_i, i);

pub const fn as_abs(&self) -> BorrowInteger<'_>

Borrows an absolute copy of the Integer.

The returned object implements Deref<Target = Integer>.

This method performs a shallow copy and possibly negates it, and negation does not change the allocated data.

Examples

use rug::Integer;
let i = Integer::from(-42);
let abs_i = i.as_abs();
assert_eq!(*abs_i, 42);
// methods taking &self can be used on the returned object
let reabs_i = abs_i.as_abs();
assert_eq!(*reabs_i, 42);
assert_eq!(*reabs_i, *abs_i);

pub const fn as_rational(&self) -> BorrowRational<'_>

Borrows a copy of the Integer as a Rational number.

The returned object implements Deref<Target = Rational>.

Examples

use rug::Integer;
let i = Integer::from(4);
let r = i.as_rational();
assert_eq!(*r, 4);
// methods taking &self can be used on the returned object
let recip_r = r.as_recip();
assert_eq!(*recip_r, 0.25);

pub const fn is_zero(&self) -> bool

Returns true if the number is zero.

Examples

use rug::Integer;
assert!(Integer::from(0).is_zero());
assert!(!(Integer::from(1).is_zero()));

pub const fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

Examples

use rug::Integer;
assert!(Integer::from(10).is_positive());
assert!(!(Integer::from(-10).is_positive()));

pub const fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

Examples

use rug::Integer;
assert!(Integer::from(-10).is_negative());
assert!(!(Integer::from(10).is_negative()));

pub const fn is_even(&self) -> bool

Returns true if the number is even.

Examples

use rug::Integer;
assert!(!(Integer::from(13).is_even()));
assert!(Integer::from(-14).is_even());

pub const fn is_odd(&self) -> bool

Returns true if the number is odd.

Examples

use rug::Integer;
assert!(Integer::from(13).is_odd());
assert!(!Integer::from(-14).is_odd());

pub fn is_divisible(&self, divisor: &Self) -> bool

Returns true if the number is divisible by divisor. Unlike other division functions, divisor can be zero.

Examples

use rug::Integer;
let i = Integer::from(230);
assert!(i.is_divisible(&Integer::from(10)));
assert!(!i.is_divisible(&Integer::from(100)));
assert!(!i.is_divisible(&Integer::new()));

pub fn is_divisible_u(&self, divisor: u32) -> bool

Returns true if the number is divisible by divisor. Unlike other division functions, divisor can be zero.

Examples

use rug::Integer;
let i = Integer::from(230);
assert!(i.is_divisible_u(23));
assert!(!i.is_divisible_u(100));
assert!(!i.is_divisible_u(0));

pub fn is_divisible_2pow(&self, b: u32) -> bool

Returns true if the number is divisible by 2^b.

Examples

use rug::Integer;
let i = Integer::from(15 << 17);
assert!(i.is_divisible_2pow(16));
assert!(i.is_divisible_2pow(17));
assert!(!i.is_divisible_2pow(18));

pub fn is_congruent(&self, c: &Self, divisor: &Self) -> bool

Returns true if the number is congruent to c mod divisor, that is, if there exists a q such that self = c + q × divisor. Unlike other division functions, divisor can be zero.

Examples

use rug::Integer;
let n = Integer::from(105);
let divisor = Integer::from(10);
assert!(n.is_congruent(&Integer::from(5), &divisor));
assert!(n.is_congruent(&Integer::from(25), &divisor));
assert!(!n.is_congruent(&Integer::from(7), &divisor));
// n is congruent to itself if divisor is 0
assert!(n.is_congruent(&n, &Integer::from(0)));

pub fn is_congruent_u(&self, c: u32, divisor: u32) -> bool

Returns true if the number is congruent to c mod divisor, that is, if there exists a q such that self = c + q × divisor. Unlike other division functions, divisor can be zero.

Examples

use rug::Integer;
let n = Integer::from(105);
assert!(n.is_congruent_u(3335, 10));
assert!(!n.is_congruent_u(107, 10));
// n is congruent to itself if divisor is 0
assert!(n.is_congruent_u(105, 0));

pub fn is_congruent_2pow(&self, c: &Self, b: u32) -> bool

Returns true if the number is congruent to c mod 2^b, that is, if there exists a q such that self = c + q × 2^b.

Examples

use rug::Integer;
let n = Integer::from(13 << 17 | 21);
assert!(n.is_congruent_2pow(&Integer::from(7 << 17 | 21), 17));
assert!(!n.is_congruent_2pow(&Integer::from(13 << 17 | 22), 17));

pub fn is_perfect_power(&self) -> bool

Returns true if the number is a perfect power.

Examples

use rug::Integer;
// 0 is 0 to the power of anything
assert!(Integer::from(0).is_perfect_power());
// 25 is 5 to the power of 2
assert!(Integer::from(25).is_perfect_power());
// -243 is -3 to the power of 5
assert!(Integer::from(243).is_perfect_power());

assert!(!Integer::from(24).is_perfect_power());
assert!(!Integer::from(-100).is_perfect_power());

pub fn is_perfect_square(&self) -> bool

Returns true if the number is a perfect square.

Examples

use rug::Integer;
assert!(Integer::from(0).is_perfect_square());
assert!(Integer::from(1).is_perfect_square());
assert!(Integer::from(4).is_perfect_square());
assert!(Integer::from(9).is_perfect_square());

assert!(!Integer::from(15).is_perfect_square());
assert!(!Integer::from(-9).is_perfect_square());

pub fn is_power_of_two(&self) -> bool

Returns true if the number is a power of two.

Examples

use rug::Integer;
assert!(Integer::from(1).is_power_of_two());
assert!(Integer::from(4).is_power_of_two());
assert!(Integer::from(1 << 30).is_power_of_two());

assert!(!Integer::from(7).is_power_of_two());
assert!(!Integer::from(0).is_power_of_two());
assert!(!Integer::from(-1).is_power_of_two());

pub const fn cmp0(&self) -> Ordering

Returns the same result as self.cmp(&0.into()), but is faster.

Examples

use core::cmp::Ordering;
use rug::Integer;
assert_eq!(Integer::from(-5).cmp0(), Ordering::Less);
assert_eq!(Integer::from(0).cmp0(), Ordering::Equal);
assert_eq!(Integer::from(5).cmp0(), Ordering::Greater);

pub fn cmp_abs(&self, other: &Self) -> Ordering

Compares the absolute values.

Examples

use core::cmp::Ordering;
use rug::Integer;
let a = Integer::from(-10);
let b = Integer::from(4);
assert_eq!(a.cmp(&b), Ordering::Less);
assert_eq!(a.cmp_abs(&b), Ordering::Greater);

pub fn significant_bits(&self) -> u32

Returns the number of bits required to represent the absolute value.

Examples

use rug::Integer;

assert_eq!(Integer::from(0).significant_bits(), 0);  //    “”
assert_eq!(Integer::from(1).significant_bits(), 1);  //   “1”
assert_eq!(Integer::from(4).significant_bits(), 3);  // “100”
assert_eq!(Integer::from(7).significant_bits(), 3);  // “111”
assert_eq!(Integer::from(-1).significant_bits(), 1); //   “1”
assert_eq!(Integer::from(-4).significant_bits(), 3); // “100”
assert_eq!(Integer::from(-7).significant_bits(), 3); // “111”

pub fn signed_bits(&self) -> u32

Returns the number of bits required to represent the value using a two’s-complement representation.

For non-negative numbers, this method returns one more than the significant_bits method, since an extra zero is needed before the most significant bit.

Examples

use rug::Integer;

assert_eq!(Integer::from(-5).signed_bits(), 4); // “1011”
assert_eq!(Integer::from(-4).signed_bits(), 3); //  “100”
assert_eq!(Integer::from(-3).signed_bits(), 3); //  “101”
assert_eq!(Integer::from(-2).signed_bits(), 2); //   “10”
assert_eq!(Integer::from(-1).signed_bits(), 1); //    “1”
assert_eq!(Integer::from(0).signed_bits(), 1);  //    “0”
assert_eq!(Integer::from(1).signed_bits(), 2);  //   “01”
assert_eq!(Integer::from(2).signed_bits(), 3);  //  “010”
assert_eq!(Integer::from(3).signed_bits(), 3);  //  “011”
assert_eq!(Integer::from(4).signed_bits(), 4);  // “0100”

pub fn count_ones(&self) -> Option<u32>

Returns the number of one bits if the value ≥ 0.

Examples

use rug::Integer;
assert_eq!(Integer::from(0).count_ones(), Some(0));
assert_eq!(Integer::from(15).count_ones(), Some(4));
assert_eq!(Integer::from(-1).count_ones(), None);

pub fn count_zeros(&self) -> Option<u32>

Returns the number of zero bits if the value < 0.

Examples

use rug::Integer;
assert_eq!(Integer::from(0).count_zeros(), None);
assert_eq!(Integer::from(1).count_zeros(), None);
assert_eq!(Integer::from(-1).count_zeros(), Some(0));
assert_eq!(Integer::from(-2).count_zeros(), Some(1));
assert_eq!(Integer::from(-7).count_zeros(), Some(2));
assert_eq!(Integer::from(-8).count_zeros(), Some(3));

pub fn find_zero(&self, start: u32) -> Option<u32>

Returns the location of the first zero, starting at start. If the bit at location start is zero, returns start.

Examples

use rug::Integer;
// -2 is ...11111110
assert_eq!(Integer::from(-2).find_zero(0), Some(0));
assert_eq!(Integer::from(-2).find_zero(1), None);
// 15 is ...00001111
assert_eq!(Integer::from(15).find_zero(0), Some(4));
assert_eq!(Integer::from(15).find_zero(20), Some(20));

pub fn find_one(&self, start: u32) -> Option<u32>

Returns the location of the first one, starting at start. If the bit at location start is one, returns start.

Examples

use rug::Integer;
// 1 is ...00000001
assert_eq!(Integer::from(1).find_one(0), Some(0));
assert_eq!(Integer::from(1).find_one(1), None);
// -16 is ...11110000
assert_eq!(Integer::from(-16).find_one(0), Some(4));
assert_eq!(Integer::from(-16).find_one(20), Some(20));

pub fn set_bit(&mut self, index: u32, val: bool) -> &mut Self

Sets the bit at location index to 1 if val is true or 0 if val is false.

Examples

use rug::{Assign, Integer};
let mut i = Integer::from(-1);
assert_eq!(*i.set_bit(0, false), -2);
i.assign(0xff);
assert_eq!(*i.set_bit(11, true), 0x8ff);

pub fn get_bit(&self, index: u32) -> bool

Returns true if the bit at location index is 1 or false if the bit is 0.

Examples

use rug::Integer;
let i = Integer::from(0b100101);
assert!(i.get_bit(0));
assert!(!i.get_bit(1));
assert!(i.get_bit(5));
let neg = Integer::from(-1);
assert!(neg.get_bit(1000));

pub fn toggle_bit(&mut self, index: u32) -> &mut Self

Toggles the bit at location index.

Examples

use rug::Integer;
let mut i = Integer::from(0b100101);
i.toggle_bit(5);
assert_eq!(i, 0b101);

pub fn hamming_dist(&self, other: &Self) -> Option<u32>

Retuns the Hamming distance if the two numbers have the same sign.

The Hamming distance is the number of different bits.

Examples

use rug::Integer;
let i = Integer::from(-1);
assert_eq!(Integer::from(0).hamming_dist(&i), None);
assert_eq!(Integer::from(-1).hamming_dist(&i), Some(0));
// -1 is ...11111111 and -13 is ...11110011
assert_eq!(Integer::from(-13).hamming_dist(&i), Some(2));

pub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I>

where I: Iterator<Item = &'a Self>,

Adds a list of Integer values.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src
• AddAssign<Src> for Integer
• Add<Src> for Integer, Add<Integer> for Src
• SubAssign<Src> for Integer, SubFrom<Src> for Integer
• Sub<Src> for Integer, Sub<Integer> for Src

Examples

use rug::{Complete, Integer};

let values = [
    Integer::from(5),
    Integer::from(1024),
    Integer::from(-100_000),
    Integer::from(-4),
];

let sum = Integer::sum(values.iter()).complete();
let expected = 5 + 1024 - 100_000 - 4;
assert_eq!(sum, expected);

pub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I>

where I: Iterator<Item = (&'a Self, &'a Self)>,

Finds the dot product of a list of Integer value pairs.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src
• AddAssign<Src> for Integer
• Add<Src> for Integer, Add<Integer> for Src
• SubAssign<Src> for Integer, SubFrom<Src> for Integer
• Sub<Src> for Integer, Sub<Integer> for Src

Examples

use rug::{Complete, Integer};

let a = [Integer::from(270), Integer::from(-11)];
let b = [Integer::from(100), Integer::from(5)];

let dot = Integer::dot(a.iter().zip(b.iter())).complete();
let expected = 270 * 100 - 11 * 5;
assert_eq!(dot, expected);

pub fn product<'a, I>(values: I) -> ProductIncomplete<'a, I>

where I: Iterator<Item = &'a Self>,

Multiplies a list of Integer values.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src
• MulAssign<Src> for Integer
• Mul<Src> for Integer, Mul<Integer> for Src

Examples

use rug::{Complete, Integer};

let values = [
    Integer::from(5),
    Integer::from(1024),
    Integer::from(-100_000),
    Integer::from(-4),
];

let product = Integer::product(values.iter()).complete();
let expected = 5 * 1024 * -100_000 * -4;
assert_eq!(product, expected);

pub fn abs(self) -> Self

Computes the absolute value.

Examples

use rug::Integer;
let i = Integer::from(-100);
let abs = i.abs();
assert_eq!(abs, 100);

pub fn abs_mut(&mut self)

Computes the absolute value.

Examples

use rug::Integer;
let mut i = Integer::from(-100);
i.abs_mut();
assert_eq!(i, 100);

pub fn abs_ref(&self) -> AbsIncomplete<'_>

Computes the absolute value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(-100);
let r = i.abs_ref();
let abs = Integer::from(r);
assert_eq!(abs, 100);
assert_eq!(i, -100);

pub fn signum(self) -> Self

Computes the signum.

• 0 if the value is zero
• 1 if the value is positive
• −1 if the value is negative

Examples

use rug::Integer;
assert_eq!(Integer::from(-100).signum(), -1);
assert_eq!(Integer::from(0).signum(), 0);
assert_eq!(Integer::from(100).signum(), 1);

pub fn signum_mut(&mut self)

Computes the signum.

• 0 if the value is zero
• 1 if the value is positive
• −1 if the value is negative

Examples

use rug::Integer;
let mut i = Integer::from(-100);
i.signum_mut();
assert_eq!(i, -1);

pub fn signum_ref(&self) -> SignumIncomplete<'_>

Computes the signum.

• 0 if the value is zero
• 1 if the value is positive
• −1 if the value is negative

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(-100);
let r = i.signum_ref();
let signum = Integer::from(r);
assert_eq!(signum, -1);
assert_eq!(i, -100);

pub fn clamp<Min, Max>(self, min: &Min, max: &Max) -> Self

where Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,

Clamps the value within the specified bounds.

Panics

Panics if the maximum value is less than the minimum value.

Examples

use rug::Integer;
let min = -10;
let max = 10;
let too_small = Integer::from(-100);
let clamped1 = too_small.clamp(&min, &max);
assert_eq!(clamped1, -10);
let in_range = Integer::from(3);
let clamped2 = in_range.clamp(&min, &max);
assert_eq!(clamped2, 3);

pub fn clamp_mut<Min, Max>(&mut self, min: &Min, max: &Max)

where Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,

Clamps the value within the specified bounds.

Panics

Panics if the maximum value is less than the minimum value.

Examples

use rug::Integer;
let min = -10;
let max = 10;
let mut too_small = Integer::from(-100);
too_small.clamp_mut(&min, &max);
assert_eq!(too_small, -10);
let mut in_range = Integer::from(3);
in_range.clamp_mut(&min, &max);
assert_eq!(in_range, 3);

pub fn clamp_ref<'min, 'max, Min, Max>( &self, min: &'min Min, max: &'max Max ) -> ClampIncomplete<'_, 'min, 'max, Min, Max>

where Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,

Clamps the value within the specified bounds.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Panics

Panics if the maximum value is less than the minimum value.

Examples

use rug::Integer;
let min = -10;
let max = 10;
let too_small = Integer::from(-100);
let r1 = too_small.clamp_ref(&min, &max);
let clamped1 = Integer::from(r1);
assert_eq!(clamped1, -10);
let in_range = Integer::from(3);
let r2 = in_range.clamp_ref(&min, &max);
let clamped2 = Integer::from(r2);
assert_eq!(clamped2, 3);

pub fn keep_bits(self, n: u32) -> Self

Keeps the n least significant bits only, producing a result that is greater or equal to 0.

Examples

use rug::Integer;
let i = Integer::from(-1);
let keep_8 = i.keep_bits(8);
assert_eq!(keep_8, 0xff);

pub fn keep_bits_mut(&mut self, n: u32)

Keeps the n least significant bits only, producing a result that is greater or equal to 0.

Examples

use rug::Integer;
let mut i = Integer::from(-1);
i.keep_bits_mut(8);
assert_eq!(i, 0xff);

pub fn keep_bits_ref(&self, n: u32) -> KeepBitsIncomplete<'_>

Keeps the n least significant bits only, producing a result that is greater or equal to 0.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(-1);
let r = i.keep_bits_ref(8);
let eight_bits = Integer::from(r);
assert_eq!(eight_bits, 0xff);

pub fn keep_signed_bits(self, n: u32) -> Self

Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.

Examples

use rug::Integer;
let i = Integer::from(-1);
let i_keep_8 = i.keep_signed_bits(8);
assert_eq!(i_keep_8, -1);
let j = Integer::from(15 << 8 | 15);
let j_keep_8 = j.keep_signed_bits(8);
assert_eq!(j_keep_8, 15);

pub fn keep_signed_bits_mut(&mut self, n: u32)

Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.

Examples

use rug::Integer;
let mut i = Integer::from(-1);
i.keep_signed_bits_mut(8);
assert_eq!(i, -1);
let mut j = Integer::from(15 << 8 | 15);
j.keep_signed_bits_mut(8);
assert_eq!(j, 15);

pub fn keep_signed_bits_ref(&self, n: u32) -> KeepSignedBitsIncomplete<'_>

Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(-1);
let r = i.keep_signed_bits_ref(8);
let eight_bits = Integer::from(r);
assert_eq!(eight_bits, -1);

pub fn next_power_of_two(self) -> Self

Finds the next power of two, or 1 if the number ≤ 0.

Examples

use rug::Integer;
let i = Integer::from(-3).next_power_of_two();
assert_eq!(i, 1);
let i = Integer::from(4).next_power_of_two();
assert_eq!(i, 4);
let i = Integer::from(7).next_power_of_two();
assert_eq!(i, 8);

pub fn next_power_of_two_mut(&mut self)

Finds the next power of two, or 1 if the number ≤ 0.

Examples

use rug::Integer;
let mut i = Integer::from(53);
i.next_power_of_two_mut();
assert_eq!(i, 64);

pub fn next_power_of_two_ref(&self) -> NextPowerOfTwoIncomplete<'_>

Finds the next power of two, or 1 if the number ≤ 0.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(53);
let r = i.next_power_of_two_ref();
let next = Integer::from(r);
assert_eq!(next, 64);

pub fn modulo(self, divisor: &Self) -> Self

Finds the modulus, or the remainder of Euclidean division.

The result is always zero or positive.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let dividend = Integer::from(-1003);
let divisor = Integer::from(-10);
let modulus = dividend.modulo(&divisor);
assert_eq!(modulus, 7);

pub fn modulo_mut(&mut self, divisor: &Self)

Finds the modulus, or the remainder of Euclidean division.

The result is always zero or positive.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let mut m = Integer::from(-1003);
let divisor = Integer::from(-10);
m.modulo_mut(&divisor);
assert_eq!(m, 7);

pub fn modulo_from(&mut self, dividend: &Self)

Finds the modulus, or the remainder of Euclidean division dividend / self.

The result is always zero or positive.

Panics

Panics if self is zero.

Examples

use rug::Integer;
let dividend = Integer::from(-1003);
let mut m = Integer::from(-10);
m.modulo_from(&dividend);
assert_eq!(m, 7);

pub fn modulo_ref<'a>(&'a self, divisor: &'a Self) -> ModuloIncomplete<'_>

Finds the modulus, or the remainder of Euclidean division.

The result is always zero or positive.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let dividend = Integer::from(-1003);
let divisor = Integer::from(-10);
let r = dividend.modulo_ref(&divisor);
let modulus = Integer::from(r);
assert_eq!(modulus, 7);

pub fn div_rem(self, divisor: Self) -> (Self, Self)

Performs a division producing both the quotient and remainder.

The remainder has the same sign as the dividend.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let dividend = Integer::from(23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem(divisor);
assert_eq!(quotient, -2);
assert_eq!(rem, 3);

pub fn div_rem_mut(&mut self, divisor: &mut Self)

Performs a division producing both the quotient and remainder.

The remainder has the same sign as the dividend.

The quotient is stored in self and the remainder is stored in divisor.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let mut dividend_quotient = Integer::from(-23);
let mut divisor_rem = Integer::from(10);
dividend_quotient.div_rem_mut(&mut divisor_rem);
assert_eq!(dividend_quotient, -2);
assert_eq!(divisor_rem, -3);

pub fn div_rem_ref<'a>(&'a self, divisor: &'a Self) -> DivRemIncomplete<'_>

Performs a division producing both the quotient and remainder.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Integer, Integer)
• Assign<Src> for (&mut Integer, &mut Integer)
• From<Src> for (Integer, Integer)
• Complete<Completed = (Integer, Integer)> for Src

The remainder has the same sign as the dividend.

Examples

use rug::{Complete, Integer};
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_ref(&divisor).complete();
assert_eq!(quotient, 2);
assert_eq!(rem, -3);

pub fn div_rem_ceil(self, divisor: Self) -> (Self, Self)

Performs a division producing both the quotient and remainder, with the quotient rounded up.

The sign of the remainder is the opposite of the divisor’s sign.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let dividend = Integer::from(23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_ceil(divisor);
assert_eq!(quotient, -2);
assert_eq!(rem, 3);

pub fn div_rem_ceil_mut(&mut self, divisor: &mut Self)

Performs a division producing both the quotient and remainder, with the quotient rounded up.

The sign of the remainder is the opposite of the divisor’s sign.

The quotient is stored in self and the remainder is stored in divisor.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let mut dividend_quotient = Integer::from(-23);
let mut divisor_rem = Integer::from(10);
dividend_quotient.div_rem_ceil_mut(&mut divisor_rem);
assert_eq!(dividend_quotient, -2);
assert_eq!(divisor_rem, -3);

pub fn div_rem_ceil_ref<'a>( &'a self, divisor: &'a Self ) -> DivRemCeilIncomplete<'_>

Performs a division producing both the quotient and remainder, with the quotient rounded up.

The sign of the remainder is the opposite of the divisor’s sign.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Integer, Integer)
• Assign<Src> for (&mut Integer, &mut Integer)
• From<Src> for (Integer, Integer)
• Complete<Completed = (Integer, Integer)> for Src

Examples

use rug::{Complete, Integer};
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_ceil_ref(&divisor).complete();
assert_eq!(quotient, 3);
assert_eq!(rem, 7);

pub fn div_rem_floor(self, divisor: Self) -> (Self, Self)

Performs a division producing both the quotient and remainder, with the quotient rounded down.

The remainder has the same sign as the divisor.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let dividend = Integer::from(23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_floor(divisor);
assert_eq!(quotient, -3);
assert_eq!(rem, -7);

pub fn div_rem_floor_mut(&mut self, divisor: &mut Self)

Performs a division producing both the quotient and remainder, with the quotient rounded down.

The remainder has the same sign as the divisor.

The quotient is stored in self and the remainder is stored in divisor.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let mut dividend_quotient = Integer::from(-23);
let mut divisor_rem = Integer::from(10);
dividend_quotient.div_rem_floor_mut(&mut divisor_rem);
assert_eq!(dividend_quotient, -3);
assert_eq!(divisor_rem, 7);

pub fn div_rem_floor_ref<'a>( &'a self, divisor: &'a Self ) -> DivRemFloorIncomplete<'_>

Performs a division producing both the quotient and remainder, with the quotient rounded down.

The remainder has the same sign as the divisor.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Integer, Integer)
• Assign<Src> for (&mut Integer, &mut Integer)
• From<Src> for (Integer, Integer)
• Complete<Completed = (Integer, Integer)> for Src

Examples

use rug::{Complete, Integer};
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_floor_ref(&divisor).complete();
assert_eq!(quotient, 2);
assert_eq!(rem, -3);

pub fn div_rem_round(self, divisor: Self) -> (Self, Self)

Performs a division producing both the quotient and remainder, with the quotient rounded to the nearest integer.

When the quotient before rounding lies exactly between two integers, it is rounded away from zero.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
// 23 / -10 → -2 rem 3
let (q, rem) = Integer::from(23).div_rem_round((-10).into());
assert!(q == -2 && rem == 3);
// 25 / 10 → 3 rem -5
let (q, rem) = Integer::from(25).div_rem_round(10.into());
assert!(q == 3 && rem == -5);
// -27 / 10 → -3 rem 3
let (q, rem) = Integer::from(-27).div_rem_round(10.into());
assert!(q == -3 && rem == 3);

pub fn div_rem_round_mut(&mut self, divisor: &mut Self)

Performs a division producing both the quotient and remainder, with the quotient rounded to the nearest integer.

When the quotient before rounding lies exactly between two integers, it is rounded away from zero.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
// -25 / -10 → 3 rem 5
let mut dividend_quotient = Integer::from(-25);
let mut divisor_rem = Integer::from(-10);
dividend_quotient.div_rem_round_mut(&mut divisor_rem);
assert_eq!(dividend_quotient, 3);
assert_eq!(divisor_rem, 5);

pub fn div_rem_round_ref<'a>( &'a self, divisor: &'a Self ) -> DivRemRoundIncomplete<'_>

Performs a division producing both the quotient and remainder, with the quotient rounded to the nearest integer.

When the quotient before rounding lies exactly between two integers, it is rounded away from zero.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Integer, Integer)
• Assign<Src> for (&mut Integer, &mut Integer)
• From<Src> for (Integer, Integer)
• Complete<Completed = (Integer, Integer)> for Src

Examples

use rug::{Complete, Integer};
// -28 / -10 → 3 rem 2
let dividend = Integer::from(-28);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_round_ref(&divisor).complete();
assert_eq!(quotient, 3);
assert_eq!(rem, 2);

pub fn div_rem_euc(self, divisor: Self) -> (Self, Self)

Performs Euclidean division producing both the quotient and remainder, with a positive remainder.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let dividend = Integer::from(23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_euc(divisor);
assert_eq!(quotient, -2);
assert_eq!(rem, 3);

pub fn div_rem_euc_mut(&mut self, divisor: &mut Self)

Performs Euclidean division producing both the quotient and remainder, with a positive remainder.

The quotient is stored in self and the remainder is stored in divisor.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let mut dividend_quotient = Integer::from(-23);
let mut divisor_rem = Integer::from(10);
dividend_quotient.div_rem_euc_mut(&mut divisor_rem);
assert_eq!(dividend_quotient, -3);
assert_eq!(divisor_rem, 7);

pub fn div_rem_euc_ref<'a>( &'a self, divisor: &'a Self ) -> DivRemEucIncomplete<'_>

Performs Euclidan division producing both the quotient and remainder, with a positive remainder.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Integer, Integer)
• Assign<Src> for (&mut Integer, &mut Integer)
• From<Src> for (Integer, Integer)
• Complete<Completed = (Integer, Integer)> for Src

Examples

use rug::{Complete, Integer};
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_euc_ref(&divisor).complete();
assert_eq!(quotient, 3);
assert_eq!(rem, 7);

pub fn mod_u(&self, modulo: u32) -> u32

Returns the modulo, or the remainder of Euclidean division by a u32.

The result is always zero or positive.

Panics

Panics if modulo is zero.

Examples

use rug::Integer;
let pos = Integer::from(23);
assert_eq!(pos.mod_u(1), 0);
assert_eq!(pos.mod_u(10), 3);
assert_eq!(pos.mod_u(100), 23);
let neg = Integer::from(-23);
assert_eq!(neg.mod_u(1), 0);
assert_eq!(neg.mod_u(10), 7);
assert_eq!(neg.mod_u(100), 77);

pub fn div_exact(self, divisor: &Self) -> Self

Performs an exact division.

This is much faster than normal division, but produces correct results only when the division is exact.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let i = Integer::from(12345 * 54321);
let quotient = i.div_exact(&Integer::from(12345));
assert_eq!(quotient, 54321);

pub fn div_exact_mut(&mut self, divisor: &Self)

Performs an exact division.

This is much faster than normal division, but produces correct results only when the division is exact.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let mut i = Integer::from(12345 * 54321);
i.div_exact_mut(&Integer::from(12345));
assert_eq!(i, 54321);

pub fn div_exact_from(&mut self, dividend: &Integer)

Performs an exact division dividend / self.

This is much faster than normal division, but produces correct results only when the division is exact.

Panics

Panics if self is zero.

Examples

use rug::Integer;
let mut i = Integer::from(12345);
i.div_exact_from(&Integer::from(12345 * 54321));
assert_eq!(i, 54321);

pub fn div_exact_ref<'a>(&'a self, divisor: &'a Self) -> DivExactIncomplete<'_>

Performs an exact division.

This is much faster than normal division, but produces correct results only when the division is exact.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(12345 * 54321);
let divisor = Integer::from(12345);
let r = i.div_exact_ref(&divisor);
let quotient = Integer::from(r);
assert_eq!(quotient, 54321);

pub fn div_exact_u(self, divisor: u32) -> Self

Performs an exact division.

This is much faster than normal division, but produces correct results only when the division is exact.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let i = Integer::from(12345 * 54321);
let q = i.div_exact_u(12345);
assert_eq!(q, 54321);

pub fn div_exact_u_mut(&mut self, divisor: u32)

Performs an exact division.

This is much faster than normal division, but produces correct results only when the division is exact.

Panics

Panics if divisor is zero.

Examples

use rug::Integer;
let mut i = Integer::from(12345 * 54321);
i.div_exact_u_mut(12345);
assert_eq!(i, 54321);

pub fn div_exact_u_ref(&self, divisor: u32) -> DivExactUIncomplete<'_>

Performs an exact division.

This is much faster than normal division, but produces correct results only when the division is exact.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(12345 * 54321);
let r = i.div_exact_u_ref(12345);
assert_eq!(Integer::from(r), 54321);

pub fn invert(self, modulo: &Self) -> Result<Self, Self>

Finds the inverse modulo modulo and returns Ok(inverse) if it exists, or Err(unchanged) if the inverse does not exist.

The inverse exists if the modulo is not zero, and self and the modulo are co-prime, that is their GCD is 1.

Examples

use rug::Integer;
let n = Integer::from(2);
// Modulo 4, 2 has no inverse: there is no i such that 2 × i = 1.
let inv_mod_4 = match n.invert(&Integer::from(4)) {
    Ok(_) => unreachable!(),
    Err(unchanged) => unchanged,
};
// no inverse exists, so value is unchanged
assert_eq!(inv_mod_4, 2);
let n = inv_mod_4;
// Modulo 5, the inverse of 2 is 3, as 2 × 3 = 1.
let inv_mod_5 = match n.invert(&Integer::from(5)) {
    Ok(inverse) => inverse,
    Err(_) => unreachable!(),
};
assert_eq!(inv_mod_5, 3);

pub fn invert_mut(&mut self, modulo: &Self) -> Result<(), ()>

Finds the inverse modulo modulo if an inverse exists.

The inverse exists if the modulo is not zero, and self and the modulo are co-prime, that is their GCD is 1.

Examples

use rug::Integer;
let mut n = Integer::from(2);
// Modulo 4, 2 has no inverse: there is no i such that 2 × i = 1.
match n.invert_mut(&Integer::from(4)) {
    Ok(()) => unreachable!(),
    Err(()) => assert_eq!(n, 2),
}
// Modulo 5, the inverse of 2 is 3, as 2 × 3 = 1.
match n.invert_mut(&Integer::from(5)) {
    Ok(()) => assert_eq!(n, 3),
    Err(()) => unreachable!(),
}

pub fn invert_ref<'a>( &'a self, modulo: &'a Self ) -> Option<InvertIncomplete<'a>>

Finds the inverse modulo modulo if an inverse exists.

The inverse exists if the modulo is not zero, and self and the modulo are co-prime, that is their GCD is 1.

The following are implemented with the unwrapped returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let two = Integer::from(2);
let four = Integer::from(4);
let five = Integer::from(5);

// Modulo 4, 2 has no inverse, there is no i such that 2 × i = 1.
// For this conversion, if no inverse exists, the Integer
// created is left unchanged as 0.
assert!(two.invert_ref(&four).is_none());

// Modulo 5, the inverse of 2 is 3, as 2 × 3 = 1.
let r = two.invert_ref(&five).unwrap();
let inverse = Integer::from(r);
assert_eq!(inverse, 3);

pub fn pow_mod(self, exponent: &Self, modulo: &Self) -> Result<Self, Self>

Raises a number to the power of exponent modulo modulo and returns Ok(power) if an answer exists, or Err(unchanged) if it does not.

If the exponent is negative, then the number must have an inverse for an answer to exist.

When the exponent is positive and the modulo is not zero, an answer always exists.

Examples

use rug::Integer;
// 7 ^ 5 = 16807
let n = Integer::from(7);
let e = Integer::from(5);
let m = Integer::from(1000);
let power = match n.pow_mod(&e, &m) {
    Ok(power) => power,
    Err(_) => unreachable!(),
};
assert_eq!(power, 807);

When the exponent is negative, an answer exists if an inverse exists.

use rug::Integer;
// 7 × 143 modulo 1000 = 1, so 7 has an inverse 143.
// 7 ^ -5 modulo 1000 = 143 ^ 5 modulo 1000 = 943.
let n = Integer::from(7);
let e = Integer::from(-5);
let m = Integer::from(1000);
let power = match n.pow_mod(&e, &m) {
    Ok(power) => power,
    Err(_) => unreachable!(),
};
assert_eq!(power, 943);

pub fn pow_mod_mut(&mut self, exponent: &Self, modulo: &Self) -> Result<(), ()>

Raises a number to the power of exponent modulo modulo if an answer exists.

If the exponent is negative, then the number must have an inverse for an answer to exist.

Examples

use rug::{Assign, Integer};
// Modulo 1000, 2 has no inverse: there is no i such that 2 × i = 1.
let mut n = Integer::from(2);
let e = Integer::from(-5);
let m = Integer::from(1000);
match n.pow_mod_mut(&e, &m) {
    Ok(()) => unreachable!(),
    Err(()) => assert_eq!(n, 2),
}
// 7 × 143 modulo 1000 = 1, so 7 has an inverse 143.
// 7 ^ -5 modulo 1000 = 143 ^ 5 modulo 1000 = 943.
n.assign(7);
match n.pow_mod_mut(&e, &m) {
    Ok(()) => assert_eq!(n, 943),
    Err(()) => unreachable!(),
}

pub fn pow_mod_ref<'a>( &'a self, exponent: &'a Self, modulo: &'a Self ) -> Option<PowModIncomplete<'a>>

Raises a number to the power of exponent modulo modulo if an answer exists.

If the exponent is negative, then the number must have an inverse for an answer to exist.

The following are implemented with the unwrapped returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let two = Integer::from(2);
let thousand = Integer::from(1000);
let minus_five = Integer::from(-5);
let seven = Integer::from(7);

// Modulo 1000, 2 has no inverse: there is no i such that 2 × i = 1.
assert!(two.pow_mod_ref(&minus_five, &thousand).is_none());

// 7 × 143 modulo 1000 = 1, so 7 has an inverse 143.
// 7 ^ -5 modulo 1000 = 143 ^ 5 modulo 1000 = 943.
let r = seven.pow_mod_ref(&minus_five, &thousand).unwrap();
let power = Integer::from(r);
assert_eq!(power, 943);

pub fn secure_pow_mod(self, exponent: &Self, modulo: &Self) -> Self

Raises a number to the power of exponent modulo modulo, with resilience to side-channel attacks.

The exponent must be greater than zero, and the modulo must be odd.

This method is intended for cryptographic purposes where resilience to side-channel attacks is desired. The function is designed to take the same time and use the same cache access patterns for same-sized arguments, assuming that the arguments are placed at the same position and the machine state is identical when starting.

Panics

Panics if exponent ≤ 0 or if modulo is even.

Examples

use rug::Integer;
// 7 ^ 4 mod 13 = 9
let n = Integer::from(7);
let e = Integer::from(4);
let m = Integer::from(13);
let power = n.secure_pow_mod(&e, &m);
assert_eq!(power, 9);

pub fn secure_pow_mod_mut(&mut self, exponent: &Self, modulo: &Self)

Raises a number to the power of exponent modulo modulo, with resilience to side-channel attacks.

The exponent must be greater than zero, and the modulo must be odd.

This method is intended for cryptographic purposes where resilience to side-channel attacks is desired. The function is designed to take the same time and use the same cache access patterns for same-sized arguments, assuming that the arguments are placed at the same position and the machine state is identical when starting.

Panics

Panics if exponent ≤ 0 or if modulo is even.

Examples

use rug::Integer;
// 7 ^ 4 mod 13 = 9
let mut n = Integer::from(7);
let e = Integer::from(4);
let m = Integer::from(13);
n.secure_pow_mod_mut(&e, &m);
assert_eq!(n, 9);

pub fn secure_pow_mod_ref<'a>( &'a self, exponent: &'a Self, modulo: &'a Self ) -> SecurePowModIncomplete<'a>

Raises a number to the power of exponent modulo modulo, with resilience to side-channel attacks.

The exponent must be greater than zero, and the modulo must be odd.

This method is intended for cryptographic purposes where resilience to side-channel attacks is desired. The function is designed to take the same time and use the same cache access patterns for same-sized arguments, assuming that the arguments are placed at the same position and the machine state is identical when starting.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Panics

Panics if exponent ≤ 0 or if modulo is even.

Examples

use rug::Integer;
// 7 ^ 4 mod 13 = 9
let n = Integer::from(7);
let e = Integer::from(4);
let m = Integer::from(13);
let power = Integer::from(n.secure_pow_mod_ref(&e, &m));
assert_eq!(power, 9);

pub fn u_pow_u(base: u32, exponent: u32) -> UPowUIncomplete

Raises base to the power of exponent.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::{Complete, Integer};
assert_eq!(Integer::u_pow_u(13, 12).complete(), 13_u64.pow(12));

pub fn i_pow_u(base: i32, exponent: u32) -> IPowUIncomplete

Raises base to the power of exponent.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::{Assign, Integer};
let mut ans = Integer::new();
ans.assign(Integer::i_pow_u(-13, 13));
assert_eq!(ans, (-13_i64).pow(13));
ans.assign(Integer::i_pow_u(13, 13));
assert_eq!(ans, (13_i64).pow(13));

pub fn root(self, n: u32) -> Self

Computes the nth root and truncates the result.

Panics

Panics if n is zero or if n is even and the value is negative.

Examples

use rug::Integer;
let i = Integer::from(1004);
let root = i.root(3);
assert_eq!(root, 10);

pub fn root_mut(&mut self, n: u32)

Computes the nth root and truncates the result.

Panics

Panics if n is zero or if n is even and the value is negative.

Examples

use rug::Integer;
let mut i = Integer::from(1004);
i.root_mut(3);
assert_eq!(i, 10);

pub fn root_ref(&self, n: u32) -> RootIncomplete<'_>

Computes the nth root and truncates the result.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(1004);
assert_eq!(Integer::from(i.root_ref(3)), 10);

pub fn root_rem(self, remainder: Self, n: u32) -> (Self, Self)

Computes the nth root and returns the truncated root and the remainder.

The remainder is the original number minus the truncated root raised to the power of n.

The initial value of remainder is ignored.

Panics

Panics if n is zero or if n is even and the value is negative.

Examples

use rug::Integer;
let i = Integer::from(1004);
let (root, rem) = i.root_rem(Integer::new(), 3);
assert_eq!(root, 10);
assert_eq!(rem, 4);

pub fn root_rem_mut(&mut self, remainder: &mut Self, n: u32)

Computes the nth root and returns the truncated root and the remainder.

The remainder is the original number minus the truncated root raised to the power of n.

The initial value of remainder is ignored.

Panics

Panics if n is zero or if n is even and the value is negative.

Examples

use rug::Integer;
let mut i = Integer::from(1004);
let mut rem = Integer::new();
i.root_rem_mut(&mut rem, 3);
assert_eq!(i, 10);
assert_eq!(rem, 4);

pub fn root_rem_ref(&self, n: u32) -> RootRemIncomplete<'_>

Computes the nth root and returns the truncated root and the remainder.

The remainder is the original number minus the truncated root raised to the power of n.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Integer, Integer)
• Assign<Src> for (&mut Integer, &mut Integer)
• From<Src> for (Integer, Integer)
• Complete<Completed = (Integer, Integer)> for Src

Examples

use rug::{Assign, Complete, Integer};
let i = Integer::from(1004);
let mut root = Integer::new();
let mut rem = Integer::new();
// 1004 = 10^3 + 5
(&mut root, &mut rem).assign(i.root_rem_ref(3));
assert_eq!(root, 10);
assert_eq!(rem, 4);
// 1004 = 3^6 + 275
let (other_root, other_rem) = i.root_rem_ref(6).complete();
assert_eq!(other_root, 3);
assert_eq!(other_rem, 275);

pub fn square(self) -> Self

Computes the square.

This method cannot be replaced by a multiplication using the * operator: i * i and i * &i are both errors.

Examples

use rug::Integer;
let i = Integer::from(13);
let square = i.square();
assert_eq!(square, 169);

pub fn square_mut(&mut self)

Computes the square.

This method cannot be replaced by a compound multiplication and assignment using the *= operataor: i *= i; and i *= &i; are both errors.

Examples

use rug::Integer;
let mut i = Integer::from(13);
i.square_mut();
assert_eq!(i, 169);

pub fn square_ref(&self) -> MulIncomplete<'_>

Computes the square.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src
• AddAssign<Src> for Integer
• Add<Src> for Integer, Add<Integer> for Src
• SubAssign<Src> for Integer, SubFrom<Src> for Integer
• Sub<Src> for Integer, Sub<Integer> for Src

i.square_ref() produces the exact same result as &i * &i.

Examples

use rug::Integer;
let i = Integer::from(13);
assert_eq!(Integer::from(i.square_ref()), 169);

pub fn sqrt(self) -> Self

Computes the square root and truncates the result.

Panics

Panics if the value is negative.

Examples

use rug::Integer;
let i = Integer::from(104);
let sqrt = i.sqrt();
assert_eq!(sqrt, 10);

pub fn sqrt_mut(&mut self)

Computes the square root and truncates the result.

Panics

Panics if the value is negative.

Examples

use rug::Integer;
let mut i = Integer::from(104);
i.sqrt_mut();
assert_eq!(i, 10);

pub fn sqrt_ref(&self) -> SqrtIncomplete<'_>

Computes the square root and truncates the result.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(104);
assert_eq!(Integer::from(i.sqrt_ref()), 10);

pub fn sqrt_rem(self, remainder: Self) -> (Self, Self)

Computes the square root and the remainder.

The remainder is the original number minus the truncated root squared.

The initial value of remainder is ignored.

Panics

Panics if the value is negative.

Examples

use rug::Integer;
let i = Integer::from(104);
let (sqrt, rem) = i.sqrt_rem(Integer::new());
assert_eq!(sqrt, 10);
assert_eq!(rem, 4);

pub fn sqrt_rem_mut(&mut self, remainder: &mut Self)

Computes the square root and the remainder.

The remainder is the original number minus the truncated root squared.

The initial value of remainder is ignored.

Panics

Panics if the value is negative.

Examples

use rug::Integer;
let mut i = Integer::from(104);
let mut rem = Integer::new();
i.sqrt_rem_mut(&mut rem);
assert_eq!(i, 10);
assert_eq!(rem, 4);

pub fn sqrt_rem_ref(&self) -> SqrtRemIncomplete<'_>

Computes the square root and the remainder.

The remainder is the original number minus the truncated root squared.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Integer, Integer)
• Assign<Src> for (&mut Integer, &mut Integer)
• From<Src> for (Integer, Integer)
• Complete<Completed = (Integer, Integer)> for Src

Examples

use rug::{Assign, Integer};
let i = Integer::from(104);
let mut sqrt = Integer::new();
let mut rem = Integer::new();
let r = i.sqrt_rem_ref();
(&mut sqrt, &mut rem).assign(r);
assert_eq!(sqrt, 10);
assert_eq!(rem, 4);
let r = i.sqrt_rem_ref();
let (other_sqrt, other_rem) = <(Integer, Integer)>::from(r);
assert_eq!(other_sqrt, 10);
assert_eq!(other_rem, 4);

pub fn is_probably_prime(&self, reps: u32) -> IsPrime

Determines wheter a number is prime.

This function uses some trial divisions, a Baille-PSW probable prime test, then reps − 24 Miller-Rabin probabilistic primality tests.

Examples

use rug::integer::IsPrime;
use rug::Integer;
let no = Integer::from(163 * 4003);
assert_eq!(no.is_probably_prime(30), IsPrime::No);
let yes = Integer::from(817_504_243);
assert_eq!(yes.is_probably_prime(30), IsPrime::Yes);
// 16_412_292_043_871_650_369 is actually a prime.
let probably = Integer::from(16_412_292_043_871_650_369_u64);
assert_eq!(probably.is_probably_prime(30), IsPrime::Probably);

pub fn next_prime(self) -> Self

Identifies primes using a probabilistic algorithm; the chance of a composite passing will be extremely small.

Examples

use rug::Integer;
let i = Integer::from(800_000_000);
let prime = i.next_prime();
assert_eq!(prime, 800_000_011);

pub fn next_prime_mut(&mut self)

Identifies primes using a probabilistic algorithm; the chance of a composite passing will be extremely small.

Examples

use rug::Integer;
let mut i = Integer::from(800_000_000);
i.next_prime_mut();
assert_eq!(i, 800_000_011);

pub fn next_prime_ref(&self) -> NextPrimeIncomplete<'_>

Identifies primes using a probabilistic algorithm; the chance of a composite passing will be extremely small.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(800_000_000);
let r = i.next_prime_ref();
let prime = Integer::from(r);
assert_eq!(prime, 800_000_011);

pub fn prev_prime(self) -> Self

Identifies previous prime number using a probabilistic algorithm; the chance of a composite passing will be extremely small.

Examples

use rug::Integer;
let i = Integer::from(800_000_000);
let prime = i.prev_prime();
assert_eq!(prime, 799_999_999);

pub fn prev_prime_mut(&mut self)

Identifies previous prime number using a probabilistic algorithm; the chance of a composite passing will be extremely small.

Examples

use rug::Integer;
let mut i = Integer::from(800_000_000);
i.prev_prime_mut();
assert_eq!(i, 799_999_999);

pub fn prev_prime_ref(&self) -> PrevPrimeIncomplete<'_>

Identifies previous prime number using a probabilistic algorithm; the chance of a composite passing will be extremely small.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(800_000_000);
let r = i.prev_prime_ref();
let prime = Integer::from(r);
assert_eq!(prime, 799_999_999);

pub fn gcd(self, other: &Self) -> Self

Finds the greatest common divisor.

The result is always positive except when both inputs are zero.

Examples

use rug::{Assign, Integer};
let a = Integer::new();
let mut b = Integer::new();
// gcd of 0, 0 is 0
let gcd1 = a.gcd(&b);
assert_eq!(gcd1, 0);
b.assign(10);
// gcd of 0, 10 is 10
let gcd2 = gcd1.gcd(&b);
assert_eq!(gcd2, 10);
b.assign(25);
// gcd of 10, 25 is 5
let gcd3 = gcd2.gcd(&b);
assert_eq!(gcd3, 5);

pub fn gcd_mut(&mut self, other: &Self)

Finds the greatest common divisor.

The result is always positive except when both inputs are zero.

Examples

use rug::{Assign, Integer};
let mut a = Integer::new();
let mut b = Integer::new();
// gcd of 0, 0 is 0
a.gcd_mut(&b);
assert_eq!(a, 0);
b.assign(10);
// gcd of 0, 10 is 10
a.gcd_mut(&b);
assert_eq!(a, 10);
b.assign(25);
// gcd of 10, 25 is 5
a.gcd_mut(&b);
assert_eq!(a, 5);

pub fn gcd_ref<'a>(&'a self, other: &'a Self) -> GcdIncomplete<'_>

Finds the greatest common divisor.

The result is always positive except when both inputs are zero.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let a = Integer::from(100);
let b = Integer::from(125);
let r = a.gcd_ref(&b);
// gcd of 100, 125 is 25
assert_eq!(Integer::from(r), 25);

pub fn gcd_u(self, other: u32) -> Self

Finds the greatest common divisor.

The result is always positive except when both inputs are zero.

Examples

use rug::Integer;
let i = Integer::new();
// gcd of 0, 0 is 0
let gcd1 = i.gcd_u(0);
assert_eq!(gcd1, 0);
// gcd of 0, 10 is 10
let gcd2 = gcd1.gcd_u(10);
assert_eq!(gcd2, 10);
// gcd of 10, 25 is 5
let gcd3 = gcd2.gcd_u(25);
assert_eq!(gcd3, 5);

pub fn gcd_u_mut(&mut self, other: u32)

Finds the greatest common divisor.

The result is always positive except when both inputs are zero.

Examples

use rug::Integer;
let mut i = Integer::new();
// gcd of 0, 0 is 0
i.gcd_u_mut(0);
assert_eq!(i, 0);
// gcd of 0, 10 is 10
i.gcd_u_mut(10);
assert_eq!(i, 10);
// gcd of 10, 25 is 5
i.gcd_u_mut(25);
assert_eq!(i, 5);

pub fn gcd_u_ref(&self, other: u32) -> GcdUIncomplete<'_>

Finds the greatest common divisor.

The result is always positive except when both inputs are zero.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• From<Src> for Option<u32>
• Complete<Completed = Integer> for Src

The implementation of From<Src> for Option<u32> is useful to obtain the result as a u32 if it fits. If other > 0 , the result always fits. If the result does not fit, it is equal to the absolute value of self.

Examples

use rug::Integer;
let i = Integer::from(100);
let r = i.gcd_u_ref(125);
// gcd of 100, 125 is 25
assert_eq!(Integer::from(r), 25);
let r = i.gcd_u_ref(125);
assert_eq!(Option::<u32>::from(r), Some(25));

pub fn extended_gcd(self, other: Self, rop: Self) -> (Self, Self, Self)

Finds the greatest common divisor (GCD) of the two inputs (self and other), and two coefficients to obtain the GCD from the two inputs.

The GCD is always positive except when both inputs are zero. If the inputs are a and b, then the GCD is g and the coefficients are s and t such that

a × s + b × t = g

The values s and t are chosen such that normally, |s| < |b| / (2g) and |t| < |a| / (2g), and these relations define s and t uniquely. There are a few exceptional cases:

• If |a| = |b|, then s = 0, t = sgn(b).
• Otherwise, if b = 0 or |b| = 2g, then s = sgn(a), and if a = 0 or |a| = 2g, then t = sgn(b).

The initial value of rop is ignored.

Examples

use rug::Integer;
let a = Integer::from(4);
let b = Integer::from(6);
let (g, s, t) = a.extended_gcd(b, Integer::new());
assert_eq!(g, 2);
assert_eq!(s, -1);
assert_eq!(t, 1);

pub fn extended_gcd_mut(&mut self, other: &mut Self, rop: &mut Self)

Finds the greatest common divisor (GCD) of the two inputs (self and other), and two coefficients to obtain the GCD from the two inputs.

The GCD is stored in self, and the two coefficients are stored in other and rop.

The GCD is always positive except when both inputs are zero. If the inputs are a and b, then the GCD is g and the coefficients are s and t such that

a × s + b × t = g

The values s and t are chosen such that normally, |s| < |b| / (2g) and |t| < |a| / (2g), and these relations define s and t uniquely. There are a few exceptional cases:

• If |a| = |b|, then s = 0, t = sgn(b).
• Otherwise, if b = 0 or |b| = 2g, then s = sgn(a), and if a = 0 or |a| = 2g, then t = sgn(b).

The initial value of rop is ignored.

Examples

use rug::Integer;
let mut a_g = Integer::from(4);
let mut b_s = Integer::from(6);
let mut t = Integer::new();
a_g.extended_gcd_mut(&mut b_s, &mut t);
assert_eq!(a_g, 2);
assert_eq!(b_s, -1);
assert_eq!(t, 1);

pub fn extended_gcd_ref<'a>(&'a self, other: &'a Self) -> GcdExtIncomplete<'_>

Finds the greatest common divisor (GCD) of the two inputs (self and other), and two coefficients to obtain the GCD from the two inputs.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Integer, Integer, Integer)
• Assign<Src> for (&mut Integer, &mut Integer, &mut Integer)
• From<Src> for (Integer, Integer, Integer)
• Complete<Completed = (Integer, Integer, Integer)> for Src

In the case that only one of the two coefficients is required, the following are also implemented:

• Assign<Src> for (Integer, Integer)
• Assign<Src> for (&mut Integer, &mut Integer)
• From<Src> for (Integer, Integer)

The GCD is always positive except when both inputs are zero. If the inputs are a and b, then the GCD is g and the coefficients are s and t such that

a × s + b × t = g

The values s and t are chosen such that normally, |s| < |b| / (2g) and |t| < |a| / (2g), and these relations define s and t uniquely. There are a few exceptional cases:

• If |a| = |b|, then s = 0, t = sgn(b).
• Otherwise, if b = 0 or |b| = 2g, then s = sgn(a), and if a = 0 or |a| = 2g, then t = sgn(b).

Examples

use rug::{Assign, Integer};
let a = Integer::from(4);
let b = Integer::from(6);
let r = a.extended_gcd_ref(&b);
let mut g = Integer::new();
let mut s = Integer::new();
let mut t = Integer::new();
(&mut g, &mut s, &mut t).assign(r);
assert_eq!(a, 4);
assert_eq!(b, 6);
assert_eq!(g, 2);
assert_eq!(s, -1);
assert_eq!(t, 1);

In the case that only one of the two coefficients is required, this can be achieved as follows:

use rug::{Assign, Integer};
let a = Integer::from(4);
let b = Integer::from(6);

// no t required
let (mut g1, mut s1) = (Integer::new(), Integer::new());
(&mut g1, &mut s1).assign(a.extended_gcd_ref(&b));
assert_eq!(g1, 2);
assert_eq!(s1, -1);

// no s required
let (mut g2, mut t2) = (Integer::new(), Integer::new());
(&mut g2, &mut t2).assign(b.extended_gcd_ref(&a));
assert_eq!(g2, 2);
assert_eq!(t2, 1);

pub fn lcm(self, other: &Self) -> Self

Finds the least common multiple.

The result is always positive except when one or both inputs are zero.

Examples

use rug::{Assign, Integer};
let a = Integer::from(10);
let mut b = Integer::from(25);
// lcm of 10, 25 is 50
let lcm1 = a.lcm(&b);
assert_eq!(lcm1, 50);
b.assign(0);
// lcm of 50, 0 is 0
let lcm2 = lcm1.lcm(&b);
assert_eq!(lcm2, 0);

pub fn lcm_mut(&mut self, other: &Self)

Finds the least common multiple.

The result is always positive except when one or both inputs are zero.

Examples

use rug::{Assign, Integer};
let mut a = Integer::from(10);
let mut b = Integer::from(25);
// lcm of 10, 25 is 50
a.lcm_mut(&b);
assert_eq!(a, 50);
b.assign(0);
// lcm of 50, 0 is 0
a.lcm_mut(&b);
assert_eq!(a, 0);

pub fn lcm_ref<'a>(&'a self, other: &'a Self) -> LcmIncomplete<'_>

Finds the least common multiple.

The result is always positive except when one or both inputs are zero.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let a = Integer::from(100);
let b = Integer::from(125);
let r = a.lcm_ref(&b);
// lcm of 100, 125 is 500
assert_eq!(Integer::from(r), 500);

pub fn lcm_u(self, other: u32) -> Self

Finds the least common multiple.

The result is always positive except when one or both inputs are zero.

Examples

use rug::Integer;
let i = Integer::from(10);
// lcm of 10, 25 is 50
let lcm1 = i.lcm_u(25);
assert_eq!(lcm1, 50);
// lcm of 50, 0 is 0
let lcm2 = lcm1.lcm_u(0);
assert_eq!(lcm2, 0);

pub fn lcm_u_mut(&mut self, other: u32)

Finds the least common multiple.

The result is always positive except when one or both inputs are zero.

Examples

use rug::Integer;
let mut i = Integer::from(10);
// lcm of 10, 25 is 50
i.lcm_u_mut(25);
assert_eq!(i, 50);
// lcm of 50, 0 is 0
i.lcm_u_mut(0);
assert_eq!(i, 0);

pub fn lcm_u_ref(&self, other: u32) -> LcmUIncomplete<'_>

Finds the least common multiple.

The result is always positive except when one or both inputs are zero.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
let i = Integer::from(100);
let r = i.lcm_u_ref(125);
// lcm of 100, 125 is 500
assert_eq!(Integer::from(r), 500);

pub fn jacobi(&self, n: &Self) -> i32

Calculates the Jacobi symbol (self/n).

Examples

use rug::{Assign, Integer};
let m = Integer::from(10);
let mut n = Integer::from(13);
assert_eq!(m.jacobi(&n), 1);
n.assign(15);
assert_eq!(m.jacobi(&n), 0);
n.assign(17);
assert_eq!(m.jacobi(&n), -1);

pub fn legendre(&self, p: &Self) -> i32

Calculates the Legendre symbol (self/p).

Examples

use rug::{Assign, Integer};
let a = Integer::from(5);
let mut p = Integer::from(7);
assert_eq!(a.legendre(&p), -1);
p.assign(11);
assert_eq!(a.legendre(&p), 1);

pub fn kronecker(&self, n: &Self) -> i32

Calculates the Jacobi symbol (self/n) with the Kronecker extension.

Examples

use rug::{Assign, Integer};
let k = Integer::from(3);
let mut n = Integer::from(16);
assert_eq!(k.kronecker(&n), 1);
n.assign(17);
assert_eq!(k.kronecker(&n), -1);
n.assign(18);
assert_eq!(k.kronecker(&n), 0);

pub fn remove_factor(self, factor: &Self) -> (Self, u32)

Removes all occurrences of factor, and returns the number of occurrences removed.

Examples

use rug::Integer;
let mut i = Integer::from(Integer::u_pow_u(13, 50));
i *= 1000;
let (remove, count) = i.remove_factor(&Integer::from(13));
assert_eq!(remove, 1000);
assert_eq!(count, 50);

pub fn remove_factor_mut(&mut self, factor: &Self) -> u32

Removes all occurrences of factor, and returns the number of occurrences removed.

Examples

use rug::Integer;
let mut i = Integer::from(Integer::u_pow_u(13, 50));
i *= 1000;
let count = i.remove_factor_mut(&Integer::from(13));
assert_eq!(i, 1000);
assert_eq!(count, 50);

pub fn remove_factor_ref<'a>( &'a self, factor: &'a Self ) -> RemoveFactorIncomplete<'a>

Removes all occurrences of factor, and counts the number of occurrences removed.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Integer, u32)
• Assign<Src> for (&mut Integer, &mut u32)
• From<Src> for (Integer, u32)
• Complete<Completed = (Integer, u32)> for Src

Examples

use rug::{Assign, Integer};
let mut i = Integer::from(Integer::u_pow_u(13, 50));
i *= 1000;
let factor = Integer::from(13);
let r = i.remove_factor_ref(&factor);
let (mut j, mut count) = (Integer::new(), 0);
(&mut j, &mut count).assign(r);
assert_eq!(count, 50);
assert_eq!(j, 1000);

pub fn factorial(n: u32) -> FactorialIncomplete

Computes the factorial of n.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::{Complete, Integer};
// 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1
assert_eq!(Integer::factorial(10).complete(), 3628800);

pub fn factorial_2(n: u32) -> Factorial2Incomplete

Computes the double factorial of n.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::{Complete, Integer};
// 10 × 8 × 6 × 4 × 2
assert_eq!(Integer::factorial_2(10).complete(), 3840);

pub fn factorial_m(n: u32, m: u32) -> FactorialMIncomplete

Computes the m-multi factorial of n.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::{Complete, Integer};
// 10 × 7 × 4 × 1
assert_eq!(Integer::factorial_m(10, 3).complete(), 280);

pub fn primorial(n: u32) -> PrimorialIncomplete

Computes the primorial of n.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::{Complete, Integer};
// 7 × 5 × 3 × 2
assert_eq!(Integer::primorial(10).complete(), 210);

pub fn binomial(self, k: u32) -> Self

Computes the binomial coefficient over k.

Examples

use rug::Integer;
// 7 choose 2 is 21
let i = Integer::from(7);
let bin = i.binomial(2);
assert_eq!(bin, 21);

pub fn binomial_mut(&mut self, k: u32)

Computes the binomial coefficient over k.

Examples

use rug::Integer;
// 7 choose 2 is 21
let mut i = Integer::from(7);
i.binomial_mut(2);
assert_eq!(i, 21);

pub fn binomial_ref(&self, k: u32) -> BinomialIncomplete<'_>

Computes the binomial coefficient over k.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::{Complete, Integer};
// 7 choose 2 is 21
let i = Integer::from(7);
assert_eq!(i.binomial_ref(2).complete(), 21);

pub fn binomial_u(n: u32, k: u32) -> BinomialUIncomplete

Computes the binomial coefficient n over k.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::Integer;
// 7 choose 2 is 21
let b = Integer::binomial_u(7, 2);
let i = Integer::from(b);
assert_eq!(i, 21);

pub fn fibonacci(n: u32) -> FibonacciIncomplete

Computes the Fibonacci number.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

This function is meant for an isolated number. If a sequence of Fibonacci numbers is required, the first two values of the sequence should be computed with the fibonacci_2 method, then iterations should be used.

Examples

use rug::{Complete, Integer};
assert_eq!(Integer::fibonacci(12).complete(), 144);

pub fn fibonacci_2(n: u32) -> Fibonacci2Incomplete

Computes a Fibonacci number, and the previous Fibonacci number.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Integer, Integer)
• Assign<Src> for (&mut Integer, &mut Integer)
• From<Src> for (Integer, Integer)
• Complete<Completed = (Integer, Integer)> for Src

This function is meant to calculate isolated numbers. If a sequence of Fibonacci numbers is required, the first two values of the sequence should be computed with this function, then iterations should be used.

Examples

use rug::{Assign, Integer};
let f = Integer::fibonacci_2(12);
let mut pair = <(Integer, Integer)>::from(f);
assert_eq!(pair.0, 144);
assert_eq!(pair.1, 89);
// Fibonacci number F[-1] is 1
pair.assign(Integer::fibonacci_2(0));
assert_eq!(pair.0, 0);
assert_eq!(pair.1, 1);

pub fn lucas(n: u32) -> LucasIncomplete

Computes the Lucas number.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

This function is meant for an isolated number. If a sequence of Lucas numbers is required, the first two values of the sequence should be computed with the lucas_2 method, then iterations should be used.

Examples

use rug::{Complete, Integer};
assert_eq!(Integer::lucas(12).complete(), 322);

pub fn lucas_2(n: u32) -> Lucas2Incomplete

Computes a Lucas number, and the previous Lucas number.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for (Integer, Integer)
• Assign<Src> for (&mut Integer, &mut Integer)
• From<Src> for (Integer, Integer)
• Complete<Completed = (Integer, Integer)> for Src

This function is meant to calculate isolated numbers. If a sequence of Lucas numbers is required, the first two values of the sequence should be computed with this function, then iterations should be used.

Examples

use rug::{Assign, Integer};
let l = Integer::lucas_2(12);
let mut pair = <(Integer, Integer)>::from(l);
assert_eq!(pair.0, 322);
assert_eq!(pair.1, 199);
pair.assign(Integer::lucas_2(0));
assert_eq!(pair.0, 2);
assert_eq!(pair.1, -1);

pub fn random_bits( bits: u32, rng: &mut dyn MutRandState ) -> RandomBitsIncomplete<'_>

Generates a random number with a specified maximum number of bits.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Examples

use rug::rand::RandState;
use rug::{Assign, Integer};
let mut rand = RandState::new();
let mut i = Integer::from(Integer::random_bits(0, &mut rand));
assert_eq!(i, 0);
i.assign(Integer::random_bits(80, &mut rand));
assert!(i.significant_bits() <= 80);

pub fn random_below(self, rng: &mut dyn MutRandState) -> Self

Generates a non-negative random number below the given boundary value.

Panics

Panics if the boundary value is less than or equal to zero.

Examples

use rug::rand::RandState;
use rug::Integer;
let mut rand = RandState::new();
let i = Integer::from(15);
let below = i.random_below(&mut rand);
println!("0 ≤ {} < 15", below);
assert!(below < 15);

pub fn random_below_mut(&mut self, rng: &mut dyn MutRandState)

Generates a non-negative random number below the given boundary value.

Panics

Panics if the boundary value is less than or equal to zero.

Examples

use rug::rand::RandState;
use rug::Integer;
let mut rand = RandState::new();
let mut i = Integer::from(15);
i.random_below_mut(&mut rand);
println!("0 ≤ {} < 15", i);
assert!(i < 15);

pub fn random_below_ref<'a>( &'a self, rng: &'a mut dyn MutRandState ) -> RandomBelowIncomplete<'a>

Generates a non-negative random number below the given boundary value.

The following are implemented with the returned incomplete-computation value as Src:

• Assign<Src> for Integer
• From<Src> for Integer
• Complete<Completed = Integer> for Src

Panics

Panics if the boundary value is less than or equal to zero.

Examples

use rug::rand::RandState;
use rug::Integer;
let mut rand = RandState::new();
let bound = Integer::from(15);
let i = Integer::from(bound.random_below_ref(&mut rand));
println!("0 ≤ {} < {}", i, bound);
assert!(i < bound);

pub fn gcd_cofactors(self, other: Self, rop: Self) -> (Self, Self, Self)

👎Deprecated since 1.18.0: renamed to extended_gcd

This method has been renamed to extended_gcd.

pub fn gcd_cofactors_mut(&mut self, other: &mut Self, rop: &mut Self)

👎Deprecated since 1.18.0: renamed to extended_gcd_mut

This method has been renamed to extended_gcd_mut.

pub fn gcd_cofactors_ref<'a>(&'a self, other: &'a Self) -> GcdExtIncomplete<'_>

👎Deprecated since 1.18.0: renamed to extended_gcd_ref

This method has been renamed to extended_gcd_ref.

Trait Implementations

impl<'a> Add<&'a Complex> for &'a Integer

type Output = AddIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Complex) -> AddIntegerIncomplete<'_>

Performs the + operation.

impl<'a> Add<&'a Complex> for Integer

type Output = AddOwnedIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &Complex) -> AddOwnedIntegerIncomplete<'_>

Performs the + operation.

impl<'a> Add<&'a Float> for &'a Integer

type Output = AddIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Float) -> AddIntegerIncomplete<'_>

Performs the + operation.

impl<'a> Add<&'a Float> for Integer

type Output = AddOwnedIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &Float) -> AddOwnedIntegerIncomplete<'_>

Performs the + operation.

impl<'a> Add<&'a Integer> for &'a Complex

type Output = AddIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Integer) -> AddIntegerIncomplete<'_>

Performs the + operation.

impl<'a> Add<&'a Integer> for &'a Float

type Output = AddIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Integer) -> AddIntegerIncomplete<'_>

Performs the + operation.

impl<'a> Add<&'a Integer> for &'a Rational

type Output = AddIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Integer) -> AddIntegerIncomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &i128

type Output = AddI128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddI128Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &i16

type Output = AddI16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddI16Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &i32

type Output = AddI32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddI32Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &i64

type Output = AddI64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddI64Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &i8

type Output = AddI8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddI8Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &isize

type Output = AddIsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddIsizeIncomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &u128

type Output = AddU128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddU128Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &u16

type Output = AddU16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddU16Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &u32

type Output = AddU32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddU32Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &u64

type Output = AddU64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddU64Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &u8

type Output = AddU8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddU8Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for &usize

type Output = AddUsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddUsizeIncomplete<'_>

Performs the + operation.

impl Add<&Integer> for Complex

type Output = Complex

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> Complex

Performs the + operation.

impl Add<&Integer> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> Float

Performs the + operation.

impl Add<&Integer> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&Integer> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> Rational

Performs the + operation.

impl<'b> Add<&'b Integer> for i128

type Output = AddI128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddI128Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for i16

type Output = AddI16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddI16Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for i32

type Output = AddI32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddI32Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for i64

type Output = AddI64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddI64Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for i8

type Output = AddI8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddI8Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for isize

type Output = AddIsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddIsizeIncomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for u128

type Output = AddU128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddU128Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for u16

type Output = AddU16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddU16Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for u32

type Output = AddU32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddU32Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for u64

type Output = AddU64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddU64Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for u8

type Output = AddU8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddU8Incomplete<'_>

Performs the + operation.

impl<'b> Add<&'b Integer> for usize

type Output = AddUsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &Integer) -> AddUsizeIncomplete<'_>

Performs the + operation.

impl<'a> Add<&'a Rational> for &'a Integer

type Output = AddIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Rational) -> AddIntegerIncomplete<'_>

Performs the + operation.

impl<'a> Add<&'a Rational> for Integer

type Output = AddOwnedIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Rational) -> AddOwnedIntegerIncomplete<'a>

Performs the + operation.

impl<'b> Add<&i128> for &'b Integer

type Output = AddI128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i128) -> AddI128Incomplete<'b>

Performs the + operation.

impl Add<&i128> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<&i16> for &'b Integer

type Output = AddI16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> AddI16Incomplete<'b>

Performs the + operation.

impl Add<&i16> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<&i32> for &'b Integer

type Output = AddI32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> AddI32Incomplete<'b>

Performs the + operation.

impl Add<&i32> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<&i64> for &'b Integer

type Output = AddI64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> AddI64Incomplete<'b>

Performs the + operation.

impl Add<&i64> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<&i8> for &'b Integer

type Output = AddI8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &i8) -> AddI8Incomplete<'b>

Performs the + operation.

impl Add<&i8> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<&isize> for &'b Integer

type Output = AddIsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> AddIsizeIncomplete<'b>

Performs the + operation.

impl Add<&isize> for Integer

type Output = Integer

The resulting type after applying the + operator.

fn add(self, rhs: &isize) -> Integer

Performs the + operation.

impl<'b> Add<&u128> for &'b Integer

type Output = AddU128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> AddU128Incomplete<'b>

Performs the + operation.

impl Add<&u128> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<&u16> for &'b Integer

type Output = AddU16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> AddU16Incomplete<'b>

Performs the + operation.

impl Add<&u16> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<&u32> for &'b Integer

type Output = AddU32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> AddU32Incomplete<'b>

Performs the + operation.

impl Add<&u32> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<&u64> for &'b Integer

type Output = AddU64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> AddU64Incomplete<'b>

Performs the + operation.

impl Add<&u64> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<&u8> for &'b Integer

type Output = AddU8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> AddU8Incomplete<'b>

Performs the + operation.

impl Add<&u8> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<&usize> for &'b Integer

type Output = AddUsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> AddUsizeIncomplete<'b>

Performs the + operation.

impl Add<&usize> for Integer

type Output = Integer

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> Integer

Performs the + operation.

impl Add<Complex> for &Integer

type Output = Complex

The resulting type after applying the + operator.

fn add(self, rhs: Complex) -> Complex

Performs the + operation.

impl Add<Complex> for Integer

type Output = Complex

The resulting type after applying the + operator.

fn add(self, rhs: Complex) -> Complex

Performs the + operation.

impl Add<Float> for &Integer

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: Float) -> Float

Performs the + operation.

impl Add<Float> for Integer

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: Float) -> Float

Performs the + operation.

impl<'a> Add<Integer> for &'a Complex

type Output = AddOwnedIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> AddOwnedIntegerIncomplete<'a>

Performs the + operation.

impl<'a> Add<Integer> for &'a Float

type Output = AddOwnedIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> AddOwnedIntegerIncomplete<'a>

Performs the + operation.

impl Add<Integer> for &Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> Add<Integer> for &'a Rational

type Output = AddOwnedIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> AddOwnedIntegerIncomplete<'a>

Performs the + operation.

impl Add<Integer> for &i128

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for &i16

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for &i32

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for &i64

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for &i8

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for &isize

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for &u128

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for &u16

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for &u32

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for &u64

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for &u8

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for &usize

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for Complex

type Output = Complex

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> Complex

Performs the + operation.

impl Add<Integer> for Float

type Output = Float

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> Float

Performs the + operation.

impl Add<Integer> for Rational

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> Rational

Performs the + operation.

impl Add<Integer> for i128

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for i16

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for i32

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for i64

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for i8

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for isize

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for u128

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for u16

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for u32

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for u64

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for u8

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Integer> for usize

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Rational> for &Integer

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: Rational) -> Rational

Performs the + operation.

impl Add<Rational> for Integer

type Output = Rational

The resulting type after applying the + operator.

fn add(self, rhs: Rational) -> Rational

Performs the + operation.

impl<'b> Add<i128> for &'b Integer

type Output = AddI128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> AddI128Incomplete<'b>

Performs the + operation.

impl Add<i128> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<i16> for &'b Integer

type Output = AddI16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> AddI16Incomplete<'b>

Performs the + operation.

impl Add<i16> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<i32> for &'b Integer

type Output = AddI32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> AddI32Incomplete<'b>

Performs the + operation.

impl Add<i32> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<i64> for &'b Integer

type Output = AddI64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> AddI64Incomplete<'b>

Performs the + operation.

impl Add<i64> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<i8> for &'b Integer

type Output = AddI8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> AddI8Incomplete<'b>

Performs the + operation.

impl Add<i8> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<isize> for &'b Integer

type Output = AddIsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> AddIsizeIncomplete<'b>

Performs the + operation.

impl Add<isize> for Integer

type Output = Integer

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> Integer

Performs the + operation.

impl<'b> Add<u128> for &'b Integer

type Output = AddU128Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> AddU128Incomplete<'b>

Performs the + operation.

impl Add<u128> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<u16> for &'b Integer

type Output = AddU16Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> AddU16Incomplete<'b>

Performs the + operation.

impl Add<u16> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<u32> for &'b Integer

type Output = AddU32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> AddU32Incomplete<'b>

Performs the + operation.

impl Add<u32> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<u64> for &'b Integer

type Output = AddU64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> AddU64Incomplete<'b>

Performs the + operation.

impl Add<u64> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<u8> for &'b Integer

type Output = AddU8Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> AddU8Incomplete<'b>

Performs the + operation.

impl Add<u8> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'b> Add<usize> for &'b Integer

type Output = AddUsizeIncomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> AddUsizeIncomplete<'b>

Performs the + operation.

impl Add<usize> for Integer

type Output = Integer

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Integer

Performs the + operation.

impl<'a> Add for &'a Integer

type Output = AddIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Integer) -> AddIncomplete<'_>

Performs the + operation.

impl Add for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&Integer> for Complex

fn add_assign(&mut self, rhs: &Integer)

Performs the += operation.

impl AddAssign<&Integer> for Float

fn add_assign(&mut self, rhs: &Integer)

Performs the += operation.

impl AddAssign<&Integer> for Integer

fn add_assign(&mut self, rhs: &Integer)

Performs the += operation.

impl AddAssign<&Integer> for Rational

fn add_assign(&mut self, rhs: &Integer)

Performs the += operation.

impl AddAssign<&i128> for Integer

fn add_assign(&mut self, rhs: &i128)

Performs the += operation.

impl AddAssign<&i16> for Integer

fn add_assign(&mut self, rhs: &i16)

Performs the += operation.

impl AddAssign<&i32> for Integer

fn add_assign(&mut self, rhs: &i32)

Performs the += operation.

impl AddAssign<&i64> for Integer

fn add_assign(&mut self, rhs: &i64)

Performs the += operation.

impl AddAssign<&i8> for Integer

fn add_assign(&mut self, rhs: &i8)

Performs the += operation.

impl AddAssign<&isize> for Integer

fn add_assign(&mut self, rhs: &isize)

Performs the += operation.

impl AddAssign<&u128> for Integer

fn add_assign(&mut self, rhs: &u128)

Performs the += operation.

impl AddAssign<&u16> for Integer

fn add_assign(&mut self, rhs: &u16)

Performs the += operation.

impl AddAssign<&u32> for Integer

fn add_assign(&mut self, rhs: &u32)

Performs the += operation.

impl AddAssign<&u64> for Integer

fn add_assign(&mut self, rhs: &u64)

Performs the += operation.

impl AddAssign<&u8> for Integer

fn add_assign(&mut self, rhs: &u8)

Performs the += operation.

impl AddAssign<&usize> for Integer

fn add_assign(&mut self, rhs: &usize)

Performs the += operation.

impl AddAssign<Integer> for Complex

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

impl AddAssign<Integer> for Float

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

impl AddAssign<Integer> for Rational

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

impl AddAssign<i128> for Integer

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

impl AddAssign<i16> for Integer

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl AddAssign<i32> for Integer

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl AddAssign<i64> for Integer

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl AddAssign<i8> for Integer

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl AddAssign<isize> for Integer

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl AddAssign<u128> for Integer

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl AddAssign<u16> for Integer

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl AddAssign<u32> for Integer

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AddAssign<u64> for Integer

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl AddAssign<u8> for Integer

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl AddAssign<usize> for Integer

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl AddAssign for Integer

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

impl AddAssignRound<&Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round( &mut self, rhs: &Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the addition.

impl AddAssignRound<&Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering

Performs the addition.

impl AddAssignRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round( &mut self, rhs: Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the addition.

impl AddAssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering

Performs the addition.

impl AddFrom<&Integer> for Complex

fn add_from(&mut self, lhs: &Integer)

Peforms the addition.

impl AddFrom<&Integer> for Float

fn add_from(&mut self, lhs: &Integer)

Peforms the addition.

impl AddFrom<&Integer> for Integer

fn add_from(&mut self, lhs: &Integer)

Peforms the addition.

impl AddFrom<&Integer> for Rational

fn add_from(&mut self, lhs: &Integer)

Peforms the addition.

impl AddFrom<&i128> for Integer

fn add_from(&mut self, lhs: &i128)

Peforms the addition.

impl AddFrom<&i16> for Integer

fn add_from(&mut self, lhs: &i16)

Peforms the addition.

impl AddFrom<&i32> for Integer

fn add_from(&mut self, lhs: &i32)

Peforms the addition.

impl AddFrom<&i64> for Integer

fn add_from(&mut self, lhs: &i64)

Peforms the addition.

impl AddFrom<&i8> for Integer

fn add_from(&mut self, lhs: &i8)

Peforms the addition.

impl AddFrom<&isize> for Integer

fn add_from(&mut self, lhs: &isize)

Peforms the addition.

impl AddFrom<&u128> for Integer

fn add_from(&mut self, lhs: &u128)

Peforms the addition.

impl AddFrom<&u16> for Integer

fn add_from(&mut self, lhs: &u16)

Peforms the addition.

impl AddFrom<&u32> for Integer

fn add_from(&mut self, lhs: &u32)

Peforms the addition.

impl AddFrom<&u64> for Integer

fn add_from(&mut self, lhs: &u64)

Peforms the addition.

impl AddFrom<&u8> for Integer

fn add_from(&mut self, lhs: &u8)

Peforms the addition.

impl AddFrom<&usize> for Integer

fn add_from(&mut self, lhs: &usize)

Peforms the addition.

impl AddFrom<Integer> for Complex

fn add_from(&mut self, lhs: Integer)

Peforms the addition.

impl AddFrom<Integer> for Float

fn add_from(&mut self, lhs: Integer)

Peforms the addition.

impl AddFrom<Integer> for Rational

fn add_from(&mut self, lhs: Integer)

Peforms the addition.

impl AddFrom<i128> for Integer

fn add_from(&mut self, lhs: i128)

Peforms the addition.

impl AddFrom<i16> for Integer

fn add_from(&mut self, lhs: i16)

Peforms the addition.

impl AddFrom<i32> for Integer

fn add_from(&mut self, lhs: i32)

Peforms the addition.

impl AddFrom<i64> for Integer

fn add_from(&mut self, lhs: i64)

Peforms the addition.

impl AddFrom<i8> for Integer

fn add_from(&mut self, lhs: i8)

Peforms the addition.

impl AddFrom<isize> for Integer

fn add_from(&mut self, lhs: isize)

Peforms the addition.

impl AddFrom<u128> for Integer

fn add_from(&mut self, lhs: u128)

Peforms the addition.

impl AddFrom<u16> for Integer

fn add_from(&mut self, lhs: u16)

Peforms the addition.

impl AddFrom<u32> for Integer

fn add_from(&mut self, lhs: u32)

Peforms the addition.

impl AddFrom<u64> for Integer

fn add_from(&mut self, lhs: u64)

Peforms the addition.

impl AddFrom<u8> for Integer

fn add_from(&mut self, lhs: u8)

Peforms the addition.

impl AddFrom<usize> for Integer

fn add_from(&mut self, lhs: usize)

Peforms the addition.

impl AddFrom for Integer

fn add_from(&mut self, lhs: Integer)

Peforms the addition.

impl AddFromRound<&Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round( &mut self, lhs: &Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the addition.

impl AddFromRound<&Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering

Performs the addition.

impl AddFromRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round( &mut self, lhs: Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the addition.

impl AddFromRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn add_from_round(&mut self, lhs: Integer, round: Round) -> Ordering

Performs the addition.

impl AsRef<[u64]> for Integer

Provides a reference to the underlying digits as &[limb_t]. See as_limbs.

fn as_ref(&self) -> &[limb_t]

Converts this type into a shared reference of the (usually inferred) input type.

impl Assign<&Integer> for Integer

fn assign(&mut self, src: &Integer)

Peforms the assignement.

impl Assign<&MiniInteger> for Integer

fn assign(&mut self, src: &MiniInteger)

Peforms the assignement.

impl Assign<&SmallInteger> for Integer

fn assign(&mut self, src: &SmallInteger)

Peforms the assignement.

impl Assign<&bool> for Integer

fn assign(&mut self, src: &bool)

Peforms the assignement.

impl Assign<&i128> for Integer

fn assign(&mut self, src: &i128)

Peforms the assignement.

impl Assign<&i16> for Integer

fn assign(&mut self, src: &i16)

Peforms the assignement.

impl Assign<&i32> for Integer

fn assign(&mut self, src: &i32)

Peforms the assignement.

impl Assign<&i64> for Integer

fn assign(&mut self, src: &i64)

Peforms the assignement.

impl Assign<&i8> for Integer

fn assign(&mut self, src: &i8)

Peforms the assignement.

impl Assign<&isize> for Integer

fn assign(&mut self, src: &isize)

Peforms the assignement.

impl Assign<&u128> for Integer

fn assign(&mut self, src: &u128)

Peforms the assignement.

impl Assign<&u16> for Integer

fn assign(&mut self, src: &u16)

Peforms the assignement.

impl Assign<&u32> for Integer

fn assign(&mut self, src: &u32)

Peforms the assignement.

impl Assign<&u64> for Integer

fn assign(&mut self, src: &u64)

Peforms the assignement.

impl Assign<&u8> for Integer

fn assign(&mut self, src: &u8)

Peforms the assignement.

impl Assign<&usize> for Integer

fn assign(&mut self, src: &usize)

Peforms the assignement.

impl Assign<MiniInteger> for Integer

fn assign(&mut self, src: MiniInteger)

Peforms the assignement.

impl Assign<SmallInteger> for Integer

fn assign(&mut self, src: SmallInteger)

Peforms the assignement.

impl Assign<bool> for Integer

fn assign(&mut self, src: bool)

Peforms the assignement.

impl Assign<i128> for Integer

fn assign(&mut self, src: i128)

Peforms the assignement.

impl Assign<i16> for Integer

fn assign(&mut self, src: i16)

Peforms the assignement.

impl Assign<i32> for Integer

fn assign(&mut self, src: i32)

Peforms the assignement.

impl Assign<i64> for Integer

fn assign(&mut self, src: i64)

Peforms the assignement.

impl Assign<i8> for Integer

fn assign(&mut self, src: i8)

Peforms the assignement.

impl Assign<isize> for Integer

fn assign(&mut self, src: isize)

Peforms the assignement.

impl Assign<u128> for Integer

fn assign(&mut self, src: u128)

Peforms the assignement.

impl Assign<u16> for Integer

fn assign(&mut self, src: u16)

Peforms the assignement.

impl Assign<u32> for Integer

fn assign(&mut self, src: u32)

Peforms the assignement.

impl Assign<u64> for Integer

fn assign(&mut self, src: u64)

Peforms the assignement.

impl Assign<u8> for Integer

fn assign(&mut self, src: u8)

Peforms the assignement.

impl Assign<usize> for Integer

fn assign(&mut self, src: usize)

Peforms the assignement.

impl Assign for Integer

fn assign(&mut self, src: Integer)

Peforms the assignement.

impl AssignRound<&Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: &Integer, round: Round) -> Ordering

Peforms the assignment.

impl AssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn assign_round(&mut self, src: Integer, round: Round) -> Ordering

Peforms the assignment.

impl Binary for Integer

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl<'b> BitAnd<&'b Integer> for &i128

type Output = BitAndI128Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndI128Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for &i16

type Output = BitAndI16Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndI16Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for &i32

type Output = BitAndI32Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndI32Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for &i64

type Output = BitAndI64Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndI64Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for &i8

type Output = BitAndI8Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndI8Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for &isize

type Output = BitAndIsizeIncomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndIsizeIncomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for &u128

type Output = BitAndU128Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndU128Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for &u16

type Output = BitAndU16Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndU16Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for &u32

type Output = BitAndU32Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndU32Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for &u64

type Output = BitAndU64Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndU64Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for &u8

type Output = BitAndU8Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndU8Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for &usize

type Output = BitAndUsizeIncomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndUsizeIncomplete<'_>

Performs the & operation.

impl BitAnd<&Integer> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for i128

type Output = BitAndI128Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndI128Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for i16

type Output = BitAndI16Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndI16Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for i32

type Output = BitAndI32Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndI32Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for i64

type Output = BitAndI64Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndI64Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for i8

type Output = BitAndI8Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndI8Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for isize

type Output = BitAndIsizeIncomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndIsizeIncomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for u128

type Output = BitAndU128Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndU128Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for u16

type Output = BitAndU16Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndU16Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for u32

type Output = BitAndU32Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndU32Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for u64

type Output = BitAndU64Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndU64Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for u8

type Output = BitAndU8Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndU8Incomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&'b Integer> for usize

type Output = BitAndUsizeIncomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndUsizeIncomplete<'_>

Performs the & operation.

impl<'b> BitAnd<&i128> for &'b Integer

type Output = BitAndI128Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &i128) -> BitAndI128Incomplete<'b>

Performs the & operation.

impl BitAnd<&i128> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<&i16> for &'b Integer

type Output = BitAndI16Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &i16) -> BitAndI16Incomplete<'b>

Performs the & operation.

impl BitAnd<&i16> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<&i32> for &'b Integer

type Output = BitAndI32Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &i32) -> BitAndI32Incomplete<'b>

Performs the & operation.

impl BitAnd<&i32> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<&i64> for &'b Integer

type Output = BitAndI64Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &i64) -> BitAndI64Incomplete<'b>

Performs the & operation.

impl BitAnd<&i64> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<&i8> for &'b Integer

type Output = BitAndI8Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &i8) -> BitAndI8Incomplete<'b>

Performs the & operation.

impl BitAnd<&i8> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<&isize> for &'b Integer

type Output = BitAndIsizeIncomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &isize) -> BitAndIsizeIncomplete<'b>

Performs the & operation.

impl BitAnd<&isize> for Integer

type Output = Integer

The resulting type after applying the & operator.

fn bitand(self, rhs: &isize) -> Integer

Performs the & operation.

impl<'b> BitAnd<&u128> for &'b Integer

type Output = BitAndU128Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &u128) -> BitAndU128Incomplete<'b>

Performs the & operation.

impl BitAnd<&u128> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<&u16> for &'b Integer

type Output = BitAndU16Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &u16) -> BitAndU16Incomplete<'b>

Performs the & operation.

impl BitAnd<&u16> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<&u32> for &'b Integer

type Output = BitAndU32Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &u32) -> BitAndU32Incomplete<'b>

Performs the & operation.

impl BitAnd<&u32> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<&u64> for &'b Integer

type Output = BitAndU64Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &u64) -> BitAndU64Incomplete<'b>

Performs the & operation.

impl BitAnd<&u64> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<&u8> for &'b Integer

type Output = BitAndU8Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &u8) -> BitAndU8Incomplete<'b>

Performs the & operation.

impl BitAnd<&u8> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<&usize> for &'b Integer

type Output = BitAndUsizeIncomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &usize) -> BitAndUsizeIncomplete<'b>

Performs the & operation.

impl BitAnd<&usize> for Integer

type Output = Integer

The resulting type after applying the & operator.

fn bitand(self, rhs: &usize) -> Integer

Performs the & operation.

impl BitAnd<Integer> for &Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &i128

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &i16

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &i32

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &i64

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &i8

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &isize

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &u128

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &u16

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &u32

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &u64

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &u8

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for &usize

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for i128

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for i16

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for i32

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for i64

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for i8

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for isize

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for u128

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for u16

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for u32

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for u64

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for u8

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<Integer> for usize

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<i128> for &'b Integer

type Output = BitAndI128Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: i128) -> BitAndI128Incomplete<'b>

Performs the & operation.

impl BitAnd<i128> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<i16> for &'b Integer

type Output = BitAndI16Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: i16) -> BitAndI16Incomplete<'b>

Performs the & operation.

impl BitAnd<i16> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<i32> for &'b Integer

type Output = BitAndI32Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: i32) -> BitAndI32Incomplete<'b>

Performs the & operation.

impl BitAnd<i32> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<i64> for &'b Integer

type Output = BitAndI64Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: i64) -> BitAndI64Incomplete<'b>

Performs the & operation.

impl BitAnd<i64> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<i8> for &'b Integer

type Output = BitAndI8Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: i8) -> BitAndI8Incomplete<'b>

Performs the & operation.

impl BitAnd<i8> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<isize> for &'b Integer

type Output = BitAndIsizeIncomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: isize) -> BitAndIsizeIncomplete<'b>

Performs the & operation.

impl BitAnd<isize> for Integer

type Output = Integer

The resulting type after applying the & operator.

fn bitand(self, rhs: isize) -> Integer

Performs the & operation.

impl<'b> BitAnd<u128> for &'b Integer

type Output = BitAndU128Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: u128) -> BitAndU128Incomplete<'b>

Performs the & operation.

impl BitAnd<u128> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<u16> for &'b Integer

type Output = BitAndU16Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: u16) -> BitAndU16Incomplete<'b>

Performs the & operation.

impl BitAnd<u16> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<u32> for &'b Integer

type Output = BitAndU32Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: u32) -> BitAndU32Incomplete<'b>

Performs the & operation.

impl BitAnd<u32> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<u64> for &'b Integer

type Output = BitAndU64Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: u64) -> BitAndU64Incomplete<'b>

Performs the & operation.

impl BitAnd<u64> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<u8> for &'b Integer

type Output = BitAndU8Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: u8) -> BitAndU8Incomplete<'b>

Performs the & operation.

impl BitAnd<u8> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b> BitAnd<usize> for &'b Integer

type Output = BitAndUsizeIncomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: usize) -> BitAndUsizeIncomplete<'b>

Performs the & operation.

impl BitAnd<usize> for Integer

type Output = Integer

The resulting type after applying the & operator.

fn bitand(self, rhs: usize) -> Integer

Performs the & operation.

impl<'a> BitAnd for &'a Integer

type Output = BitAndIncomplete<'a>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Integer) -> BitAndIncomplete<'_>

Performs the & operation.

impl BitAnd for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign<&Integer> for Integer

fn bitand_assign(&mut self, rhs: &Integer)

Performs the &= operation.

impl BitAndAssign<&i128> for Integer

fn bitand_assign(&mut self, rhs: &i128)

Performs the &= operation.

impl BitAndAssign<&i16> for Integer

fn bitand_assign(&mut self, rhs: &i16)

Performs the &= operation.

impl BitAndAssign<&i32> for Integer

fn bitand_assign(&mut self, rhs: &i32)

Performs the &= operation.

impl BitAndAssign<&i64> for Integer

fn bitand_assign(&mut self, rhs: &i64)

Performs the &= operation.

impl BitAndAssign<&i8> for Integer

fn bitand_assign(&mut self, rhs: &i8)

Performs the &= operation.

impl BitAndAssign<&isize> for Integer

fn bitand_assign(&mut self, rhs: &isize)

Performs the &= operation.

impl BitAndAssign<&u128> for Integer

fn bitand_assign(&mut self, rhs: &u128)

Performs the &= operation.

impl BitAndAssign<&u16> for Integer

fn bitand_assign(&mut self, rhs: &u16)

Performs the &= operation.

impl BitAndAssign<&u32> for Integer

fn bitand_assign(&mut self, rhs: &u32)

Performs the &= operation.

impl BitAndAssign<&u64> for Integer

fn bitand_assign(&mut self, rhs: &u64)

Performs the &= operation.

impl BitAndAssign<&u8> for Integer

fn bitand_assign(&mut self, rhs: &u8)

Performs the &= operation.

impl BitAndAssign<&usize> for Integer

fn bitand_assign(&mut self, rhs: &usize)

Performs the &= operation.

impl BitAndAssign<i128> for Integer

fn bitand_assign(&mut self, rhs: i128)

Performs the &= operation.

impl BitAndAssign<i16> for Integer

fn bitand_assign(&mut self, rhs: i16)

Performs the &= operation.

impl BitAndAssign<i32> for Integer

fn bitand_assign(&mut self, rhs: i32)

Performs the &= operation.

impl BitAndAssign<i64> for Integer

fn bitand_assign(&mut self, rhs: i64)

Performs the &= operation.

impl BitAndAssign<i8> for Integer

fn bitand_assign(&mut self, rhs: i8)

Performs the &= operation.

impl BitAndAssign<isize> for Integer

fn bitand_assign(&mut self, rhs: isize)

Performs the &= operation.

impl BitAndAssign<u128> for Integer

fn bitand_assign(&mut self, rhs: u128)

Performs the &= operation.

impl BitAndAssign<u16> for Integer

fn bitand_assign(&mut self, rhs: u16)

Performs the &= operation.

impl BitAndAssign<u32> for Integer

fn bitand_assign(&mut self, rhs: u32)

Performs the &= operation.

impl BitAndAssign<u64> for Integer

fn bitand_assign(&mut self, rhs: u64)

Performs the &= operation.

impl BitAndAssign<u8> for Integer

fn bitand_assign(&mut self, rhs: u8)

Performs the &= operation.

impl BitAndAssign<usize> for Integer

fn bitand_assign(&mut self, rhs: usize)

Performs the &= operation.

impl BitAndAssign for Integer

fn bitand_assign(&mut self, rhs: Integer)

Performs the &= operation.

impl BitAndFrom<&Integer> for Integer

fn bitand_from(&mut self, lhs: &Integer)

Peforms the AND operation.

impl BitAndFrom<&i128> for Integer

fn bitand_from(&mut self, lhs: &i128)

Peforms the AND operation.

impl BitAndFrom<&i16> for Integer

fn bitand_from(&mut self, lhs: &i16)

Peforms the AND operation.

impl BitAndFrom<&i32> for Integer

fn bitand_from(&mut self, lhs: &i32)

Peforms the AND operation.

impl BitAndFrom<&i64> for Integer

fn bitand_from(&mut self, lhs: &i64)

Peforms the AND operation.

impl BitAndFrom<&i8> for Integer

fn bitand_from(&mut self, lhs: &i8)

Peforms the AND operation.

impl BitAndFrom<&isize> for Integer

fn bitand_from(&mut self, lhs: &isize)

Peforms the AND operation.

impl BitAndFrom<&u128> for Integer

fn bitand_from(&mut self, lhs: &u128)

Peforms the AND operation.

impl BitAndFrom<&u16> for Integer

fn bitand_from(&mut self, lhs: &u16)

Peforms the AND operation.

impl BitAndFrom<&u32> for Integer

fn bitand_from(&mut self, lhs: &u32)

Peforms the AND operation.

impl BitAndFrom<&u64> for Integer

fn bitand_from(&mut self, lhs: &u64)

Peforms the AND operation.

impl BitAndFrom<&u8> for Integer

fn bitand_from(&mut self, lhs: &u8)

Peforms the AND operation.

impl BitAndFrom<&usize> for Integer

fn bitand_from(&mut self, lhs: &usize)

Peforms the AND operation.

impl BitAndFrom<i128> for Integer

fn bitand_from(&mut self, lhs: i128)

Peforms the AND operation.

impl BitAndFrom<i16> for Integer

fn bitand_from(&mut self, lhs: i16)

Peforms the AND operation.

impl BitAndFrom<i32> for Integer

fn bitand_from(&mut self, lhs: i32)

Peforms the AND operation.

impl BitAndFrom<i64> for Integer

fn bitand_from(&mut self, lhs: i64)

Peforms the AND operation.

impl BitAndFrom<i8> for Integer

fn bitand_from(&mut self, lhs: i8)

Peforms the AND operation.

impl BitAndFrom<isize> for Integer

fn bitand_from(&mut self, lhs: isize)

Peforms the AND operation.

impl BitAndFrom<u128> for Integer

fn bitand_from(&mut self, lhs: u128)

Peforms the AND operation.

impl BitAndFrom<u16> for Integer

fn bitand_from(&mut self, lhs: u16)

Peforms the AND operation.

impl BitAndFrom<u32> for Integer

fn bitand_from(&mut self, lhs: u32)

Peforms the AND operation.

impl BitAndFrom<u64> for Integer

fn bitand_from(&mut self, lhs: u64)

Peforms the AND operation.

impl BitAndFrom<u8> for Integer

fn bitand_from(&mut self, lhs: u8)

Peforms the AND operation.

impl BitAndFrom<usize> for Integer

fn bitand_from(&mut self, lhs: usize)

Peforms the AND operation.

impl BitAndFrom for Integer

fn bitand_from(&mut self, lhs: Integer)

Peforms the AND operation.

impl<'b> BitOr<&'b Integer> for &i128

type Output = BitOrI128Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrI128Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for &i16

type Output = BitOrI16Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrI16Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for &i32

type Output = BitOrI32Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrI32Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for &i64

type Output = BitOrI64Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrI64Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for &i8

type Output = BitOrI8Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrI8Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for &isize

type Output = BitOrIsizeIncomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrIsizeIncomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for &u128

type Output = BitOrU128Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrU128Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for &u16

type Output = BitOrU16Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrU16Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for &u32

type Output = BitOrU32Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrU32Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for &u64

type Output = BitOrU64Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrU64Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for &u8

type Output = BitOrU8Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrU8Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for &usize

type Output = BitOrUsizeIncomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrUsizeIncomplete<'_>

Performs the | operation.

impl BitOr<&Integer> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<&'b Integer> for i128

type Output = BitOrI128Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrI128Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for i16

type Output = BitOrI16Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrI16Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for i32

type Output = BitOrI32Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrI32Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for i64

type Output = BitOrI64Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrI64Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for i8

type Output = BitOrI8Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrI8Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for isize

type Output = BitOrIsizeIncomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrIsizeIncomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for u128

type Output = BitOrU128Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrU128Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for u16

type Output = BitOrU16Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrU16Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for u32

type Output = BitOrU32Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrU32Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for u64

type Output = BitOrU64Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrU64Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for u8

type Output = BitOrU8Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrU8Incomplete<'_>

Performs the | operation.

impl<'b> BitOr<&'b Integer> for usize

type Output = BitOrUsizeIncomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrUsizeIncomplete<'_>

Performs the | operation.

impl<'b> BitOr<&i128> for &'b Integer

type Output = BitOrI128Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &i128) -> BitOrI128Incomplete<'b>

Performs the | operation.

impl BitOr<&i128> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<&i16> for &'b Integer

type Output = BitOrI16Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &i16) -> BitOrI16Incomplete<'b>

Performs the | operation.

impl BitOr<&i16> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<&i32> for &'b Integer

type Output = BitOrI32Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &i32) -> BitOrI32Incomplete<'b>

Performs the | operation.

impl BitOr<&i32> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<&i64> for &'b Integer

type Output = BitOrI64Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &i64) -> BitOrI64Incomplete<'b>

Performs the | operation.

impl BitOr<&i64> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<&i8> for &'b Integer

type Output = BitOrI8Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &i8) -> BitOrI8Incomplete<'b>

Performs the | operation.

impl BitOr<&i8> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<&isize> for &'b Integer

type Output = BitOrIsizeIncomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &isize) -> BitOrIsizeIncomplete<'b>

Performs the | operation.

impl BitOr<&isize> for Integer

type Output = Integer

The resulting type after applying the | operator.

fn bitor(self, rhs: &isize) -> Integer

Performs the | operation.

impl<'b> BitOr<&u128> for &'b Integer

type Output = BitOrU128Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &u128) -> BitOrU128Incomplete<'b>

Performs the | operation.

impl BitOr<&u128> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<&u16> for &'b Integer

type Output = BitOrU16Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &u16) -> BitOrU16Incomplete<'b>

Performs the | operation.

impl BitOr<&u16> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<&u32> for &'b Integer

type Output = BitOrU32Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &u32) -> BitOrU32Incomplete<'b>

Performs the | operation.

impl BitOr<&u32> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<&u64> for &'b Integer

type Output = BitOrU64Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &u64) -> BitOrU64Incomplete<'b>

Performs the | operation.

impl BitOr<&u64> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<&u8> for &'b Integer

type Output = BitOrU8Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &u8) -> BitOrU8Incomplete<'b>

Performs the | operation.

impl BitOr<&u8> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<&usize> for &'b Integer

type Output = BitOrUsizeIncomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &usize) -> BitOrUsizeIncomplete<'b>

Performs the | operation.

impl BitOr<&usize> for Integer

type Output = Integer

The resulting type after applying the | operator.

fn bitor(self, rhs: &usize) -> Integer

Performs the | operation.

impl BitOr<Integer> for &Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &i128

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &i16

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &i32

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &i64

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &i8

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &isize

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &u128

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &u16

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &u32

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &u64

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &u8

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for &usize

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for i128

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for i16

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for i32

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for i64

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for i8

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for isize

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for u128

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for u16

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for u32

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for u64

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for u8

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<Integer> for usize

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<i128> for &'b Integer

type Output = BitOrI128Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: i128) -> BitOrI128Incomplete<'b>

Performs the | operation.

impl BitOr<i128> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<i16> for &'b Integer

type Output = BitOrI16Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: i16) -> BitOrI16Incomplete<'b>

Performs the | operation.

impl BitOr<i16> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<i32> for &'b Integer

type Output = BitOrI32Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: i32) -> BitOrI32Incomplete<'b>

Performs the | operation.

impl BitOr<i32> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<i64> for &'b Integer

type Output = BitOrI64Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: i64) -> BitOrI64Incomplete<'b>

Performs the | operation.

impl BitOr<i64> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<i8> for &'b Integer

type Output = BitOrI8Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: i8) -> BitOrI8Incomplete<'b>

Performs the | operation.

impl BitOr<i8> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<isize> for &'b Integer

type Output = BitOrIsizeIncomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: isize) -> BitOrIsizeIncomplete<'b>

Performs the | operation.

impl BitOr<isize> for Integer

type Output = Integer

The resulting type after applying the | operator.

fn bitor(self, rhs: isize) -> Integer

Performs the | operation.

impl<'b> BitOr<u128> for &'b Integer

type Output = BitOrU128Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: u128) -> BitOrU128Incomplete<'b>

Performs the | operation.

impl BitOr<u128> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<u16> for &'b Integer

type Output = BitOrU16Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: u16) -> BitOrU16Incomplete<'b>

Performs the | operation.

impl BitOr<u16> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<u32> for &'b Integer

type Output = BitOrU32Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> BitOrU32Incomplete<'b>

Performs the | operation.

impl BitOr<u32> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<u64> for &'b Integer

type Output = BitOrU64Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: u64) -> BitOrU64Incomplete<'b>

Performs the | operation.

impl BitOr<u64> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<u8> for &'b Integer

type Output = BitOrU8Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: u8) -> BitOrU8Incomplete<'b>

Performs the | operation.

impl BitOr<u8> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b> BitOr<usize> for &'b Integer

type Output = BitOrUsizeIncomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: usize) -> BitOrUsizeIncomplete<'b>

Performs the | operation.

impl BitOr<usize> for Integer

type Output = Integer

The resulting type after applying the | operator.

fn bitor(self, rhs: usize) -> Integer

Performs the | operation.

impl<'a> BitOr for &'a Integer

type Output = BitOrIncomplete<'a>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Integer) -> BitOrIncomplete<'_>

Performs the | operation.

impl BitOr for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign<&Integer> for Integer

fn bitor_assign(&mut self, rhs: &Integer)

Performs the |= operation.

impl BitOrAssign<&i128> for Integer

fn bitor_assign(&mut self, rhs: &i128)

Performs the |= operation.

impl BitOrAssign<&i16> for Integer

fn bitor_assign(&mut self, rhs: &i16)

Performs the |= operation.

impl BitOrAssign<&i32> for Integer

fn bitor_assign(&mut self, rhs: &i32)

Performs the |= operation.

impl BitOrAssign<&i64> for Integer

fn bitor_assign(&mut self, rhs: &i64)

Performs the |= operation.

impl BitOrAssign<&i8> for Integer

fn bitor_assign(&mut self, rhs: &i8)

Performs the |= operation.

impl BitOrAssign<&isize> for Integer

fn bitor_assign(&mut self, rhs: &isize)

Performs the |= operation.

impl BitOrAssign<&u128> for Integer

fn bitor_assign(&mut self, rhs: &u128)

Performs the |= operation.

impl BitOrAssign<&u16> for Integer

fn bitor_assign(&mut self, rhs: &u16)

Performs the |= operation.

impl BitOrAssign<&u32> for Integer

fn bitor_assign(&mut self, rhs: &u32)

Performs the |= operation.

impl BitOrAssign<&u64> for Integer

fn bitor_assign(&mut self, rhs: &u64)

Performs the |= operation.

impl BitOrAssign<&u8> for Integer

fn bitor_assign(&mut self, rhs: &u8)

Performs the |= operation.

impl BitOrAssign<&usize> for Integer

fn bitor_assign(&mut self, rhs: &usize)

Performs the |= operation.

impl BitOrAssign<i128> for Integer

fn bitor_assign(&mut self, rhs: i128)

Performs the |= operation.

impl BitOrAssign<i16> for Integer

fn bitor_assign(&mut self, rhs: i16)

Performs the |= operation.

impl BitOrAssign<i32> for Integer

fn bitor_assign(&mut self, rhs: i32)

Performs the |= operation.

impl BitOrAssign<i64> for Integer

fn bitor_assign(&mut self, rhs: i64)

Performs the |= operation.

impl BitOrAssign<i8> for Integer

fn bitor_assign(&mut self, rhs: i8)

Performs the |= operation.

impl BitOrAssign<isize> for Integer

fn bitor_assign(&mut self, rhs: isize)

Performs the |= operation.

impl BitOrAssign<u128> for Integer

fn bitor_assign(&mut self, rhs: u128)

Performs the |= operation.

impl BitOrAssign<u16> for Integer

fn bitor_assign(&mut self, rhs: u16)

Performs the |= operation.

impl BitOrAssign<u32> for Integer

fn bitor_assign(&mut self, rhs: u32)

Performs the |= operation.

impl BitOrAssign<u64> for Integer

fn bitor_assign(&mut self, rhs: u64)

Performs the |= operation.

impl BitOrAssign<u8> for Integer

fn bitor_assign(&mut self, rhs: u8)

Performs the |= operation.

impl BitOrAssign<usize> for Integer

fn bitor_assign(&mut self, rhs: usize)

Performs the |= operation.

impl BitOrAssign for Integer

fn bitor_assign(&mut self, rhs: Integer)

Performs the |= operation.

impl BitOrFrom<&Integer> for Integer

fn bitor_from(&mut self, lhs: &Integer)

Peforms the OR operation.

impl BitOrFrom<&i128> for Integer

fn bitor_from(&mut self, lhs: &i128)

Peforms the OR operation.

impl BitOrFrom<&i16> for Integer

fn bitor_from(&mut self, lhs: &i16)

Peforms the OR operation.

impl BitOrFrom<&i32> for Integer

fn bitor_from(&mut self, lhs: &i32)

Peforms the OR operation.

impl BitOrFrom<&i64> for Integer

fn bitor_from(&mut self, lhs: &i64)

Peforms the OR operation.

impl BitOrFrom<&i8> for Integer

fn bitor_from(&mut self, lhs: &i8)

Peforms the OR operation.

impl BitOrFrom<&isize> for Integer

fn bitor_from(&mut self, lhs: &isize)

Peforms the OR operation.

impl BitOrFrom<&u128> for Integer

fn bitor_from(&mut self, lhs: &u128)

Peforms the OR operation.

impl BitOrFrom<&u16> for Integer

fn bitor_from(&mut self, lhs: &u16)

Peforms the OR operation.

impl BitOrFrom<&u32> for Integer

fn bitor_from(&mut self, lhs: &u32)

Peforms the OR operation.

impl BitOrFrom<&u64> for Integer

fn bitor_from(&mut self, lhs: &u64)

Peforms the OR operation.

impl BitOrFrom<&u8> for Integer

fn bitor_from(&mut self, lhs: &u8)

Peforms the OR operation.

impl BitOrFrom<&usize> for Integer

fn bitor_from(&mut self, lhs: &usize)

Peforms the OR operation.

impl BitOrFrom<i128> for Integer

fn bitor_from(&mut self, lhs: i128)

Peforms the OR operation.

impl BitOrFrom<i16> for Integer

fn bitor_from(&mut self, lhs: i16)

Peforms the OR operation.

impl BitOrFrom<i32> for Integer

fn bitor_from(&mut self, lhs: i32)

Peforms the OR operation.

impl BitOrFrom<i64> for Integer

fn bitor_from(&mut self, lhs: i64)

Peforms the OR operation.

impl BitOrFrom<i8> for Integer

fn bitor_from(&mut self, lhs: i8)

Peforms the OR operation.

impl BitOrFrom<isize> for Integer

fn bitor_from(&mut self, lhs: isize)

Peforms the OR operation.

impl BitOrFrom<u128> for Integer

fn bitor_from(&mut self, lhs: u128)

Peforms the OR operation.

impl BitOrFrom<u16> for Integer

fn bitor_from(&mut self, lhs: u16)

Peforms the OR operation.

impl BitOrFrom<u32> for Integer

fn bitor_from(&mut self, lhs: u32)

Peforms the OR operation.

impl BitOrFrom<u64> for Integer

fn bitor_from(&mut self, lhs: u64)

Peforms the OR operation.

impl BitOrFrom<u8> for Integer

fn bitor_from(&mut self, lhs: u8)

Peforms the OR operation.

impl BitOrFrom<usize> for Integer

fn bitor_from(&mut self, lhs: usize)

Peforms the OR operation.

impl BitOrFrom for Integer

fn bitor_from(&mut self, lhs: Integer)

Peforms the OR operation.

impl<'b> BitXor<&'b Integer> for &i128

type Output = BitXorI128Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorI128Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for &i16

type Output = BitXorI16Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorI16Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for &i32

type Output = BitXorI32Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorI32Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for &i64

type Output = BitXorI64Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorI64Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for &i8

type Output = BitXorI8Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorI8Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for &isize

type Output = BitXorIsizeIncomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorIsizeIncomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for &u128

type Output = BitXorU128Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorU128Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for &u16

type Output = BitXorU16Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorU16Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for &u32

type Output = BitXorU32Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorU32Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for &u64

type Output = BitXorU64Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorU64Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for &u8

type Output = BitXorU8Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorU8Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for &usize

type Output = BitXorUsizeIncomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorUsizeIncomplete<'_>

Performs the ^ operation.

impl BitXor<&Integer> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for i128

type Output = BitXorI128Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorI128Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for i16

type Output = BitXorI16Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorI16Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for i32

type Output = BitXorI32Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorI32Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for i64

type Output = BitXorI64Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorI64Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for i8

type Output = BitXorI8Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorI8Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for isize

type Output = BitXorIsizeIncomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorIsizeIncomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for u128

type Output = BitXorU128Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorU128Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for u16

type Output = BitXorU16Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorU16Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for u32

type Output = BitXorU32Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorU32Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for u64

type Output = BitXorU64Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorU64Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for u8

type Output = BitXorU8Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorU8Incomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&'b Integer> for usize

type Output = BitXorUsizeIncomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorUsizeIncomplete<'_>

Performs the ^ operation.

impl<'b> BitXor<&i128> for &'b Integer

type Output = BitXorI128Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i128) -> BitXorI128Incomplete<'b>

Performs the ^ operation.

impl BitXor<&i128> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<&i16> for &'b Integer

type Output = BitXorI16Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i16) -> BitXorI16Incomplete<'b>

Performs the ^ operation.

impl BitXor<&i16> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<&i32> for &'b Integer

type Output = BitXorI32Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i32) -> BitXorI32Incomplete<'b>

Performs the ^ operation.

impl BitXor<&i32> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<&i64> for &'b Integer

type Output = BitXorI64Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i64) -> BitXorI64Incomplete<'b>

Performs the ^ operation.

impl BitXor<&i64> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<&i8> for &'b Integer

type Output = BitXorI8Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &i8) -> BitXorI8Incomplete<'b>

Performs the ^ operation.

impl BitXor<&i8> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<&isize> for &'b Integer

type Output = BitXorIsizeIncomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &isize) -> BitXorIsizeIncomplete<'b>

Performs the ^ operation.

impl BitXor<&isize> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &isize) -> Integer

Performs the ^ operation.

impl<'b> BitXor<&u128> for &'b Integer

type Output = BitXorU128Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u128) -> BitXorU128Incomplete<'b>

Performs the ^ operation.

impl BitXor<&u128> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<&u16> for &'b Integer

type Output = BitXorU16Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u16) -> BitXorU16Incomplete<'b>

Performs the ^ operation.

impl BitXor<&u16> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<&u32> for &'b Integer

type Output = BitXorU32Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u32) -> BitXorU32Incomplete<'b>

Performs the ^ operation.

impl BitXor<&u32> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<&u64> for &'b Integer

type Output = BitXorU64Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u64) -> BitXorU64Incomplete<'b>

Performs the ^ operation.

impl BitXor<&u64> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<&u8> for &'b Integer

type Output = BitXorU8Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u8) -> BitXorU8Incomplete<'b>

Performs the ^ operation.

impl BitXor<&u8> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<&usize> for &'b Integer

type Output = BitXorUsizeIncomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &usize) -> BitXorUsizeIncomplete<'b>

Performs the ^ operation.

impl BitXor<&usize> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &usize) -> Integer

Performs the ^ operation.

impl BitXor<Integer> for &Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &i128

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &i16

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &i32

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &i64

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &i8

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &isize

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &u128

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &u16

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &u32

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &u64

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &u8

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for &usize

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for i128

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for i16

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for i32

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for i64

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for i8

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for isize

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for u128

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for u16

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for u32

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for u64

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for u8

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<Integer> for usize

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<i128> for &'b Integer

type Output = BitXorI128Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i128) -> BitXorI128Incomplete<'b>

Performs the ^ operation.

impl BitXor<i128> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<i16> for &'b Integer

type Output = BitXorI16Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i16) -> BitXorI16Incomplete<'b>

Performs the ^ operation.

impl BitXor<i16> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<i32> for &'b Integer

type Output = BitXorI32Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i32) -> BitXorI32Incomplete<'b>

Performs the ^ operation.

impl BitXor<i32> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<i64> for &'b Integer

type Output = BitXorI64Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i64) -> BitXorI64Incomplete<'b>

Performs the ^ operation.

impl BitXor<i64> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<i8> for &'b Integer

type Output = BitXorI8Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i8) -> BitXorI8Incomplete<'b>

Performs the ^ operation.

impl BitXor<i8> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<isize> for &'b Integer

type Output = BitXorIsizeIncomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: isize) -> BitXorIsizeIncomplete<'b>

Performs the ^ operation.

impl BitXor<isize> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: isize) -> Integer

Performs the ^ operation.

impl<'b> BitXor<u128> for &'b Integer

type Output = BitXorU128Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u128) -> BitXorU128Incomplete<'b>

Performs the ^ operation.

impl BitXor<u128> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<u16> for &'b Integer

type Output = BitXorU16Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u16) -> BitXorU16Incomplete<'b>

Performs the ^ operation.

impl BitXor<u16> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<u32> for &'b Integer

type Output = BitXorU32Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u32) -> BitXorU32Incomplete<'b>

Performs the ^ operation.

impl BitXor<u32> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<u64> for &'b Integer

type Output = BitXorU64Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u64) -> BitXorU64Incomplete<'b>

Performs the ^ operation.

impl BitXor<u64> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<u8> for &'b Integer

type Output = BitXorU8Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u8) -> BitXorU8Incomplete<'b>

Performs the ^ operation.

impl BitXor<u8> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b> BitXor<usize> for &'b Integer

type Output = BitXorUsizeIncomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: usize) -> BitXorUsizeIncomplete<'b>

Performs the ^ operation.

impl BitXor<usize> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: usize) -> Integer

Performs the ^ operation.

impl<'a> BitXor for &'a Integer

type Output = BitXorIncomplete<'a>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Integer) -> BitXorIncomplete<'_>

Performs the ^ operation.

impl BitXor for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXorAssign<&Integer> for Integer

fn bitxor_assign(&mut self, rhs: &Integer)

Performs the ^= operation.

impl BitXorAssign<&i128> for Integer

fn bitxor_assign(&mut self, rhs: &i128)

Performs the ^= operation.

impl BitXorAssign<&i16> for Integer

fn bitxor_assign(&mut self, rhs: &i16)

Performs the ^= operation.

impl BitXorAssign<&i32> for Integer

fn bitxor_assign(&mut self, rhs: &i32)

Performs the ^= operation.

impl BitXorAssign<&i64> for Integer

fn bitxor_assign(&mut self, rhs: &i64)

Performs the ^= operation.

impl BitXorAssign<&i8> for Integer

fn bitxor_assign(&mut self, rhs: &i8)

Performs the ^= operation.

impl BitXorAssign<&isize> for Integer

fn bitxor_assign(&mut self, rhs: &isize)

Performs the ^= operation.

impl BitXorAssign<&u128> for Integer

fn bitxor_assign(&mut self, rhs: &u128)

Performs the ^= operation.

impl BitXorAssign<&u16> for Integer

fn bitxor_assign(&mut self, rhs: &u16)

Performs the ^= operation.

impl BitXorAssign<&u32> for Integer

fn bitxor_assign(&mut self, rhs: &u32)

Performs the ^= operation.

impl BitXorAssign<&u64> for Integer

fn bitxor_assign(&mut self, rhs: &u64)

Performs the ^= operation.

impl BitXorAssign<&u8> for Integer

fn bitxor_assign(&mut self, rhs: &u8)

Performs the ^= operation.

impl BitXorAssign<&usize> for Integer

fn bitxor_assign(&mut self, rhs: &usize)

Performs the ^= operation.

impl BitXorAssign<i128> for Integer

fn bitxor_assign(&mut self, rhs: i128)

Performs the ^= operation.

impl BitXorAssign<i16> for Integer

fn bitxor_assign(&mut self, rhs: i16)

Performs the ^= operation.

impl BitXorAssign<i32> for Integer

fn bitxor_assign(&mut self, rhs: i32)

Performs the ^= operation.

impl BitXorAssign<i64> for Integer

fn bitxor_assign(&mut self, rhs: i64)

Performs the ^= operation.

impl BitXorAssign<i8> for Integer

fn bitxor_assign(&mut self, rhs: i8)

Performs the ^= operation.

impl BitXorAssign<isize> for Integer

fn bitxor_assign(&mut self, rhs: isize)

Performs the ^= operation.

impl BitXorAssign<u128> for Integer

fn bitxor_assign(&mut self, rhs: u128)

Performs the ^= operation.

impl BitXorAssign<u16> for Integer

fn bitxor_assign(&mut self, rhs: u16)

Performs the ^= operation.

impl BitXorAssign<u32> for Integer

fn bitxor_assign(&mut self, rhs: u32)

Performs the ^= operation.

impl BitXorAssign<u64> for Integer

fn bitxor_assign(&mut self, rhs: u64)

Performs the ^= operation.

impl BitXorAssign<u8> for Integer

fn bitxor_assign(&mut self, rhs: u8)

Performs the ^= operation.

impl BitXorAssign<usize> for Integer

fn bitxor_assign(&mut self, rhs: usize)

Performs the ^= operation.

impl BitXorAssign for Integer

fn bitxor_assign(&mut self, rhs: Integer)

Performs the ^= operation.

impl BitXorFrom<&Integer> for Integer

fn bitxor_from(&mut self, lhs: &Integer)

Peforms the XOR operation.

impl BitXorFrom<&i128> for Integer

fn bitxor_from(&mut self, lhs: &i128)

Peforms the XOR operation.

impl BitXorFrom<&i16> for Integer

fn bitxor_from(&mut self, lhs: &i16)

Peforms the XOR operation.

impl BitXorFrom<&i32> for Integer

fn bitxor_from(&mut self, lhs: &i32)

Peforms the XOR operation.

impl BitXorFrom<&i64> for Integer

fn bitxor_from(&mut self, lhs: &i64)

Peforms the XOR operation.

impl BitXorFrom<&i8> for Integer

fn bitxor_from(&mut self, lhs: &i8)

Peforms the XOR operation.

impl BitXorFrom<&isize> for Integer

fn bitxor_from(&mut self, lhs: &isize)

Peforms the XOR operation.

impl BitXorFrom<&u128> for Integer

fn bitxor_from(&mut self, lhs: &u128)

Peforms the XOR operation.

impl BitXorFrom<&u16> for Integer

fn bitxor_from(&mut self, lhs: &u16)

Peforms the XOR operation.

impl BitXorFrom<&u32> for Integer

fn bitxor_from(&mut self, lhs: &u32)

Peforms the XOR operation.

impl BitXorFrom<&u64> for Integer

fn bitxor_from(&mut self, lhs: &u64)

Peforms the XOR operation.

impl BitXorFrom<&u8> for Integer

fn bitxor_from(&mut self, lhs: &u8)

Peforms the XOR operation.

impl BitXorFrom<&usize> for Integer

fn bitxor_from(&mut self, lhs: &usize)

Peforms the XOR operation.

impl BitXorFrom<i128> for Integer

fn bitxor_from(&mut self, lhs: i128)

Peforms the XOR operation.

impl BitXorFrom<i16> for Integer

fn bitxor_from(&mut self, lhs: i16)

Peforms the XOR operation.

impl BitXorFrom<i32> for Integer

fn bitxor_from(&mut self, lhs: i32)

Peforms the XOR operation.

impl BitXorFrom<i64> for Integer

fn bitxor_from(&mut self, lhs: i64)

Peforms the XOR operation.

impl BitXorFrom<i8> for Integer

fn bitxor_from(&mut self, lhs: i8)

Peforms the XOR operation.

impl BitXorFrom<isize> for Integer

fn bitxor_from(&mut self, lhs: isize)

Peforms the XOR operation.

impl BitXorFrom<u128> for Integer

fn bitxor_from(&mut self, lhs: u128)

Peforms the XOR operation.

impl BitXorFrom<u16> for Integer

fn bitxor_from(&mut self, lhs: u16)

Peforms the XOR operation.

impl BitXorFrom<u32> for Integer

fn bitxor_from(&mut self, lhs: u32)

Peforms the XOR operation.

impl BitXorFrom<u64> for Integer

fn bitxor_from(&mut self, lhs: u64)

Peforms the XOR operation.

impl BitXorFrom<u8> for Integer

fn bitxor_from(&mut self, lhs: u8)

Peforms the XOR operation.

impl BitXorFrom<usize> for Integer

fn bitxor_from(&mut self, lhs: usize)

Peforms the XOR operation.

impl BitXorFrom for Integer

fn bitxor_from(&mut self, lhs: Integer)

Peforms the XOR operation.

impl Cast<Integer> for &Float

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for Float

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for Round<f32>

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for Round<f64>

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for bool

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for f32

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for f64

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for i128

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for i16

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for i32

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for i64

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for i8

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for isize

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for u128

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for u16

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for u32

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for u64

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for u8

fn cast(self) -> Integer

Casts the value.

impl Cast<Integer> for usize

fn cast(self) -> Integer

Casts the value.

impl Cast<Rational> for &Integer

fn cast(self) -> Rational

Casts the value.

impl Cast<Rational> for Integer

fn cast(self) -> Rational

Casts the value.

impl Cast<f32> for &Integer

fn cast(self) -> f32

Casts the value.

impl Cast<f32> for Integer

fn cast(self) -> f32

Casts the value.

impl Cast<f64> for &Integer

fn cast(self) -> f64

Casts the value.

impl Cast<f64> for Integer

fn cast(self) -> f64

Casts the value.

impl Cast<i128> for &Integer

fn cast(self) -> i128

Casts the value.

impl Cast<i128> for Integer

fn cast(self) -> i128

Casts the value.

impl Cast<i16> for &Integer

fn cast(self) -> i16

Casts the value.

impl Cast<i16> for Integer

fn cast(self) -> i16

Casts the value.

impl Cast<i32> for &Integer

fn cast(self) -> i32

Casts the value.

impl Cast<i32> for Integer

fn cast(self) -> i32

Casts the value.

impl Cast<i64> for &Integer

fn cast(self) -> i64

Casts the value.

impl Cast<i64> for Integer

fn cast(self) -> i64

Casts the value.

impl Cast<i8> for &Integer

fn cast(self) -> i8

Casts the value.

impl Cast<i8> for Integer

fn cast(self) -> i8

Casts the value.

impl Cast<isize> for &Integer

fn cast(self) -> isize

Casts the value.

impl Cast<isize> for Integer

fn cast(self) -> isize

Casts the value.

impl Cast<u128> for &Integer

fn cast(self) -> u128

Casts the value.

impl Cast<u128> for Integer

fn cast(self) -> u128

Casts the value.

impl Cast<u16> for &Integer

fn cast(self) -> u16

Casts the value.

impl Cast<u16> for Integer

fn cast(self) -> u16

Casts the value.

impl Cast<u32> for &Integer

fn cast(self) -> u32

Casts the value.

impl Cast<u32> for Integer

fn cast(self) -> u32

Casts the value.

impl Cast<u64> for &Integer

fn cast(self) -> u64

Casts the value.

impl Cast<u64> for Integer

fn cast(self) -> u64

Casts the value.

impl Cast<u8> for &Integer

fn cast(self) -> u8

Casts the value.

impl Cast<u8> for Integer

fn cast(self) -> u8

Casts the value.

impl Cast<usize> for &Integer

fn cast(self) -> usize

Casts the value.

impl Cast<usize> for Integer

fn cast(self) -> usize

Casts the value.

impl CheckedCast<Integer> for &Float

fn checked_cast(self) -> Option<Integer>

Casts the value.

impl CheckedCast<Integer> for Float

fn checked_cast(self) -> Option<Integer>

Casts the value.

impl CheckedCast<Integer> for Round<f32>

fn checked_cast(self) -> Option<Integer>

Casts the value.

impl CheckedCast<Integer> for Round<f64>

fn checked_cast(self) -> Option<Integer>

Casts the value.

impl CheckedCast<Integer> for f32

fn checked_cast(self) -> Option<Integer>

Casts the value.

impl CheckedCast<Integer> for f64

fn checked_cast(self) -> Option<Integer>

Casts the value.

impl CheckedCast<i128> for &Integer

fn checked_cast(self) -> Option<i128>

Casts the value.

impl CheckedCast<i128> for Integer

fn checked_cast(self) -> Option<i128>

Casts the value.

impl CheckedCast<i16> for &Integer

fn checked_cast(self) -> Option<i16>

Casts the value.

impl CheckedCast<i16> for Integer

fn checked_cast(self) -> Option<i16>

Casts the value.

impl CheckedCast<i32> for &Integer

fn checked_cast(self) -> Option<i32>

Casts the value.

impl CheckedCast<i32> for Integer

fn checked_cast(self) -> Option<i32>

Casts the value.

impl CheckedCast<i64> for &Integer

fn checked_cast(self) -> Option<i64>

Casts the value.

impl CheckedCast<i64> for Integer

fn checked_cast(self) -> Option<i64>

Casts the value.

impl CheckedCast<i8> for &Integer

fn checked_cast(self) -> Option<i8>

Casts the value.

impl CheckedCast<i8> for Integer

fn checked_cast(self) -> Option<i8>

Casts the value.

impl CheckedCast<isize> for &Integer

fn checked_cast(self) -> Option<isize>

Casts the value.

impl CheckedCast<isize> for Integer

fn checked_cast(self) -> Option<isize>

Casts the value.

impl CheckedCast<u128> for &Integer

fn checked_cast(self) -> Option<u128>

Casts the value.

impl CheckedCast<u128> for Integer

fn checked_cast(self) -> Option<u128>

Casts the value.

impl CheckedCast<u16> for &Integer

fn checked_cast(self) -> Option<u16>

Casts the value.

impl CheckedCast<u16> for Integer

fn checked_cast(self) -> Option<u16>

Casts the value.

impl CheckedCast<u32> for &Integer

fn checked_cast(self) -> Option<u32>

Casts the value.

impl CheckedCast<u32> for Integer

fn checked_cast(self) -> Option<u32>

Casts the value.

impl CheckedCast<u64> for &Integer

fn checked_cast(self) -> Option<u64>

Casts the value.

impl CheckedCast<u64> for Integer

fn checked_cast(self) -> Option<u64>

Casts the value.

impl CheckedCast<u8> for &Integer

fn checked_cast(self) -> Option<u8>

Casts the value.

impl CheckedCast<u8> for Integer

fn checked_cast(self) -> Option<u8>

Casts the value.

impl CheckedCast<usize> for &Integer

fn checked_cast(self) -> Option<usize>

Casts the value.

impl CheckedCast<usize> for Integer

fn checked_cast(self) -> Option<usize>

Casts the value.

impl CheckedDiv for Integer

fn checked_div(&self, v: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl CheckedEuclid for Integer

fn checked_div_euclid(&self, v: &Self) -> Option<Self>

Performs euclid division that returns None instead of panicking on division by zero and instead of wrapping around on underflow and overflow.

fn checked_rem_euclid(&self, v: &Self) -> Option<Self>

Finds the euclid remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

fn checked_div_rem_euclid(&self, v: &Self) -> Option<(Self, Self)>

Returns both the quotient and remainder from checked Euclidean division.

impl CheckedRem for Integer

fn checked_rem(&self, v: &Self) -> Option<Self>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl Clone for Integer

fn clone(&self) -> Integer

Returns a copy of the value.

fn clone_from(&mut self, source: &Integer)

Performs copy-assignment from source.

impl Debug for Integer

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl Default for Integer

fn default() -> Integer

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Integer

fn deserialize<D: Deserializer<'de>>( deserializer: D ) -> Result<Integer, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for Integer

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl<'a> Div<&'a Float> for &'a Integer

type Output = DivFromIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Float) -> DivFromIntegerIncomplete<'_>

Performs the / operation.

impl<'a> Div<&'a Float> for Integer

type Output = DivFromOwnedIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &Float) -> DivFromOwnedIntegerIncomplete<'_>

Performs the / operation.

impl<'a> Div<&'a Integer> for &'a Complex

type Output = DivIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Integer) -> DivIntegerIncomplete<'_>

Performs the / operation.

impl<'a> Div<&'a Integer> for &'a Float

type Output = DivIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Integer) -> DivIntegerIncomplete<'_>

Performs the / operation.

impl<'a> Div<&'a Integer> for &'a Rational

type Output = DivIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Integer) -> DivIntegerIncomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for &i128

type Output = DivFromI128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromI128Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Integer> for &i16

type Output = DivFromI16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromI16Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Integer> for &i32

type Output = DivFromI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromI32Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Integer> for &i64

type Output = DivFromI64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromI64Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Integer> for &i8

type Output = DivFromI8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromI8Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Integer> for &isize

type Output = DivFromIsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromIsizeIncomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Integer> for &u128

type Output = DivFromU128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromU128Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Integer> for &u16

type Output = DivFromU16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromU16Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Integer> for &u32

type Output = DivFromU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromU32Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Integer> for &u64

type Output = DivFromU64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromU64Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Integer> for &u8

type Output = DivFromU8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromU8Incomplete<'b>

Performs the / operation.

impl<'b> Div<&'b Integer> for &usize

type Output = DivFromUsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromUsizeIncomplete<'b>

Performs the / operation.

impl Div<&Integer> for Complex

type Output = Complex

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> Complex

Performs the / operation.

impl Div<&Integer> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> Float

Performs the / operation.

impl Div<&Integer> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&Integer> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> Rational

Performs the / operation.

impl<'b> Div<&'b Integer> for i128

type Output = DivFromI128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromI128Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for i16

type Output = DivFromI16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromI16Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for i32

type Output = DivFromI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromI32Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for i64

type Output = DivFromI64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromI64Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for i8

type Output = DivFromI8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromI8Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for isize

type Output = DivFromIsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromIsizeIncomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for u128

type Output = DivFromU128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromU128Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for u16

type Output = DivFromU16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromU16Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for u32

type Output = DivFromU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromU32Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for u64

type Output = DivFromU64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromU64Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for u8

type Output = DivFromU8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromU8Incomplete<'_>

Performs the / operation.

impl<'b> Div<&'b Integer> for usize

type Output = DivFromUsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &Integer) -> DivFromUsizeIncomplete<'_>

Performs the / operation.

impl<'a> Div<&'a Rational> for &'a Integer

type Output = DivFromIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Rational) -> DivFromIntegerIncomplete<'_>

Performs the / operation.

impl<'a> Div<&'a Rational> for Integer

type Output = DivFromOwnedIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &Rational) -> DivFromOwnedIntegerIncomplete<'_>

Performs the / operation.

impl<'b> Div<&i128> for &'b Integer

type Output = DivI128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i128) -> DivI128Incomplete<'b>

Performs the / operation.

impl Div<&i128> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<&i16> for &'b Integer

type Output = DivI16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> DivI16Incomplete<'b>

Performs the / operation.

impl Div<&i16> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<&i32> for &'b Integer

type Output = DivI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> DivI32Incomplete<'b>

Performs the / operation.

impl Div<&i32> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<&i64> for &'b Integer

type Output = DivI64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> DivI64Incomplete<'b>

Performs the / operation.

impl Div<&i64> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<&i8> for &'b Integer

type Output = DivI8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &i8) -> DivI8Incomplete<'b>

Performs the / operation.

impl Div<&i8> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<&isize> for &'b Integer

type Output = DivIsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> DivIsizeIncomplete<'b>

Performs the / operation.

impl Div<&isize> for Integer

type Output = Integer

The resulting type after applying the / operator.

fn div(self, rhs: &isize) -> Integer

Performs the / operation.

impl<'b> Div<&u128> for &'b Integer

type Output = DivU128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> DivU128Incomplete<'b>

Performs the / operation.

impl Div<&u128> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<&u16> for &'b Integer

type Output = DivU16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> DivU16Incomplete<'b>

Performs the / operation.

impl Div<&u16> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<&u32> for &'b Integer

type Output = DivU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> DivU32Incomplete<'b>

Performs the / operation.

impl Div<&u32> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<&u64> for &'b Integer

type Output = DivU64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> DivU64Incomplete<'b>

Performs the / operation.

impl Div<&u64> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<&u8> for &'b Integer

type Output = DivU8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> DivU8Incomplete<'b>

Performs the / operation.

impl Div<&u8> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<&usize> for &'b Integer

type Output = DivUsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> DivUsizeIncomplete<'b>

Performs the / operation.

impl Div<&usize> for Integer

type Output = Integer

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> Integer

Performs the / operation.

impl Div<Float> for &Integer

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: Float) -> Float

Performs the / operation.

impl Div<Float> for Integer

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: Float) -> Float

Performs the / operation.

impl<'a> Div<Integer> for &'a Complex

type Output = DivOwnedIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> DivOwnedIntegerIncomplete<'a>

Performs the / operation.

impl<'a> Div<Integer> for &'a Float

type Output = DivOwnedIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> DivOwnedIntegerIncomplete<'a>

Performs the / operation.

impl Div<Integer> for &Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> Div<Integer> for &'a Rational

type Output = DivOwnedIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> DivOwnedIntegerIncomplete<'a>

Performs the / operation.

impl Div<Integer> for &i128

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for &i16

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for &i32

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for &i64

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for &i8

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for &isize

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for &u128

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for &u16

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for &u32

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for &u64

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for &u8

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for &usize

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for Complex

type Output = Complex

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> Complex

Performs the / operation.

impl Div<Integer> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> Float

Performs the / operation.

impl Div<Integer> for Rational

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> Rational

Performs the / operation.

impl Div<Integer> for i128

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for i16

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for i32

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for i64

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for i8

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for isize

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for u128

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for u16

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for u32

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for u64

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for u8

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Integer> for usize

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Rational> for &Integer

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: Rational) -> Rational

Performs the / operation.

impl Div<Rational> for Integer

type Output = Rational

The resulting type after applying the / operator.

fn div(self, rhs: Rational) -> Rational

Performs the / operation.

impl<'b> Div<i128> for &'b Integer

type Output = DivI128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> DivI128Incomplete<'b>

Performs the / operation.

impl Div<i128> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<i16> for &'b Integer

type Output = DivI16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> DivI16Incomplete<'b>

Performs the / operation.

impl Div<i16> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<i32> for &'b Integer

type Output = DivI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> DivI32Incomplete<'b>

Performs the / operation.

impl Div<i32> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<i64> for &'b Integer

type Output = DivI64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> DivI64Incomplete<'b>

Performs the / operation.

impl Div<i64> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<i8> for &'b Integer

type Output = DivI8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> DivI8Incomplete<'b>

Performs the / operation.

impl Div<i8> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<isize> for &'b Integer

type Output = DivIsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> DivIsizeIncomplete<'b>

Performs the / operation.

impl Div<isize> for Integer

type Output = Integer

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> Integer

Performs the / operation.

impl<'b> Div<u128> for &'b Integer

type Output = DivU128Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> DivU128Incomplete<'b>

Performs the / operation.

impl Div<u128> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<u16> for &'b Integer

type Output = DivU16Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> DivU16Incomplete<'b>

Performs the / operation.

impl Div<u16> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<u32> for &'b Integer

type Output = DivU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> DivU32Incomplete<'b>

Performs the / operation.

impl Div<u32> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<u64> for &'b Integer

type Output = DivU64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> DivU64Incomplete<'b>

Performs the / operation.

impl Div<u64> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<u8> for &'b Integer

type Output = DivU8Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> DivU8Incomplete<'b>

Performs the / operation.

impl Div<u8> for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b> Div<usize> for &'b Integer

type Output = DivUsizeIncomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> DivUsizeIncomplete<'b>

Performs the / operation.

impl Div<usize> for Integer

type Output = Integer

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> Integer

Performs the / operation.

impl<'a> Div for &'a Integer

type Output = DivIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Integer) -> DivIncomplete<'_>

Performs the / operation.

impl Div for Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<&Integer> for Complex

fn div_assign(&mut self, rhs: &Integer)

Performs the /= operation.

impl DivAssign<&Integer> for Float

fn div_assign(&mut self, rhs: &Integer)

Performs the /= operation.

impl DivAssign<&Integer> for Integer

fn div_assign(&mut self, rhs: &Integer)

Performs the /= operation.

impl DivAssign<&Integer> for Rational

fn div_assign(&mut self, rhs: &Integer)

Performs the /= operation.

impl DivAssign<&i128> for Integer

fn div_assign(&mut self, rhs: &i128)

Performs the /= operation.

impl DivAssign<&i16> for Integer

fn div_assign(&mut self, rhs: &i16)

Performs the /= operation.

impl DivAssign<&i32> for Integer

fn div_assign(&mut self, rhs: &i32)

Performs the /= operation.

impl DivAssign<&i64> for Integer

fn div_assign(&mut self, rhs: &i64)

Performs the /= operation.

impl DivAssign<&i8> for Integer

fn div_assign(&mut self, rhs: &i8)

Performs the /= operation.

impl DivAssign<&isize> for Integer

fn div_assign(&mut self, rhs: &isize)

Performs the /= operation.

impl DivAssign<&u128> for Integer

fn div_assign(&mut self, rhs: &u128)

Performs the /= operation.

impl DivAssign<&u16> for Integer

fn div_assign(&mut self, rhs: &u16)

Performs the /= operation.

impl DivAssign<&u32> for Integer

fn div_assign(&mut self, rhs: &u32)

Performs the /= operation.

impl DivAssign<&u64> for Integer

fn div_assign(&mut self, rhs: &u64)

Performs the /= operation.

impl DivAssign<&u8> for Integer

fn div_assign(&mut self, rhs: &u8)

Performs the /= operation.

impl DivAssign<&usize> for Integer

fn div_assign(&mut self, rhs: &usize)

Performs the /= operation.

impl DivAssign<Integer> for Complex

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

impl DivAssign<Integer> for Float

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

impl DivAssign<Integer> for Rational

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

impl DivAssign<i128> for Integer

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl DivAssign<i16> for Integer

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl DivAssign<i32> for Integer

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl DivAssign<i64> for Integer

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl DivAssign<i8> for Integer

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl DivAssign<isize> for Integer

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl DivAssign<u128> for Integer

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl DivAssign<u16> for Integer

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl DivAssign<u32> for Integer

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl DivAssign<u64> for Integer

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl DivAssign<u8> for Integer

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl DivAssign<usize> for Integer

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl DivAssign for Integer

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

impl DivAssignRound<&Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_assign_round( &mut self, rhs: &Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the division.

impl DivAssignRound<&Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering

Performs the division.

impl DivAssignRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_assign_round( &mut self, rhs: Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the division.

impl DivAssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering

Performs the division.

impl DivFrom<&Integer> for Float

fn div_from(&mut self, lhs: &Integer)

Peforms the division.

impl DivFrom<&Integer> for Integer

fn div_from(&mut self, lhs: &Integer)

Peforms the division.

impl DivFrom<&Integer> for Rational

fn div_from(&mut self, lhs: &Integer)

Peforms the division.

impl DivFrom<&i128> for Integer

fn div_from(&mut self, lhs: &i128)

Peforms the division.

impl DivFrom<&i16> for Integer

fn div_from(&mut self, lhs: &i16)

Peforms the division.

impl DivFrom<&i32> for Integer

fn div_from(&mut self, lhs: &i32)

Peforms the division.

impl DivFrom<&i64> for Integer

fn div_from(&mut self, lhs: &i64)

Peforms the division.

impl DivFrom<&i8> for Integer

fn div_from(&mut self, lhs: &i8)

Peforms the division.

impl DivFrom<&isize> for Integer

fn div_from(&mut self, lhs: &isize)

Peforms the division.

impl DivFrom<&u128> for Integer

fn div_from(&mut self, lhs: &u128)

Peforms the division.

impl DivFrom<&u16> for Integer

fn div_from(&mut self, lhs: &u16)

Peforms the division.

impl DivFrom<&u32> for Integer

fn div_from(&mut self, lhs: &u32)

Peforms the division.

impl DivFrom<&u64> for Integer

fn div_from(&mut self, lhs: &u64)

Peforms the division.

impl DivFrom<&u8> for Integer

fn div_from(&mut self, lhs: &u8)

Peforms the division.

impl DivFrom<&usize> for Integer

fn div_from(&mut self, lhs: &usize)

Peforms the division.

impl DivFrom<Integer> for Float

fn div_from(&mut self, lhs: Integer)

Peforms the division.

impl DivFrom<Integer> for Rational

fn div_from(&mut self, lhs: Integer)

Peforms the division.

impl DivFrom<i128> for Integer

fn div_from(&mut self, lhs: i128)

Peforms the division.

impl DivFrom<i16> for Integer

fn div_from(&mut self, lhs: i16)

Peforms the division.

impl DivFrom<i32> for Integer

fn div_from(&mut self, lhs: i32)

Peforms the division.

impl DivFrom<i64> for Integer

fn div_from(&mut self, lhs: i64)

Peforms the division.

impl DivFrom<i8> for Integer

fn div_from(&mut self, lhs: i8)

Peforms the division.

impl DivFrom<isize> for Integer

fn div_from(&mut self, lhs: isize)

Peforms the division.

impl DivFrom<u128> for Integer

fn div_from(&mut self, lhs: u128)

Peforms the division.

impl DivFrom<u16> for Integer

fn div_from(&mut self, lhs: u16)

Peforms the division.

impl DivFrom<u32> for Integer

fn div_from(&mut self, lhs: u32)

Peforms the division.

impl DivFrom<u64> for Integer

fn div_from(&mut self, lhs: u64)

Peforms the division.

impl DivFrom<u8> for Integer

fn div_from(&mut self, lhs: u8)

Peforms the division.

impl DivFrom<usize> for Integer

fn div_from(&mut self, lhs: usize)

Peforms the division.

impl DivFrom for Integer

fn div_from(&mut self, lhs: Integer)

Peforms the division.

impl DivFromRound<&Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering

Performs the division.

impl DivFromRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn div_from_round(&mut self, lhs: Integer, round: Round) -> Ordering

Performs the division.

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

type Output = DivRoundingFromI128Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromI16Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromI32Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromI64Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromI8Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromU128Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromU16Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromU32Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromU64Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromU8Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<&Integer> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromI128Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromI16Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromI32Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromI64Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromI8Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromU128Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromU16Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromU32Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromU64Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingFromU8Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingI128Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<&i128> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingI16Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<&i16> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingI32Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<&i32> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingI64Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<&i64> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingI8Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<&i8> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingU128Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<&u128> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingU16Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<&u16> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingU32Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<&u32> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingU64Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<&u64> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingU8Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<&u8> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for &Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for &i128

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for &i16

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for &i32

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for &i64

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for &i8

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for &u128

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for &u16

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for &u32

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for &u64

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for &u8

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for i128

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for i16

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for i32

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for i64

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for i8

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for u128

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for u16

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for u32

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for u64

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<Integer> for u8

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingI128Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<i128> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingI16Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<i16> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingI32Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<i32> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingI64Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<i64> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingI8Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<i8> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingU128Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<u128> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingU16Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<u16> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingU32Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<u32> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingU64Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<u64> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

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

type Output = DivRoundingU8Incomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding<u8> for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl<'i> DivRounding for &'i Integer

type Output = DivRoundingIncomplete<'i>

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRounding for Integer

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

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

impl DivRoundingAssign<&Integer> for Integer

fn div_trunc_assign(&mut self, rhs: &Integer)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &Integer)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &Integer)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &Integer)

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

impl DivRoundingAssign<&i128> for Integer

fn div_trunc_assign(&mut self, rhs: &i128)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &i128)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &i128)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &i128)

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

impl DivRoundingAssign<&i16> for Integer

fn div_trunc_assign(&mut self, rhs: &i16)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &i16)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &i16)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &i16)

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

impl DivRoundingAssign<&i32> for Integer

fn div_trunc_assign(&mut self, rhs: &i32)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &i32)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &i32)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &i32)

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

impl DivRoundingAssign<&i64> for Integer

fn div_trunc_assign(&mut self, rhs: &i64)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &i64)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &i64)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &i64)

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

impl DivRoundingAssign<&i8> for Integer

fn div_trunc_assign(&mut self, rhs: &i8)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &i8)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &i8)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &i8)

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

impl DivRoundingAssign<&u128> for Integer

fn div_trunc_assign(&mut self, rhs: &u128)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &u128)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &u128)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &u128)

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

impl DivRoundingAssign<&u16> for Integer

fn div_trunc_assign(&mut self, rhs: &u16)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &u16)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &u16)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &u16)

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

impl DivRoundingAssign<&u32> for Integer

fn div_trunc_assign(&mut self, rhs: &u32)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &u32)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &u32)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &u32)

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

impl DivRoundingAssign<&u64> for Integer

fn div_trunc_assign(&mut self, rhs: &u64)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &u64)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &u64)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &u64)

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

impl DivRoundingAssign<&u8> for Integer

fn div_trunc_assign(&mut self, rhs: &u8)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &u8)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &u8)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &u8)

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

impl DivRoundingAssign<i128> for Integer

fn div_trunc_assign(&mut self, rhs: i128)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: i128)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: i128)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: i128)

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

impl DivRoundingAssign<i16> for Integer

fn div_trunc_assign(&mut self, rhs: i16)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: i16)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: i16)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: i16)

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

impl DivRoundingAssign<i32> for Integer

fn div_trunc_assign(&mut self, rhs: i32)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: i32)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: i32)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: i32)

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

impl DivRoundingAssign<i64> for Integer

fn div_trunc_assign(&mut self, rhs: i64)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: i64)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: i64)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: i64)

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

impl DivRoundingAssign<i8> for Integer

fn div_trunc_assign(&mut self, rhs: i8)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: i8)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: i8)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: i8)

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

impl DivRoundingAssign<u128> for Integer

fn div_trunc_assign(&mut self, rhs: u128)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: u128)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: u128)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: u128)

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

impl DivRoundingAssign<u16> for Integer

fn div_trunc_assign(&mut self, rhs: u16)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: u16)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: u16)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: u16)

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

impl DivRoundingAssign<u32> for Integer

fn div_trunc_assign(&mut self, rhs: u32)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: u32)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: u32)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: u32)

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

impl DivRoundingAssign<u64> for Integer

fn div_trunc_assign(&mut self, rhs: u64)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: u64)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: u64)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: u64)

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

impl DivRoundingAssign<u8> for Integer

fn div_trunc_assign(&mut self, rhs: u8)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: u8)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: u8)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: u8)

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

impl DivRoundingAssign for Integer

fn div_trunc_assign(&mut self, rhs: Integer)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: Integer)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: Integer)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: Integer)

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

impl DivRoundingFrom<&Integer> for Integer

fn div_trunc_from(&mut self, lhs: &Integer)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &Integer)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &Integer)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &Integer)

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

impl DivRoundingFrom<&i128> for Integer

fn div_trunc_from(&mut self, lhs: &i128)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &i128)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &i128)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &i128)

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

impl DivRoundingFrom<&i16> for Integer

fn div_trunc_from(&mut self, lhs: &i16)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &i16)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &i16)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &i16)

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

impl DivRoundingFrom<&i32> for Integer

fn div_trunc_from(&mut self, lhs: &i32)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &i32)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &i32)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &i32)

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

impl DivRoundingFrom<&i64> for Integer

fn div_trunc_from(&mut self, lhs: &i64)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &i64)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &i64)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &i64)

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

impl DivRoundingFrom<&i8> for Integer

fn div_trunc_from(&mut self, lhs: &i8)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &i8)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &i8)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &i8)

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

impl DivRoundingFrom<&u128> for Integer

fn div_trunc_from(&mut self, lhs: &u128)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &u128)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &u128)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &u128)

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

impl DivRoundingFrom<&u16> for Integer

fn div_trunc_from(&mut self, lhs: &u16)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &u16)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &u16)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &u16)

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

impl DivRoundingFrom<&u32> for Integer

fn div_trunc_from(&mut self, lhs: &u32)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &u32)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &u32)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &u32)

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

impl DivRoundingFrom<&u64> for Integer

fn div_trunc_from(&mut self, lhs: &u64)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &u64)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &u64)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &u64)

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

impl DivRoundingFrom<&u8> for Integer

fn div_trunc_from(&mut self, lhs: &u8)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &u8)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &u8)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &u8)

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

impl DivRoundingFrom<i128> for Integer

fn div_trunc_from(&mut self, lhs: i128)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: i128)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: i128)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: i128)

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

impl DivRoundingFrom<i16> for Integer

fn div_trunc_from(&mut self, lhs: i16)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: i16)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: i16)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: i16)

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

impl DivRoundingFrom<i32> for Integer

fn div_trunc_from(&mut self, lhs: i32)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: i32)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: i32)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: i32)

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

impl DivRoundingFrom<i64> for Integer

fn div_trunc_from(&mut self, lhs: i64)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: i64)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: i64)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: i64)

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

impl DivRoundingFrom<i8> for Integer

fn div_trunc_from(&mut self, lhs: i8)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: i8)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: i8)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: i8)

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

impl DivRoundingFrom<u128> for Integer

fn div_trunc_from(&mut self, lhs: u128)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: u128)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: u128)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: u128)

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

impl DivRoundingFrom<u16> for Integer

fn div_trunc_from(&mut self, lhs: u16)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: u16)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: u16)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: u16)

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

impl DivRoundingFrom<u32> for Integer

fn div_trunc_from(&mut self, lhs: u32)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: u32)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: u32)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: u32)

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

impl DivRoundingFrom<u64> for Integer

fn div_trunc_from(&mut self, lhs: u64)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: u64)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: u64)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: u64)

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

impl DivRoundingFrom<u8> for Integer

fn div_trunc_from(&mut self, lhs: u8)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: u8)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: u8)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: u8)

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

impl DivRoundingFrom for Integer

fn div_trunc_from(&mut self, lhs: Integer)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: Integer)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: Integer)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: Integer)

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

impl Drop for Integer

fn drop(&mut self)

Executes the destructor for this type.

impl Euclid for Integer

fn div_euclid(&self, v: &Self) -> Self

Calculates Euclidean division, the matching method for rem_euclid.

fn rem_euclid(&self, v: &Self) -> Self

Calculates the least nonnegative remainder of self (mod v).

fn div_rem_euclid(&self, v: &Self) -> (Self, Self)

Returns both the quotient and remainder from Euclidean division.

impl From<&Integer> for Integer

fn from(val: &Integer) -> Self

Converts to this type from the input type.

impl From<&MiniInteger> for Integer

fn from(src: &MiniInteger) -> Self

Converts to this type from the input type.

impl From<&SmallInteger> for Integer

fn from(src: &SmallInteger) -> Self

Converts to this type from the input type.

impl From<MiniInteger> for Integer

fn from(src: MiniInteger) -> Self

Converts to this type from the input type.

impl From<SmallInteger> for Integer

fn from(src: SmallInteger) -> Self

Converts to this type from the input type.

impl From<bool> for Integer

fn from(src: bool) -> Self

Converts to this type from the input type.

impl From<i128> for Integer

fn from(src: i128) -> Self

Converts to this type from the input type.

impl From<i16> for Integer

fn from(src: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Integer

fn from(src: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Integer

fn from(src: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Integer

fn from(src: i8) -> Self

Converts to this type from the input type.

impl From<isize> for Integer

fn from(src: isize) -> Self

Converts to this type from the input type.

impl From<u128> for Integer

fn from(src: u128) -> Self

Converts to this type from the input type.

impl From<u16> for Integer

fn from(src: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Integer

fn from(src: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Integer

fn from(src: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Integer

fn from(src: u8) -> Self

Converts to this type from the input type.

impl From<usize> for Integer

fn from(src: usize) -> Self

Converts to this type from the input type.

impl FromPrimitive for Integer

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl FromStr for Integer

type Err = ParseIntegerError

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<Integer, ParseIntegerError>

Parses a string s to return a value of this type.

impl Hash for Integer

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Integer for Integer

fn div_floor(&self, other: &Self) -> Self

Floored integer division.

fn mod_floor(&self, other: &Self) -> Self

Floored integer modulo, satisfying:

fn gcd(&self, other: &Self) -> Self

Greatest Common Divisor (GCD).

fn lcm(&self, other: &Self) -> Self

Lowest Common Multiple (LCM).

fn divides(&self, other: &Self) -> bool

👎Deprecated: Please use is_multiple_of instead

Deprecated, use is_multiple_of instead.

fn is_multiple_of(&self, other: &Self) -> bool

Returns true if self is a multiple of other.

fn is_even(&self) -> bool

Returns true if the number is even.

fn is_odd(&self) -> bool

Returns true if the number is odd.

fn div_rem(&self, other: &Self) -> (Self, Self)

Simultaneous truncated integer division and modulus. Returns (quotient, remainder).

fn div_ceil(&self, other: &Self) -> Self

Ceiled integer division.

fn gcd_lcm(&self, other: &Self) -> (Self, Self)

Greatest Common Divisor (GCD) and Lowest Common Multiple (LCM) together.

fn extended_gcd(&self, other: &Self) -> ExtendedGcd<Self>

Greatest common divisor and Bézout coefficients.

fn extended_gcd_lcm(&self, other: &Self) -> (ExtendedGcd<Self>, Self)

Greatest common divisor, least common multiple, and Bézout coefficients.

fn div_mod_floor(&self, other: &Self) -> (Self, Self)

Simultaneous floored integer division and modulus. Returns (quotient, remainder).

fn next_multiple_of(&self, other: &Self) -> Self

Rounds up to nearest multiple of argument.

fn prev_multiple_of(&self, other: &Self) -> Self

Rounds down to nearest multiple of argument.

fn dec(&mut self)

where Self: Clone,

Decrements self by one.

fn inc(&mut self)

where Self: Clone,

Increments self by one.

impl IntegerExt64 for Integer

fn to_f32_exp64(&self) -> (f32, u64)

Converts to an f32 and an exponent, rounding towards zero.

fn to_f64_exp64(&self) -> (f64, u64)

Converts to an f64 and an exponent, rounding towards zero.

fn is_divisible_u64(&self, divisor: u64) -> bool

Returns true if the number is divisible by divisor. Unlike other division functions, divisor can be zero.

fn is_divisible_2pow_64(&self, b: u64) -> bool

Returns true if the number is divisible by 2^b.

fn is_congruent_u64(&self, c: u64, divisor: u64) -> bool

Returns true if the number is congruent to c mod divisor, that is, if there exists a q such that self = c + q × divisor. Unlike other division functions, divisor can be zero.

fn is_congruent_2pow_64(&self, c: &Self, b: u64) -> bool

Returns true if the number is congruent to c mod 2^b, that is, if there exists a q such that self = c + q × 2^b.

fn significant_bits_64(&self) -> u64

Returns the number of bits required to represent the absolute value.

fn signed_bits_64(&self) -> u64

Returns the number of bits required to represent the value using a two’s-complement representation.

fn count_ones_64(&self) -> Option<u64>

Returns the number of one bits if the value ≥ 0.

fn count_zeros_64(&self) -> Option<u64>

Returns the number of zero bits if the value < 0.

fn find_zero_64(&self, start: u64) -> Option<u64>

Returns the location of the first zero, starting at start. If the bit at location start is zero, returns start.

fn find_one_64(&self, start: u64) -> Option<u64>

Returns the location of the first one, starting at start. If the bit at location start is one, returns start.

fn set_bit_64(&mut self, index: u64, val: bool) -> &mut Self

Sets the bit at location index to 1 if val is true or 0 if val is false.

fn get_bit_64(&self, index: u64) -> bool

Returns true if the bit at location index is 1 or false if the bit is 0.

fn toggle_bit_64(&mut self, index: u64) -> &mut Self

Toggles the bit at location index.

fn hamming_dist_64(&self, other: &Self) -> Option<u64>

Retuns the Hamming distance if the two numbers have the same sign.

fn keep_bits_64(self, n: u64) -> Self

Keeps the n least significant bits only, producing a result that is greater or equal to 0.

fn keep_bits_64_mut(&mut self, n: u64)

Keeps the n least significant bits only, producing a result that is greater or equal to 0.

fn keep_bits_64_ref(&self, n: u64) -> KeepBitsIncomplete<'_>

Keeps the n least significant bits only, producing a result that is greater or equal to 0.

fn keep_signed_bits_64(self, n: u64) -> Self

Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.

fn keep_signed_bits_64_mut(&mut self, n: u64)

Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.

fn keep_signed_bits_64_ref(&self, n: u64) -> KeepSignedBitsIncomplete<'_>

Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.

fn mod_u64(&self, modulo: u64) -> u64

Returns the modulo, or the remainder of Euclidean division by a u64.

fn div_exact_u64(self, divisor: u64) -> Self

Performs an exact division.

fn div_exact_u64_mut(&mut self, divisor: u64)

Performs an exact division.

fn div_exact_u64_ref(&self, divisor: u64) -> DivExactUIncomplete<'_>

Performs an exact division.

fn u64_pow_u64(base: u64, exponent: u64) -> UPowUIncomplete

Raises base to the power of exponent.

fn i64_pow_u64(base: i64, exponent: u64) -> IPowUIncomplete

Raises base to the power of exponent.

fn root_64(self, n: u64) -> Self

Computes the nth root and truncates the result.

fn root_64_mut(&mut self, n: u64)

Computes the nth root and truncates the result.

fn root_64_ref(&self, n: u64) -> RootIncomplete<'_>

Computes the nth root and truncates the result.

fn root_rem_64(self, remainder: Self, n: u64) -> (Self, Self)

Computes the nth root and returns the truncated root and the remainder.

fn root_rem_64_mut(&mut self, remainder: &mut Self, n: u64)

Computes the nth root and returns the truncated root and the remainder.

fn root_rem_64_ref(&self, n: u64) -> RootRemIncomplete<'_>

Computes the nth root and returns the truncated root and the remainder.

fn gcd_u64(self, other: u64) -> Self

Finds the greatest common divisor.

fn gcd_u64_mut(&mut self, other: u64)

Finds the greatest common divisor.

fn gcd_u64_ref(&self, other: u64) -> GcdUIncomplete<'_>

Finds the greatest common divisor.

fn lcm_u64(self, other: u64) -> Self

Finds the least common multiple.

fn lcm_u64_mut(&mut self, other: u64)

Finds the least common multiple.

fn lcm_u64_ref(&self, other: u64) -> LcmUIncomplete<'_>

Finds the least common multiple.

fn remove_factor_64(self, factor: &Self) -> (Self, u64)

Removes all occurrences of factor, and returns the number of occurrences removed.

fn remove_factor_64_mut(&mut self, factor: &Self) -> u64

Removes all occurrences of factor, and returns the number of occurrences removed.

fn remove_factor_64_ref<'a>( &'a self, factor: &'a Self ) -> RemoveFactorIncomplete<'a>

Removes all occurrences of factor, and counts the number of occurrences removed.

fn factorial_64(n: u64) -> FactorialIncomplete

Computes the factorial of n.

fn factorial_2_64(n: u64) -> Factorial2Incomplete

Computes the double factorial of n.

fn factorial_m_64(n: u64, m: u64) -> FactorialMIncomplete

Computes the m-multi factorial of n.

fn primorial_64(n: u64) -> PrimorialIncomplete

Computes the primorial of n.

fn binomial_64(self, k: u64) -> Self

Computes the binomial coefficient over k.

fn binomial_64_mut(&mut self, k: u64)

Computes the binomial coefficient over k.

fn binomial_64_ref(&self, k: u64) -> BinomialIncomplete<'_>

Computes the binomial coefficient over k.

fn binomial_u64(n: u64, k: u64) -> BinomialUIncomplete

Computes the binomial coefficient n over k.

fn fibonacci_64(n: u64) -> FibonacciIncomplete

Computes the Fibonacci number.

fn fibonacci_2_64(n: u64) -> Fibonacci2Incomplete

Computes a Fibonacci number, and the previous Fibonacci number.

fn lucas_64(n: u64) -> LucasIncomplete

Computes the Lucas number.

fn lucas_2_64(n: u64) -> Lucas2Incomplete

Computes a Lucas number, and the previous Lucas number.

fn random_bits_64( bits: u64, rng: &mut dyn MutRandState ) -> RandomBitsIncomplete<'_>

Generates a random number with a specified maximum number of bits.

impl LowerExp for Integer

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl LowerHex for Integer

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl<'a> Mul<&'a Complex> for &'a Integer

type Output = MulIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Complex) -> MulIntegerIncomplete<'_>

Performs the * operation.

impl<'a> Mul<&'a Complex> for Integer

type Output = MulOwnedIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &Complex) -> MulOwnedIntegerIncomplete<'_>

Performs the * operation.

impl<'a> Mul<&'a Float> for &'a Integer

type Output = MulIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Float) -> MulIntegerIncomplete<'_>

Performs the * operation.

impl<'a> Mul<&'a Float> for Integer

type Output = MulOwnedIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &Float) -> MulOwnedIntegerIncomplete<'_>

Performs the * operation.

impl<'a> Mul<&'a Integer> for &'a Complex

type Output = MulIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Integer) -> MulIntegerIncomplete<'_>

Performs the * operation.

impl<'a> Mul<&'a Integer> for &'a Float

type Output = MulIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Integer) -> MulIntegerIncomplete<'_>

Performs the * operation.

impl<'a> Mul<&'a Integer> for &'a Rational

type Output = MulIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Integer) -> MulIntegerIncomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &i128

type Output = MulI128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulI128Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &i16

type Output = MulI16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulI16Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &i32

type Output = MulI32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulI32Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &i64

type Output = MulI64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulI64Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &i8

type Output = MulI8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulI8Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &isize

type Output = MulIsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulIsizeIncomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &u128

type Output = MulU128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulU128Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &u16

type Output = MulU16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulU16Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &u32

type Output = MulU32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulU32Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &u64

type Output = MulU64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulU64Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &u8

type Output = MulU8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulU8Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for &usize

type Output = MulUsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulUsizeIncomplete<'_>

Performs the * operation.

impl Mul<&Integer> for Complex

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> Complex

Performs the * operation.

impl Mul<&Integer> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> Float

Performs the * operation.

impl Mul<&Integer> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&Integer> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> Rational

Performs the * operation.

impl<'b> Mul<&'b Integer> for i128

type Output = MulI128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulI128Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for i16

type Output = MulI16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulI16Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for i32

type Output = MulI32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulI32Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for i64

type Output = MulI64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulI64Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for i8

type Output = MulI8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulI8Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for isize

type Output = MulIsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulIsizeIncomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for u128

type Output = MulU128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulU128Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for u16

type Output = MulU16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulU16Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for u32

type Output = MulU32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulU32Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for u64

type Output = MulU64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulU64Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for u8

type Output = MulU8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulU8Incomplete<'_>

Performs the * operation.

impl<'b> Mul<&'b Integer> for usize

type Output = MulUsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulUsizeIncomplete<'_>

Performs the * operation.

impl<'a> Mul<&'a Rational> for &'a Integer

type Output = MulIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Rational) -> MulIntegerIncomplete<'_>

Performs the * operation.

impl<'a> Mul<&'a Rational> for Integer

type Output = MulOwnedIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Rational) -> MulOwnedIntegerIncomplete<'a>

Performs the * operation.

impl<'b> Mul<&i128> for &'b Integer

type Output = MulI128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i128) -> MulI128Incomplete<'b>

Performs the * operation.

impl Mul<&i128> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<&i16> for &'b Integer

type Output = MulI16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> MulI16Incomplete<'b>

Performs the * operation.

impl Mul<&i16> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<&i32> for &'b Integer

type Output = MulI32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> MulI32Incomplete<'b>

Performs the * operation.

impl Mul<&i32> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<&i64> for &'b Integer

type Output = MulI64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> MulI64Incomplete<'b>

Performs the * operation.

impl Mul<&i64> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<&i8> for &'b Integer

type Output = MulI8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &i8) -> MulI8Incomplete<'b>

Performs the * operation.

impl Mul<&i8> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<&isize> for &'b Integer

type Output = MulIsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> MulIsizeIncomplete<'b>

Performs the * operation.

impl Mul<&isize> for Integer

type Output = Integer

The resulting type after applying the * operator.

fn mul(self, rhs: &isize) -> Integer

Performs the * operation.

impl<'b> Mul<&u128> for &'b Integer

type Output = MulU128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> MulU128Incomplete<'b>

Performs the * operation.

impl Mul<&u128> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<&u16> for &'b Integer

type Output = MulU16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> MulU16Incomplete<'b>

Performs the * operation.

impl Mul<&u16> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<&u32> for &'b Integer

type Output = MulU32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> MulU32Incomplete<'b>

Performs the * operation.

impl Mul<&u32> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<&u64> for &'b Integer

type Output = MulU64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> MulU64Incomplete<'b>

Performs the * operation.

impl Mul<&u64> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<&u8> for &'b Integer

type Output = MulU8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> MulU8Incomplete<'b>

Performs the * operation.

impl Mul<&u8> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<&usize> for &'b Integer

type Output = MulUsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> MulUsizeIncomplete<'b>

Performs the * operation.

impl Mul<&usize> for Integer

type Output = Integer

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> Integer

Performs the * operation.

impl Mul<Complex> for &Integer

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: Complex) -> Complex

Performs the * operation.

impl Mul<Complex> for Integer

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: Complex) -> Complex

Performs the * operation.

impl Mul<Float> for &Integer

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: Float) -> Float

Performs the * operation.

impl Mul<Float> for Integer

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: Float) -> Float

Performs the * operation.

impl<'a> Mul<Integer> for &'a Complex

type Output = MulOwnedIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> MulOwnedIntegerIncomplete<'a>

Performs the * operation.

impl<'a> Mul<Integer> for &'a Float

type Output = MulOwnedIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> MulOwnedIntegerIncomplete<'a>

Performs the * operation.

impl Mul<Integer> for &Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<Integer> for &'a Rational

type Output = MulOwnedIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> MulOwnedIntegerIncomplete<'a>

Performs the * operation.

impl Mul<Integer> for &i128

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for &i16

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for &i32

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for &i64

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for &i8

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for &isize

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for &u128

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for &u16

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for &u32

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for &u64

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for &u8

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for &usize

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for Complex

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> Complex

Performs the * operation.

impl Mul<Integer> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> Float

Performs the * operation.

impl Mul<Integer> for Rational

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> Rational

Performs the * operation.

impl Mul<Integer> for i128

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for i16

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for i32

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for i64

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for i8

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for isize

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for u128

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for u16

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for u32

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for u64

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for u8

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Integer> for usize

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Rational> for &Integer

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> Rational

Performs the * operation.

impl Mul<Rational> for Integer

type Output = Rational

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> Rational

Performs the * operation.

impl<'b> Mul<i128> for &'b Integer

type Output = MulI128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> MulI128Incomplete<'b>

Performs the * operation.

impl Mul<i128> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<i16> for &'b Integer

type Output = MulI16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> MulI16Incomplete<'b>

Performs the * operation.

impl Mul<i16> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<i32> for &'b Integer

type Output = MulI32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> MulI32Incomplete<'b>

Performs the * operation.

impl Mul<i32> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<i64> for &'b Integer

type Output = MulI64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> MulI64Incomplete<'b>

Performs the * operation.

impl Mul<i64> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<i8> for &'b Integer

type Output = MulI8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> MulI8Incomplete<'b>

Performs the * operation.

impl Mul<i8> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<isize> for &'b Integer

type Output = MulIsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> MulIsizeIncomplete<'b>

Performs the * operation.

impl Mul<isize> for Integer

type Output = Integer

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> Integer

Performs the * operation.

impl<'b> Mul<u128> for &'b Integer

type Output = MulU128Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> MulU128Incomplete<'b>

Performs the * operation.

impl Mul<u128> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<u16> for &'b Integer

type Output = MulU16Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> MulU16Incomplete<'b>

Performs the * operation.

impl Mul<u16> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<u32> for &'b Integer

type Output = MulU32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> MulU32Incomplete<'b>

Performs the * operation.

impl Mul<u32> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<u64> for &'b Integer

type Output = MulU64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> MulU64Incomplete<'b>

Performs the * operation.

impl Mul<u64> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<u8> for &'b Integer

type Output = MulU8Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> MulU8Incomplete<'b>

Performs the * operation.

impl Mul<u8> for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b> Mul<usize> for &'b Integer

type Output = MulUsizeIncomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> MulUsizeIncomplete<'b>

Performs the * operation.

impl Mul<usize> for Integer

type Output = Integer

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Integer

Performs the * operation.

impl<'a> Mul for &'a Integer

type Output = MulIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Integer) -> MulIncomplete<'_>

Performs the * operation.

impl Mul for Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAdd<&Integer, &Integer> for Integer

type Output = Integer

The resulting type after applying the fused multiply-add.

fn mul_add(self, a: &Integer, b: &Integer) -> Integer

Performs the fused multiply-add operation (self * a) + b

impl MulAdd for Integer

type Output = Integer

The resulting type after applying the fused multiply-add.

fn mul_add(self, a: Integer, b: Integer) -> Integer

Performs the fused multiply-add operation (self * a) + b

impl MulAddAssign<&Integer, &Integer> for Integer

fn mul_add_assign(&mut self, a: &Integer, b: &Integer)

Performs the fused multiply-add assignment operation *self = (*self * a) + b

impl MulAddAssign for Integer

fn mul_add_assign(&mut self, a: Integer, b: Integer)

Performs the fused multiply-add assignment operation *self = (*self * a) + b

impl MulAssign<&Integer> for Complex

fn mul_assign(&mut self, rhs: &Integer)

Performs the *= operation.

impl MulAssign<&Integer> for Float

fn mul_assign(&mut self, rhs: &Integer)

Performs the *= operation.

impl MulAssign<&Integer> for Integer

fn mul_assign(&mut self, rhs: &Integer)

Performs the *= operation.

impl MulAssign<&Integer> for Rational

fn mul_assign(&mut self, rhs: &Integer)

Performs the *= operation.

impl MulAssign<&i128> for Integer

fn mul_assign(&mut self, rhs: &i128)

Performs the *= operation.

impl MulAssign<&i16> for Integer

fn mul_assign(&mut self, rhs: &i16)

Performs the *= operation.

impl MulAssign<&i32> for Integer

fn mul_assign(&mut self, rhs: &i32)

Performs the *= operation.

impl MulAssign<&i64> for Integer

fn mul_assign(&mut self, rhs: &i64)

Performs the *= operation.

impl MulAssign<&i8> for Integer

fn mul_assign(&mut self, rhs: &i8)

Performs the *= operation.

impl MulAssign<&isize> for Integer

fn mul_assign(&mut self, rhs: &isize)

Performs the *= operation.

impl MulAssign<&u128> for Integer

fn mul_assign(&mut self, rhs: &u128)

Performs the *= operation.

impl MulAssign<&u16> for Integer

fn mul_assign(&mut self, rhs: &u16)

Performs the *= operation.

impl MulAssign<&u32> for Integer

fn mul_assign(&mut self, rhs: &u32)

Performs the *= operation.

impl MulAssign<&u64> for Integer

fn mul_assign(&mut self, rhs: &u64)

Performs the *= operation.

impl MulAssign<&u8> for Integer

fn mul_assign(&mut self, rhs: &u8)

Performs the *= operation.

impl MulAssign<&usize> for Integer

fn mul_assign(&mut self, rhs: &usize)

Performs the *= operation.

impl MulAssign<Integer> for Complex

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

impl MulAssign<Integer> for Float

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

impl MulAssign<Integer> for Rational

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

impl MulAssign<i128> for Integer

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl MulAssign<i16> for Integer

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl MulAssign<i32> for Integer

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign<i64> for Integer

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl MulAssign<i8> for Integer

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl MulAssign<isize> for Integer

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl MulAssign<u128> for Integer

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl MulAssign<u16> for Integer

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl MulAssign<u32> for Integer

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl MulAssign<u64> for Integer

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl MulAssign<u8> for Integer

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl MulAssign<usize> for Integer

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl MulAssign for Integer

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

impl MulAssignRound<&Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_assign_round( &mut self, rhs: &Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the multiplication.

impl MulAssignRound<&Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering

Performs the multiplication.

impl MulAssignRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_assign_round( &mut self, rhs: Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the multiplication.

impl MulAssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering

Performs the multiplication.

impl MulFrom<&Integer> for Complex

fn mul_from(&mut self, lhs: &Integer)

Peforms the multiplication.

impl MulFrom<&Integer> for Float

fn mul_from(&mut self, lhs: &Integer)

Peforms the multiplication.

impl MulFrom<&Integer> for Integer

fn mul_from(&mut self, lhs: &Integer)

Peforms the multiplication.

impl MulFrom<&Integer> for Rational

fn mul_from(&mut self, lhs: &Integer)

Peforms the multiplication.

impl MulFrom<&i128> for Integer

fn mul_from(&mut self, lhs: &i128)

Peforms the multiplication.

impl MulFrom<&i16> for Integer

fn mul_from(&mut self, lhs: &i16)

Peforms the multiplication.

impl MulFrom<&i32> for Integer

fn mul_from(&mut self, lhs: &i32)

Peforms the multiplication.

impl MulFrom<&i64> for Integer

fn mul_from(&mut self, lhs: &i64)

Peforms the multiplication.

impl MulFrom<&i8> for Integer

fn mul_from(&mut self, lhs: &i8)

Peforms the multiplication.

impl MulFrom<&isize> for Integer

fn mul_from(&mut self, lhs: &isize)

Peforms the multiplication.

impl MulFrom<&u128> for Integer

fn mul_from(&mut self, lhs: &u128)

Peforms the multiplication.

impl MulFrom<&u16> for Integer

fn mul_from(&mut self, lhs: &u16)

Peforms the multiplication.

impl MulFrom<&u32> for Integer

fn mul_from(&mut self, lhs: &u32)

Peforms the multiplication.

impl MulFrom<&u64> for Integer

fn mul_from(&mut self, lhs: &u64)

Peforms the multiplication.

impl MulFrom<&u8> for Integer

fn mul_from(&mut self, lhs: &u8)

Peforms the multiplication.

impl MulFrom<&usize> for Integer

fn mul_from(&mut self, lhs: &usize)

Peforms the multiplication.

impl MulFrom<Integer> for Complex

fn mul_from(&mut self, lhs: Integer)

Peforms the multiplication.

impl MulFrom<Integer> for Float

fn mul_from(&mut self, lhs: Integer)

Peforms the multiplication.

impl MulFrom<Integer> for Rational

fn mul_from(&mut self, lhs: Integer)

Peforms the multiplication.

impl MulFrom<i128> for Integer

fn mul_from(&mut self, lhs: i128)

Peforms the multiplication.

impl MulFrom<i16> for Integer

fn mul_from(&mut self, lhs: i16)

Peforms the multiplication.

impl MulFrom<i32> for Integer

fn mul_from(&mut self, lhs: i32)

Peforms the multiplication.

impl MulFrom<i64> for Integer

fn mul_from(&mut self, lhs: i64)

Peforms the multiplication.

impl MulFrom<i8> for Integer

fn mul_from(&mut self, lhs: i8)

Peforms the multiplication.

impl MulFrom<isize> for Integer

fn mul_from(&mut self, lhs: isize)

Peforms the multiplication.

impl MulFrom<u128> for Integer

fn mul_from(&mut self, lhs: u128)

Peforms the multiplication.

impl MulFrom<u16> for Integer

fn mul_from(&mut self, lhs: u16)

Peforms the multiplication.

impl MulFrom<u32> for Integer

fn mul_from(&mut self, lhs: u32)

Peforms the multiplication.

impl MulFrom<u64> for Integer

fn mul_from(&mut self, lhs: u64)

Peforms the multiplication.

impl MulFrom<u8> for Integer

fn mul_from(&mut self, lhs: u8)

Peforms the multiplication.

impl MulFrom<usize> for Integer

fn mul_from(&mut self, lhs: usize)

Peforms the multiplication.

impl MulFrom for Integer

fn mul_from(&mut self, lhs: Integer)

Peforms the multiplication.

impl MulFromRound<&Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_from_round( &mut self, lhs: &Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the multiplication.

impl MulFromRound<&Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering

Performs the multiplication.

impl MulFromRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_from_round( &mut self, lhs: Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the multiplication.

impl MulFromRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn mul_from_round(&mut self, lhs: Integer, round: Round) -> Ordering

Performs the multiplication.

impl<'a> Neg for &'a Integer

type Output = NegIncomplete<'a>

The resulting type after applying the - operator.

fn neg(self) -> NegIncomplete<'a>

Performs the unary - operation.

impl Neg for Integer

type Output = Integer

The resulting type after applying the - operator.

fn neg(self) -> Integer

Performs the unary - operation.

impl NegAssign for Integer

fn neg_assign(&mut self)

Peforms the negation.

impl<'a> Not for &'a Integer

type Output = NotIncomplete<'a>

The resulting type after applying the ! operator.

fn not(self) -> NotIncomplete<'a>

Performs the unary ! operation.

impl Not for Integer

type Output = Integer

The resulting type after applying the ! operator.

fn not(self) -> Integer

Performs the unary ! operation.

impl NotAssign for Integer

fn not_assign(&mut self)

Peforms the complement.

impl Num for Integer

type FromStrRadixErr = ParseIntegerError

fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntegerError>

Convert from a string and radix (typically 2..=36).

impl Octal for Integer

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl One for Integer

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

impl Ord for Integer

fn cmp(&self, other: &Integer) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl OverflowingCast<i128> for &Integer

fn overflowing_cast(self) -> (i128, bool)

Casts the value.

impl OverflowingCast<i128> for Integer

fn overflowing_cast(self) -> (i128, bool)

Casts the value.

impl OverflowingCast<i16> for &Integer

fn overflowing_cast(self) -> (i16, bool)

Casts the value.

impl OverflowingCast<i16> for Integer

fn overflowing_cast(self) -> (i16, bool)

Casts the value.

impl OverflowingCast<i32> for &Integer

fn overflowing_cast(self) -> (i32, bool)

Casts the value.

impl OverflowingCast<i32> for Integer

fn overflowing_cast(self) -> (i32, bool)

Casts the value.

impl OverflowingCast<i64> for &Integer

fn overflowing_cast(self) -> (i64, bool)

Casts the value.

impl OverflowingCast<i64> for Integer

fn overflowing_cast(self) -> (i64, bool)

Casts the value.

impl OverflowingCast<i8> for &Integer

fn overflowing_cast(self) -> (i8, bool)

Casts the value.

impl OverflowingCast<i8> for Integer

fn overflowing_cast(self) -> (i8, bool)

Casts the value.

impl OverflowingCast<isize> for &Integer

fn overflowing_cast(self) -> (isize, bool)

Casts the value.

impl OverflowingCast<isize> for Integer

fn overflowing_cast(self) -> (isize, bool)

Casts the value.

impl OverflowingCast<u128> for &Integer

fn overflowing_cast(self) -> (u128, bool)

Casts the value.

impl OverflowingCast<u128> for Integer

fn overflowing_cast(self) -> (u128, bool)

Casts the value.

impl OverflowingCast<u16> for &Integer

fn overflowing_cast(self) -> (u16, bool)

Casts the value.

impl OverflowingCast<u16> for Integer

fn overflowing_cast(self) -> (u16, bool)

Casts the value.

impl OverflowingCast<u32> for &Integer

fn overflowing_cast(self) -> (u32, bool)

Casts the value.

impl OverflowingCast<u32> for Integer

fn overflowing_cast(self) -> (u32, bool)

Casts the value.

impl OverflowingCast<u64> for &Integer

fn overflowing_cast(self) -> (u64, bool)

Casts the value.

impl OverflowingCast<u64> for Integer

fn overflowing_cast(self) -> (u64, bool)

Casts the value.

impl OverflowingCast<u8> for &Integer

fn overflowing_cast(self) -> (u8, bool)

Casts the value.

impl OverflowingCast<u8> for Integer

fn overflowing_cast(self) -> (u8, bool)

Casts the value.

impl OverflowingCast<usize> for &Integer

fn overflowing_cast(self) -> (usize, bool)

Casts the value.

impl OverflowingCast<usize> for Integer

fn overflowing_cast(self) -> (usize, bool)

Casts the value.

impl PartialEq<Complex> for Integer

fn eq(&self, other: &Complex) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for Integer

fn eq(&self, other: &Float) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for Complex

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for Float

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for MiniInteger

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for Rational

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for SmallInteger

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for f32

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for f64

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for i128

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for i16

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for i32

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for i64

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for i8

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for isize

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for u128

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for u16

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for u32

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for u64

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for u8

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for usize

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<MiniInteger> for Integer

fn eq(&self, other: &MiniInteger) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for Integer

fn eq(&self, other: &Rational) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<SmallInteger> for Integer

fn eq(&self, other: &SmallInteger) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f32> for Integer

fn eq(&self, other: &f32) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f64> for Integer

fn eq(&self, other: &f64) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i128> for Integer

fn eq(&self, other: &i128) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i16> for Integer

fn eq(&self, other: &i16) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i32> for Integer

fn eq(&self, other: &i32) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i64> for Integer

fn eq(&self, other: &i64) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i8> for Integer

fn eq(&self, other: &i8) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<isize> for Integer

fn eq(&self, other: &isize) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u128> for Integer

fn eq(&self, other: &u128) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u16> for Integer

fn eq(&self, other: &u16) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u32> for Integer

fn eq(&self, other: &u32) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u64> for Integer

fn eq(&self, other: &u64) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u8> for Integer

fn eq(&self, other: &u8) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<usize> for Integer

fn eq(&self, other: &usize) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for Integer

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Float> for Integer

fn partial_cmp(&self, other: &Float) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for Float

fn partial_cmp(&self, z: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for MiniInteger

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for Rational

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for SmallInteger

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for f32

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for f64

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for i128

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for i16

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for i32

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for i64

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for i8

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for isize

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for u128

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for u16

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for u32

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for u64

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for u8

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Integer> for usize

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<MiniInteger> for Integer

fn partial_cmp(&self, other: &MiniInteger) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Rational> for Integer

fn partial_cmp(&self, other: &Rational) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<SmallInteger> for Integer

fn partial_cmp(&self, other: &SmallInteger) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<f32> for Integer

fn partial_cmp(&self, other: &f32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<f64> for Integer

fn partial_cmp(&self, other: &f64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i128> for Integer

fn partial_cmp(&self, other: &i128) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i16> for Integer

fn partial_cmp(&self, other: &i16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i32> for Integer

fn partial_cmp(&self, other: &i32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i64> for Integer

fn partial_cmp(&self, other: &i64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i8> for Integer

fn partial_cmp(&self, other: &i8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<isize> for Integer

fn partial_cmp(&self, other: &isize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u128> for Integer

fn partial_cmp(&self, other: &u128) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u16> for Integer

fn partial_cmp(&self, other: &u16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u32> for Integer

fn partial_cmp(&self, other: &u32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u64> for Integer

fn partial_cmp(&self, other: &u64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u8> for Integer

fn partial_cmp(&self, other: &u8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<usize> for Integer

fn partial_cmp(&self, other: &usize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd for Integer

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Pow<&'a Integer> for &'a Complex

type Output = PowIntegerIncomplete<'a>

The result after applying the operator.

fn pow(self, rhs: &'a Integer) -> PowIntegerIncomplete<'_>

Returns self to the power rhs.

impl<'a> Pow<&'a Integer> for &'a Float

type Output = PowIntegerIncomplete<'a>

The result after applying the operator.

fn pow(self, rhs: &'a Integer) -> PowIntegerIncomplete<'_>

Returns self to the power rhs.

impl Pow<&Integer> for Complex

type Output = Complex

The result after applying the operator.

fn pow(self, rhs: &Integer) -> Complex

Returns self to the power rhs.

impl Pow<&Integer> for Float

type Output = Float

The result after applying the operator.

fn pow(self, rhs: &Integer) -> Float

Returns self to the power rhs.

impl<'b> Pow<&u32> for &'b Integer

type Output = PowU32Incomplete<'b>

The result after applying the operator.

fn pow(self, rhs: &u32) -> PowU32Incomplete<'b>

Returns self to the power rhs.

impl Pow<&u32> for Integer

type Output = Integer

The result after applying the operator.

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

Returns self to the power rhs.

impl<'a> Pow<Integer> for &'a Complex

type Output = PowOwnedIntegerIncomplete<'a>

The result after applying the operator.

fn pow(self, rhs: Integer) -> PowOwnedIntegerIncomplete<'a>

Returns self to the power rhs.

impl<'a> Pow<Integer> for &'a Float

type Output = PowOwnedIntegerIncomplete<'a>

The result after applying the operator.

fn pow(self, rhs: Integer) -> PowOwnedIntegerIncomplete<'a>

Returns self to the power rhs.

impl Pow<Integer> for Complex

type Output = Complex

The result after applying the operator.

fn pow(self, rhs: Integer) -> Complex

Returns self to the power rhs.

impl Pow<Integer> for Float

type Output = Float

The result after applying the operator.

fn pow(self, rhs: Integer) -> Float

Returns self to the power rhs.

impl<'b> Pow<u32> for &'b Integer

type Output = PowU32Incomplete<'b>

The result after applying the operator.

fn pow(self, rhs: u32) -> PowU32Incomplete<'b>

Returns self to the power rhs.

impl Pow<u32> for Integer

type Output = Integer

The result after applying the operator.

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

Returns self to the power rhs.

impl PowAssign<&Integer> for Complex

fn pow_assign(&mut self, rhs: &Integer)

Peforms the power operation.

impl PowAssign<&Integer> for Float

fn pow_assign(&mut self, rhs: &Integer)

Peforms the power operation.

impl PowAssign<&u32> for Integer

fn pow_assign(&mut self, rhs: &u32)

Peforms the power operation.

impl PowAssign<Integer> for Complex

fn pow_assign(&mut self, rhs: Integer)

Peforms the power operation.

impl PowAssign<Integer> for Float

fn pow_assign(&mut self, rhs: Integer)

Peforms the power operation.

impl PowAssign<u32> for Integer

fn pow_assign(&mut self, rhs: u32)

Peforms the power operation.

impl PowAssignRound<&Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round( &mut self, rhs: &Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the power operation.

impl PowAssignRound<&Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering

Performs the power operation.

impl PowAssignRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round( &mut self, rhs: Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the power operation.

impl PowAssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn pow_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering

Performs the power operation.

impl<T> Product<T> for Integer

where Integer: MulAssign<T>,

fn product<I>(iter: I) -> Integer

where I: Iterator<Item = T>,

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'b> Rem<&'b Integer> for &i128

type Output = RemFromI128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromI128Incomplete<'b>

Performs the % operation.

impl<'b> Rem<&'b Integer> for &i16

type Output = RemFromI16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromI16Incomplete<'b>

Performs the % operation.

impl<'b> Rem<&'b Integer> for &i32

type Output = RemFromI32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromI32Incomplete<'b>

Performs the % operation.

impl<'b> Rem<&'b Integer> for &i64

type Output = RemFromI64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromI64Incomplete<'b>

Performs the % operation.

impl<'b> Rem<&'b Integer> for &i8

type Output = RemFromI8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromI8Incomplete<'b>

Performs the % operation.

impl<'b> Rem<&'b Integer> for &isize

type Output = RemFromIsizeIncomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromIsizeIncomplete<'b>

Performs the % operation.

impl<'b> Rem<&'b Integer> for &u128

type Output = RemFromU128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromU128Incomplete<'b>

Performs the % operation.

impl<'b> Rem<&'b Integer> for &u16

type Output = RemFromU16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromU16Incomplete<'b>

Performs the % operation.

impl<'b> Rem<&'b Integer> for &u32

type Output = RemFromU32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromU32Incomplete<'b>

Performs the % operation.

impl<'b> Rem<&'b Integer> for &u64

type Output = RemFromU64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromU64Incomplete<'b>

Performs the % operation.

impl<'b> Rem<&'b Integer> for &u8

type Output = RemFromU8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromU8Incomplete<'b>

Performs the % operation.

impl<'b> Rem<&'b Integer> for &usize

type Output = RemFromUsizeIncomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromUsizeIncomplete<'b>

Performs the % operation.

impl Rem<&Integer> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b> Rem<&'b Integer> for i128

type Output = RemFromI128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromI128Incomplete<'_>

Performs the % operation.

impl<'b> Rem<&'b Integer> for i16

type Output = RemFromI16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromI16Incomplete<'_>

Performs the % operation.

impl<'b> Rem<&'b Integer> for i32

type Output = RemFromI32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromI32Incomplete<'_>

Performs the % operation.

impl<'b> Rem<&'b Integer> for i64

type Output = RemFromI64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromI64Incomplete<'_>

Performs the % operation.

impl<'b> Rem<&'b Integer> for i8

type Output = RemFromI8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromI8Incomplete<'_>

Performs the % operation.

impl<'b> Rem<&'b Integer> for isize

type Output = RemFromIsizeIncomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromIsizeIncomplete<'_>

Performs the % operation.

impl<'b> Rem<&'b Integer> for u128

type Output = RemFromU128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromU128Incomplete<'_>

Performs the % operation.

impl<'b> Rem<&'b Integer> for u16

type Output = RemFromU16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromU16Incomplete<'_>

Performs the % operation.

impl<'b> Rem<&'b Integer> for u32

type Output = RemFromU32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromU32Incomplete<'_>

Performs the % operation.

impl<'b> Rem<&'b Integer> for u64

type Output = RemFromU64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromU64Incomplete<'_>

Performs the % operation.

impl<'b> Rem<&'b Integer> for u8

type Output = RemFromU8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromU8Incomplete<'_>

Performs the % operation.

impl<'b> Rem<&'b Integer> for usize

type Output = RemFromUsizeIncomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &Integer) -> RemFromUsizeIncomplete<'_>

Performs the % operation.

impl<'b> Rem<&i128> for &'b Integer

type Output = RemI128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &i128) -> RemI128Incomplete<'b>

Performs the % operation.

impl Rem<&i128> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b> Rem<&i16> for &'b Integer

type Output = RemI16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> RemI16Incomplete<'b>

Performs the % operation.

impl Rem<&i16> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b> Rem<&i32> for &'b Integer

type Output = RemI32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> RemI32Incomplete<'b>

Performs the % operation.

impl Rem<&i32> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b> Rem<&i64> for &'b Integer

type Output = RemI64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> RemI64Incomplete<'b>

Performs the % operation.

impl Rem<&i64> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b> Rem<&i8> for &'b Integer

type Output = RemI8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> RemI8Incomplete<'b>

Performs the % operation.

impl Rem<&i8> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b> Rem<&isize> for &'b Integer

type Output = RemIsizeIncomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> RemIsizeIncomplete<'b>

Performs the % operation.

impl Rem<&isize> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> Integer

Performs the % operation.

impl<'b> Rem<&u128> for &'b Integer

type Output = RemU128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &u128) -> RemU128Incomplete<'b>

Performs the % operation.

impl Rem<&u128> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b> Rem<&u16> for &'b Integer

type Output = RemU16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> RemU16Incomplete<'b>

Performs the % operation.

impl Rem<&u16> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b> Rem<&u32> for &'b Integer

type Output = RemU32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> RemU32Incomplete<'b>

Performs the % operation.

impl Rem<&u32> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b> Rem<&u64> for &'b Integer

type Output = RemU64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> RemU64Incomplete<'b>

Performs the % operation.

impl Rem<&u64> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b> Rem<&u8> for &'b Integer

type Output = RemU8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &u8) -> RemU8Incomplete<'b>

Performs the % operation.

impl Rem<&u8> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b> Rem<&usize> for &'b Integer

type Output = RemUsizeIncomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &usize) -> RemUsizeIncomplete<'b>

Performs the % operation.

impl Rem<&usize> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: &usize) -> Integer

Performs the % operation.

impl Rem<Integer> for &Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<Integer> for &i128

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for &i16

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for &i32

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for &i64

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for &i8

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for &isize

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for &u128

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for &u16

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for &u32

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for &u64

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for &u8

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for &usize

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for i128

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for i16

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for i32

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for i64

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for i8

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for isize

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for u128

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for u16

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for u32

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for u64

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for u8

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl Rem<Integer> for usize

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl<'b> Rem<i128> for &'b Integer

type Output = RemI128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> RemI128Incomplete<'b>

Performs the % operation.

impl Rem<i128> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> Integer

Performs the % operation.

impl<'b> Rem<i16> for &'b Integer

type Output = RemI16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> RemI16Incomplete<'b>

Performs the % operation.

impl Rem<i16> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Integer

Performs the % operation.

impl<'b> Rem<i32> for &'b Integer

type Output = RemI32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> RemI32Incomplete<'b>

Performs the % operation.

impl Rem<i32> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Integer

Performs the % operation.

impl<'b> Rem<i64> for &'b Integer

type Output = RemI64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> RemI64Incomplete<'b>

Performs the % operation.

impl Rem<i64> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Integer

Performs the % operation.

impl<'b> Rem<i8> for &'b Integer

type Output = RemI8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> RemI8Incomplete<'b>

Performs the % operation.

impl Rem<i8> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> Integer

Performs the % operation.

impl<'b> Rem<isize> for &'b Integer

type Output = RemIsizeIncomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> RemIsizeIncomplete<'b>

Performs the % operation.

impl Rem<isize> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> Integer

Performs the % operation.

impl<'b> Rem<u128> for &'b Integer

type Output = RemU128Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: u128) -> RemU128Incomplete<'b>

Performs the % operation.

impl Rem<u128> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: u128) -> Integer

Performs the % operation.

impl<'b> Rem<u16> for &'b Integer

type Output = RemU16Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> RemU16Incomplete<'b>

Performs the % operation.

impl Rem<u16> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Integer

Performs the % operation.

impl<'b> Rem<u32> for &'b Integer

type Output = RemU32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> RemU32Incomplete<'b>

Performs the % operation.

impl Rem<u32> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Integer

Performs the % operation.

impl<'b> Rem<u64> for &'b Integer

type Output = RemU64Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> RemU64Incomplete<'b>

Performs the % operation.

impl Rem<u64> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Integer

Performs the % operation.

impl<'b> Rem<u8> for &'b Integer

type Output = RemU8Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> RemU8Incomplete<'b>

Performs the % operation.

impl Rem<u8> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> Integer

Performs the % operation.

impl<'b> Rem<usize> for &'b Integer

type Output = RemUsizeIncomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> RemUsizeIncomplete<'b>

Performs the % operation.

impl Rem<usize> for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> Integer

Performs the % operation.

impl<'a> Rem for &'a Integer

type Output = RemIncomplete<'a>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Integer) -> RemIncomplete<'_>

Performs the % operation.

impl Rem for Integer

type Output = Integer

The resulting type after applying the % operator.

fn rem(self, rhs: Integer) -> Integer

Performs the % operation.

impl RemAssign<&Integer> for Integer

fn rem_assign(&mut self, rhs: &Integer)

Performs the %= operation.

impl RemAssign<&i128> for Integer

fn rem_assign(&mut self, rhs: &i128)

Performs the %= operation.

impl RemAssign<&i16> for Integer

fn rem_assign(&mut self, rhs: &i16)

Performs the %= operation.

impl RemAssign<&i32> for Integer

fn rem_assign(&mut self, rhs: &i32)

Performs the %= operation.

impl RemAssign<&i64> for Integer

fn rem_assign(&mut self, rhs: &i64)

Performs the %= operation.

impl RemAssign<&i8> for Integer

fn rem_assign(&mut self, rhs: &i8)

Performs the %= operation.

impl RemAssign<&isize> for Integer

fn rem_assign(&mut self, rhs: &isize)

Performs the %= operation.

impl RemAssign<&u128> for Integer

fn rem_assign(&mut self, rhs: &u128)

Performs the %= operation.

impl RemAssign<&u16> for Integer

fn rem_assign(&mut self, rhs: &u16)

Performs the %= operation.

impl RemAssign<&u32> for Integer

fn rem_assign(&mut self, rhs: &u32)

Performs the %= operation.

impl RemAssign<&u64> for Integer

fn rem_assign(&mut self, rhs: &u64)

Performs the %= operation.

impl RemAssign<&u8> for Integer

fn rem_assign(&mut self, rhs: &u8)

Performs the %= operation.

impl RemAssign<&usize> for Integer

fn rem_assign(&mut self, rhs: &usize)

Performs the %= operation.

impl RemAssign<i128> for Integer

fn rem_assign(&mut self, rhs: i128)

Performs the %= operation.

impl RemAssign<i16> for Integer

fn rem_assign(&mut self, rhs: i16)

Performs the %= operation.

impl RemAssign<i32> for Integer

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl RemAssign<i64> for Integer

fn rem_assign(&mut self, rhs: i64)

Performs the %= operation.

impl RemAssign<i8> for Integer

fn rem_assign(&mut self, rhs: i8)

Performs the %= operation.

impl RemAssign<isize> for Integer

fn rem_assign(&mut self, rhs: isize)

Performs the %= operation.

impl RemAssign<u128> for Integer

fn rem_assign(&mut self, rhs: u128)

Performs the %= operation.

impl RemAssign<u16> for Integer

fn rem_assign(&mut self, rhs: u16)

Performs the %= operation.

impl RemAssign<u32> for Integer

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl RemAssign<u64> for Integer

fn rem_assign(&mut self, rhs: u64)

Performs the %= operation.

impl RemAssign<u8> for Integer

fn rem_assign(&mut self, rhs: u8)

Performs the %= operation.

impl RemAssign<usize> for Integer

fn rem_assign(&mut self, rhs: usize)

Performs the %= operation.

impl RemAssign for Integer

fn rem_assign(&mut self, rhs: Integer)

Performs the %= operation.

impl RemFrom<&Integer> for Integer

fn rem_from(&mut self, lhs: &Integer)

Peforms the remainder operation.

impl RemFrom<&i128> for Integer

fn rem_from(&mut self, lhs: &i128)

Peforms the remainder operation.

impl RemFrom<&i16> for Integer

fn rem_from(&mut self, lhs: &i16)

Peforms the remainder operation.

impl RemFrom<&i32> for Integer

fn rem_from(&mut self, lhs: &i32)

Peforms the remainder operation.

impl RemFrom<&i64> for Integer

fn rem_from(&mut self, lhs: &i64)

Peforms the remainder operation.

impl RemFrom<&i8> for Integer

fn rem_from(&mut self, lhs: &i8)

Peforms the remainder operation.

impl RemFrom<&isize> for Integer

fn rem_from(&mut self, lhs: &isize)

Peforms the remainder operation.

impl RemFrom<&u128> for Integer

fn rem_from(&mut self, lhs: &u128)

Peforms the remainder operation.

impl RemFrom<&u16> for Integer

fn rem_from(&mut self, lhs: &u16)

Peforms the remainder operation.

impl RemFrom<&u32> for Integer

fn rem_from(&mut self, lhs: &u32)

Peforms the remainder operation.

impl RemFrom<&u64> for Integer

fn rem_from(&mut self, lhs: &u64)

Peforms the remainder operation.

impl RemFrom<&u8> for Integer

fn rem_from(&mut self, lhs: &u8)

Peforms the remainder operation.

impl RemFrom<&usize> for Integer

fn rem_from(&mut self, lhs: &usize)

Peforms the remainder operation.

impl RemFrom<i128> for Integer

fn rem_from(&mut self, lhs: i128)

Peforms the remainder operation.

impl RemFrom<i16> for Integer

fn rem_from(&mut self, lhs: i16)

Peforms the remainder operation.

impl RemFrom<i32> for Integer

fn rem_from(&mut self, lhs: i32)

Peforms the remainder operation.

impl RemFrom<i64> for Integer

fn rem_from(&mut self, lhs: i64)

Peforms the remainder operation.

impl RemFrom<i8> for Integer

fn rem_from(&mut self, lhs: i8)

Peforms the remainder operation.

impl RemFrom<isize> for Integer

fn rem_from(&mut self, lhs: isize)

Peforms the remainder operation.

impl RemFrom<u128> for Integer

fn rem_from(&mut self, lhs: u128)

Peforms the remainder operation.

impl RemFrom<u16> for Integer

fn rem_from(&mut self, lhs: u16)

Peforms the remainder operation.

impl RemFrom<u32> for Integer

fn rem_from(&mut self, lhs: u32)

Peforms the remainder operation.

impl RemFrom<u64> for Integer

fn rem_from(&mut self, lhs: u64)

Peforms the remainder operation.

impl RemFrom<u8> for Integer

fn rem_from(&mut self, lhs: u8)

Peforms the remainder operation.

impl RemFrom<usize> for Integer

fn rem_from(&mut self, lhs: usize)

Peforms the remainder operation.

impl RemFrom for Integer

fn rem_from(&mut self, lhs: Integer)

Peforms the remainder operation.

impl<'i> RemRounding<&'i Integer> for &i128

type Output = RemRoundingFromI128Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for &i16

type Output = RemRoundingFromI16Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for &i32

type Output = RemRoundingFromI32Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for &i64

type Output = RemRoundingFromI64Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for &i8

type Output = RemRoundingFromI8Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for &u128

type Output = RemRoundingFromU128Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for &u16

type Output = RemRoundingFromU16Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for &u32

type Output = RemRoundingFromU32Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for &u64

type Output = RemRoundingFromU64Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for &u8

type Output = RemRoundingFromU8Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<&Integer> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for i128

type Output = RemRoundingFromI128Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for i16

type Output = RemRoundingFromI16Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for i32

type Output = RemRoundingFromI32Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for i64

type Output = RemRoundingFromI64Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for i8

type Output = RemRoundingFromI8Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for u128

type Output = RemRoundingFromU128Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for u16

type Output = RemRoundingFromU16Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for u32

type Output = RemRoundingFromU32Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for u64

type Output = RemRoundingFromU64Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<&'i Integer> for u8

type Output = RemRoundingFromU8Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>

Finds the positive remainder from Euclidean division.

impl<'t, 'i> RemRounding<&'t i128> for &'i Integer

type Output = RemRoundingI128Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<&i128> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &i128) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &i128) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &i128) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &i128) -> Integer

Finds the positive remainder from Euclidean division.

impl<'t, 'i> RemRounding<&'t i16> for &'i Integer

type Output = RemRoundingI16Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<&i16> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &i16) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &i16) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &i16) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &i16) -> Integer

Finds the positive remainder from Euclidean division.

impl<'t, 'i> RemRounding<&'t i32> for &'i Integer

type Output = RemRoundingI32Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<&i32> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &i32) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &i32) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &i32) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &i32) -> Integer

Finds the positive remainder from Euclidean division.

impl<'t, 'i> RemRounding<&'t i64> for &'i Integer

type Output = RemRoundingI64Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<&i64> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &i64) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &i64) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &i64) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &i64) -> Integer

Finds the positive remainder from Euclidean division.

impl<'t, 'i> RemRounding<&'t i8> for &'i Integer

type Output = RemRoundingI8Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<&i8> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &i8) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &i8) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &i8) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &i8) -> Integer

Finds the positive remainder from Euclidean division.

impl<'t, 'i> RemRounding<&'t u128> for &'i Integer

type Output = RemRoundingU128Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<&u128> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &u128) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &u128) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &u128) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &u128) -> Integer

Finds the positive remainder from Euclidean division.

impl<'t, 'i> RemRounding<&'t u16> for &'i Integer

type Output = RemRoundingU16Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<&u16> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &u16) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &u16) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &u16) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &u16) -> Integer

Finds the positive remainder from Euclidean division.

impl<'t, 'i> RemRounding<&'t u32> for &'i Integer

type Output = RemRoundingU32Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<&u32> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &u32) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &u32) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &u32) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &u32) -> Integer

Finds the positive remainder from Euclidean division.

impl<'t, 'i> RemRounding<&'t u64> for &'i Integer

type Output = RemRoundingU64Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<&u64> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &u64) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &u64) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &u64) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &u64) -> Integer

Finds the positive remainder from Euclidean division.

impl<'t, 'i> RemRounding<&'t u8> for &'i Integer

type Output = RemRoundingU8Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<&u8> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &u8) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &u8) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &u8) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &u8) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for &Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for &i128

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for &i16

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for &i32

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for &i64

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for &i8

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for &u128

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for &u16

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for &u32

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for &u64

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for &u8

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for i128

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for i16

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for i32

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for i64

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for i8

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for u128

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for u16

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for u32

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for u64

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRounding<Integer> for u8

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<i128> for &'i Integer

type Output = RemRoundingI128Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: i128) -> RemRoundingI128Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: i128) -> RemRoundingI128Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: i128) -> RemRoundingI128Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: i128) -> RemRoundingI128Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<i128> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: i128) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: i128) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: i128) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: i128) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<i16> for &'i Integer

type Output = RemRoundingI16Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: i16) -> RemRoundingI16Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: i16) -> RemRoundingI16Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: i16) -> RemRoundingI16Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: i16) -> RemRoundingI16Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<i16> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: i16) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: i16) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: i16) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: i16) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<i32> for &'i Integer

type Output = RemRoundingI32Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: i32) -> RemRoundingI32Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: i32) -> RemRoundingI32Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: i32) -> RemRoundingI32Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: i32) -> RemRoundingI32Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<i32> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: i32) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: i32) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: i32) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: i32) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<i64> for &'i Integer

type Output = RemRoundingI64Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: i64) -> RemRoundingI64Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: i64) -> RemRoundingI64Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: i64) -> RemRoundingI64Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: i64) -> RemRoundingI64Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<i64> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: i64) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: i64) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: i64) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: i64) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<i8> for &'i Integer

type Output = RemRoundingI8Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: i8) -> RemRoundingI8Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: i8) -> RemRoundingI8Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: i8) -> RemRoundingI8Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: i8) -> RemRoundingI8Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<i8> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: i8) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: i8) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: i8) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: i8) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<u128> for &'i Integer

type Output = RemRoundingU128Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: u128) -> RemRoundingU128Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: u128) -> RemRoundingU128Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: u128) -> RemRoundingU128Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: u128) -> RemRoundingU128Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<u128> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: u128) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: u128) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: u128) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: u128) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<u16> for &'i Integer

type Output = RemRoundingU16Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: u16) -> RemRoundingU16Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: u16) -> RemRoundingU16Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: u16) -> RemRoundingU16Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: u16) -> RemRoundingU16Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<u16> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: u16) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: u16) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: u16) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: u16) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<u32> for &'i Integer

type Output = RemRoundingU32Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: u32) -> RemRoundingU32Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: u32) -> RemRoundingU32Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: u32) -> RemRoundingU32Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: u32) -> RemRoundingU32Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<u32> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: u32) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: u32) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: u32) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: u32) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<u64> for &'i Integer

type Output = RemRoundingU64Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: u64) -> RemRoundingU64Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: u64) -> RemRoundingU64Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: u64) -> RemRoundingU64Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: u64) -> RemRoundingU64Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<u64> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: u64) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: u64) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: u64) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: u64) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding<u8> for &'i Integer

type Output = RemRoundingU8Incomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: u8) -> RemRoundingU8Incomplete<'i>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: u8) -> RemRoundingU8Incomplete<'i>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: u8) -> RemRoundingU8Incomplete<'i>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: u8) -> RemRoundingU8Incomplete<'i>

Finds the positive remainder from Euclidean division.

impl RemRounding<u8> for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: u8) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: u8) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: u8) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: u8) -> Integer

Finds the positive remainder from Euclidean division.

impl<'i> RemRounding for &'i Integer

type Output = RemRoundingIncomplete<'i>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>

Finds the positive remainder from Euclidean division.

impl RemRounding for Integer

type Output = Integer

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: Integer) -> Integer

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: Integer) -> Integer

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<&Integer> for Integer

fn rem_trunc_assign(&mut self, rhs: &Integer)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &Integer)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &Integer)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &Integer)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<&i128> for Integer

fn rem_trunc_assign(&mut self, rhs: &i128)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &i128)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &i128)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &i128)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<&i16> for Integer

fn rem_trunc_assign(&mut self, rhs: &i16)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &i16)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &i16)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &i16)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<&i32> for Integer

fn rem_trunc_assign(&mut self, rhs: &i32)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &i32)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &i32)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &i32)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<&i64> for Integer

fn rem_trunc_assign(&mut self, rhs: &i64)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &i64)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &i64)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &i64)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<&i8> for Integer

fn rem_trunc_assign(&mut self, rhs: &i8)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &i8)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &i8)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &i8)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<&u128> for Integer

fn rem_trunc_assign(&mut self, rhs: &u128)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &u128)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &u128)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &u128)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<&u16> for Integer

fn rem_trunc_assign(&mut self, rhs: &u16)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &u16)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &u16)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &u16)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<&u32> for Integer

fn rem_trunc_assign(&mut self, rhs: &u32)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &u32)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &u32)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &u32)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<&u64> for Integer

fn rem_trunc_assign(&mut self, rhs: &u64)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &u64)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &u64)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &u64)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<&u8> for Integer

fn rem_trunc_assign(&mut self, rhs: &u8)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &u8)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &u8)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &u8)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<i128> for Integer

fn rem_trunc_assign(&mut self, rhs: i128)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: i128)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: i128)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: i128)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<i16> for Integer

fn rem_trunc_assign(&mut self, rhs: i16)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: i16)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: i16)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: i16)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<i32> for Integer

fn rem_trunc_assign(&mut self, rhs: i32)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: i32)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: i32)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: i32)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<i64> for Integer

fn rem_trunc_assign(&mut self, rhs: i64)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: i64)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: i64)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: i64)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<i8> for Integer

fn rem_trunc_assign(&mut self, rhs: i8)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: i8)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: i8)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: i8)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<u128> for Integer

fn rem_trunc_assign(&mut self, rhs: u128)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: u128)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: u128)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: u128)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<u16> for Integer

fn rem_trunc_assign(&mut self, rhs: u16)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: u16)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: u16)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: u16)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<u32> for Integer

fn rem_trunc_assign(&mut self, rhs: u32)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: u32)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: u32)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: u32)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<u64> for Integer

fn rem_trunc_assign(&mut self, rhs: u64)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: u64)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: u64)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: u64)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<u8> for Integer

fn rem_trunc_assign(&mut self, rhs: u8)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: u8)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: u8)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: u8)

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign for Integer

fn rem_trunc_assign(&mut self, rhs: Integer)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: Integer)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: Integer)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: Integer)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<&Integer> for Integer

fn rem_trunc_from(&mut self, lhs: &Integer)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &Integer)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &Integer)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &Integer)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<&i128> for Integer

fn rem_trunc_from(&mut self, lhs: &i128)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &i128)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &i128)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &i128)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<&i16> for Integer

fn rem_trunc_from(&mut self, lhs: &i16)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &i16)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &i16)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &i16)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<&i32> for Integer

fn rem_trunc_from(&mut self, lhs: &i32)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &i32)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &i32)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &i32)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<&i64> for Integer

fn rem_trunc_from(&mut self, lhs: &i64)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &i64)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &i64)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &i64)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<&i8> for Integer

fn rem_trunc_from(&mut self, lhs: &i8)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &i8)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &i8)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &i8)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<&u128> for Integer

fn rem_trunc_from(&mut self, lhs: &u128)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &u128)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &u128)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &u128)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<&u16> for Integer

fn rem_trunc_from(&mut self, lhs: &u16)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &u16)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &u16)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &u16)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<&u32> for Integer

fn rem_trunc_from(&mut self, lhs: &u32)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &u32)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &u32)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &u32)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<&u64> for Integer

fn rem_trunc_from(&mut self, lhs: &u64)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &u64)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &u64)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &u64)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<&u8> for Integer

fn rem_trunc_from(&mut self, lhs: &u8)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &u8)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &u8)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &u8)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<i128> for Integer

fn rem_trunc_from(&mut self, lhs: i128)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: i128)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: i128)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: i128)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<i16> for Integer

fn rem_trunc_from(&mut self, lhs: i16)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: i16)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: i16)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: i16)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<i32> for Integer

fn rem_trunc_from(&mut self, lhs: i32)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: i32)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: i32)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: i32)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<i64> for Integer

fn rem_trunc_from(&mut self, lhs: i64)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: i64)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: i64)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: i64)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<i8> for Integer

fn rem_trunc_from(&mut self, lhs: i8)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: i8)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: i8)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: i8)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<u128> for Integer

fn rem_trunc_from(&mut self, lhs: u128)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: u128)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: u128)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: u128)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<u16> for Integer

fn rem_trunc_from(&mut self, lhs: u16)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: u16)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: u16)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: u16)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<u32> for Integer

fn rem_trunc_from(&mut self, lhs: u32)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: u32)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: u32)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: u32)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<u64> for Integer

fn rem_trunc_from(&mut self, lhs: u64)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: u64)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: u64)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: u64)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<u8> for Integer

fn rem_trunc_from(&mut self, lhs: u8)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: u8)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: u8)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: u8)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom for Integer

fn rem_trunc_from(&mut self, lhs: Integer)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: Integer)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: Integer)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: Integer)

Finds the positive remainder from Euclidean division.

impl Roots for Integer

fn nth_root(&self, n: u32) -> Self

Returns the truncated principal nth root of an integer – if x >= 0 { ⌊ⁿ√x⌋ } else { ⌈ⁿ√x⌉ }

fn sqrt(&self) -> Self

Returns the truncated principal square root of an integer – ⌊√x⌋

fn cbrt(&self) -> Self

Returns the truncated principal cube root of an integer – if x >= 0 { ⌊∛x⌋ } else { ⌈∛x⌉ }

impl SaturatingCast<i128> for &Integer

fn saturating_cast(self) -> i128

Casts the value.

impl SaturatingCast<i128> for Integer

fn saturating_cast(self) -> i128

Casts the value.

impl SaturatingCast<i16> for &Integer

fn saturating_cast(self) -> i16

Casts the value.

impl SaturatingCast<i16> for Integer

fn saturating_cast(self) -> i16

Casts the value.

impl SaturatingCast<i32> for &Integer

fn saturating_cast(self) -> i32

Casts the value.

impl SaturatingCast<i32> for Integer

fn saturating_cast(self) -> i32

Casts the value.

impl SaturatingCast<i64> for &Integer

fn saturating_cast(self) -> i64

Casts the value.

impl SaturatingCast<i64> for Integer

fn saturating_cast(self) -> i64

Casts the value.

impl SaturatingCast<i8> for &Integer

fn saturating_cast(self) -> i8

Casts the value.

impl SaturatingCast<i8> for Integer

fn saturating_cast(self) -> i8

Casts the value.

impl SaturatingCast<isize> for &Integer

fn saturating_cast(self) -> isize

Casts the value.

impl SaturatingCast<isize> for Integer

fn saturating_cast(self) -> isize

Casts the value.

impl SaturatingCast<u128> for &Integer

fn saturating_cast(self) -> u128

Casts the value.

impl SaturatingCast<u128> for Integer

fn saturating_cast(self) -> u128

Casts the value.

impl SaturatingCast<u16> for &Integer

fn saturating_cast(self) -> u16

Casts the value.

impl SaturatingCast<u16> for Integer

fn saturating_cast(self) -> u16

Casts the value.

impl SaturatingCast<u32> for &Integer

fn saturating_cast(self) -> u32

Casts the value.

impl SaturatingCast<u32> for Integer

fn saturating_cast(self) -> u32

Casts the value.

impl SaturatingCast<u64> for &Integer

fn saturating_cast(self) -> u64

Casts the value.

impl SaturatingCast<u64> for Integer

fn saturating_cast(self) -> u64

Casts the value.

impl SaturatingCast<u8> for &Integer

fn saturating_cast(self) -> u8

Casts the value.

impl SaturatingCast<u8> for Integer

fn saturating_cast(self) -> u8

Casts the value.

impl SaturatingCast<usize> for &Integer

fn saturating_cast(self) -> usize

Casts the value.

impl SaturatingCast<usize> for Integer

fn saturating_cast(self) -> usize

Casts the value.

impl Serialize for Integer

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<'b> Shl<&i32> for &'b Integer

type Output = ShlI32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> ShlI32Incomplete<'b>

Performs the << operation.

impl Shl<&i32> for Integer

type Output = Integer

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> Integer

Performs the << operation.

impl<'b> Shl<&isize> for &'b Integer

type Output = ShlIsizeIncomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> ShlIsizeIncomplete<'b>

Performs the << operation.

impl Shl<&isize> for Integer

type Output = Integer

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> Integer

Performs the << operation.

impl<'b> Shl<&u32> for &'b Integer

type Output = ShlU32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> ShlU32Incomplete<'b>

Performs the << operation.

impl Shl<&u32> for Integer

type Output = Integer

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> Integer

Performs the << operation.

impl<'b> Shl<&usize> for &'b Integer

type Output = ShlUsizeIncomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> ShlUsizeIncomplete<'b>

Performs the << operation.

impl Shl<&usize> for Integer

type Output = Integer

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> Integer

Performs the << operation.

impl<'b> Shl<i32> for &'b Integer

type Output = ShlI32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> ShlI32Incomplete<'b>

Performs the << operation.

impl Shl<i32> for Integer

type Output = Integer

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> Integer

Performs the << operation.

impl<'b> Shl<isize> for &'b Integer

type Output = ShlIsizeIncomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> ShlIsizeIncomplete<'b>

Performs the << operation.

impl Shl<isize> for Integer

type Output = Integer

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> Integer

Performs the << operation.

impl<'b> Shl<u32> for &'b Integer

type Output = ShlU32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> ShlU32Incomplete<'b>

Performs the << operation.

impl Shl<u32> for Integer

type Output = Integer

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Integer

Performs the << operation.

impl<'b> Shl<usize> for &'b Integer

type Output = ShlUsizeIncomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> ShlUsizeIncomplete<'b>

Performs the << operation.

impl Shl<usize> for Integer

type Output = Integer

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Integer

Performs the << operation.

impl ShlAssign<&i32> for Integer

fn shl_assign(&mut self, rhs: &i32)

Performs the <<= operation.

impl ShlAssign<&isize> for Integer

fn shl_assign(&mut self, rhs: &isize)

Performs the <<= operation.

impl ShlAssign<&u32> for Integer

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation.

impl ShlAssign<&usize> for Integer

fn shl_assign(&mut self, rhs: &usize)

Performs the <<= operation.

impl ShlAssign<i32> for Integer

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl ShlAssign<isize> for Integer

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl ShlAssign<u32> for Integer

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl ShlAssign<usize> for Integer

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl<'b> Shr<&i32> for &'b Integer

type Output = ShrI32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> ShrI32Incomplete<'b>

Performs the >> operation.

impl Shr<&i32> for Integer

type Output = Integer

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> Integer

Performs the >> operation.

impl<'b> Shr<&isize> for &'b Integer

type Output = ShrIsizeIncomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> ShrIsizeIncomplete<'b>

Performs the >> operation.

impl Shr<&isize> for Integer

type Output = Integer

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> Integer

Performs the >> operation.

impl<'b> Shr<&u32> for &'b Integer

type Output = ShrU32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> ShrU32Incomplete<'b>

Performs the >> operation.

impl Shr<&u32> for Integer

type Output = Integer

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> Integer

Performs the >> operation.

impl<'b> Shr<&usize> for &'b Integer

type Output = ShrUsizeIncomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> ShrUsizeIncomplete<'b>

Performs the >> operation.

impl Shr<&usize> for Integer

type Output = Integer

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> Integer

Performs the >> operation.

impl<'b> Shr<i32> for &'b Integer

type Output = ShrI32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> ShrI32Incomplete<'b>

Performs the >> operation.

impl Shr<i32> for Integer

type Output = Integer

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> Integer

Performs the >> operation.

impl<'b> Shr<isize> for &'b Integer

type Output = ShrIsizeIncomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> ShrIsizeIncomplete<'b>

Performs the >> operation.

impl Shr<isize> for Integer

type Output = Integer

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> Integer

Performs the >> operation.

impl<'b> Shr<u32> for &'b Integer

type Output = ShrU32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> ShrU32Incomplete<'b>

Performs the >> operation.

impl Shr<u32> for Integer

type Output = Integer

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Integer

Performs the >> operation.

impl<'b> Shr<usize> for &'b Integer

type Output = ShrUsizeIncomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> ShrUsizeIncomplete<'b>

Performs the >> operation.

impl Shr<usize> for Integer

type Output = Integer

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Integer

Performs the >> operation.

impl ShrAssign<&i32> for Integer

fn shr_assign(&mut self, rhs: &i32)

Performs the >>= operation.

impl ShrAssign<&isize> for Integer

fn shr_assign(&mut self, rhs: &isize)

Performs the >>= operation.

impl ShrAssign<&u32> for Integer

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl ShrAssign<&usize> for Integer

fn shr_assign(&mut self, rhs: &usize)

Performs the >>= operation.

impl ShrAssign<i32> for Integer

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl ShrAssign<isize> for Integer

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl ShrAssign<u32> for Integer

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl ShrAssign<usize> for Integer

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl Signed for Integer

fn abs(&self) -> Self

Computes the absolute value.

fn abs_sub(&self, other: &Self) -> Self

The positive difference of two numbers.

fn signum(&self) -> Self

Returns the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

impl<'a> Sub<&'a Complex> for &'a Integer

type Output = SubFromIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Complex) -> SubFromIntegerIncomplete<'_>

Performs the - operation.

impl<'a> Sub<&'a Complex> for Integer

type Output = SubFromOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &Complex) -> SubFromOwnedIntegerIncomplete<'_>

Performs the - operation.

impl<'a> Sub<&'a Float> for &'a Integer

type Output = SubFromIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Float) -> SubFromIntegerIncomplete<'_>

Performs the - operation.

impl<'a> Sub<&'a Float> for Integer

type Output = SubFromOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &Float) -> SubFromOwnedIntegerIncomplete<'_>

Performs the - operation.

impl<'a> Sub<&'a Integer> for &'a Complex

type Output = SubIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Integer) -> SubIntegerIncomplete<'_>

Performs the - operation.

impl<'a> Sub<&'a Integer> for &'a Float

type Output = SubIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Integer) -> SubIntegerIncomplete<'_>

Performs the - operation.

impl<'a> Sub<&'a Integer> for &'a Rational

type Output = SubIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Integer) -> SubIntegerIncomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &i128

type Output = SubFromI128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromI128Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &i16

type Output = SubFromI16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromI16Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &i32

type Output = SubFromI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromI32Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &i64

type Output = SubFromI64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromI64Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &i8

type Output = SubFromI8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromI8Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &isize

type Output = SubFromIsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromIsizeIncomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &u128

type Output = SubFromU128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromU128Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &u16

type Output = SubFromU16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromU16Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &u32

type Output = SubFromU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromU32Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &u64

type Output = SubFromU64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromU64Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &u8

type Output = SubFromU8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromU8Incomplete<'b>

Performs the - operation.

impl<'b> Sub<&'b Integer> for &usize

type Output = SubFromUsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromUsizeIncomplete<'b>

Performs the - operation.

impl Sub<&Integer> for Complex

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> Complex

Performs the - operation.

impl Sub<&Integer> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> Float

Performs the - operation.

impl Sub<&Integer> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> Integer

Performs the - operation.

impl Sub<&Integer> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> Rational

Performs the - operation.

impl<'b> Sub<&'b Integer> for i128

type Output = SubFromI128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromI128Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for i16

type Output = SubFromI16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromI16Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for i32

type Output = SubFromI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromI32Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for i64

type Output = SubFromI64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromI64Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for i8

type Output = SubFromI8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromI8Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for isize

type Output = SubFromIsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromIsizeIncomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for u128

type Output = SubFromU128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromU128Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for u16

type Output = SubFromU16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromU16Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for u32

type Output = SubFromU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromU32Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for u64

type Output = SubFromU64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromU64Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for u8

type Output = SubFromU8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromU8Incomplete<'_>

Performs the - operation.

impl<'b> Sub<&'b Integer> for usize

type Output = SubFromUsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &Integer) -> SubFromUsizeIncomplete<'_>

Performs the - operation.

impl<'a> Sub<&'a Rational> for &'a Integer

type Output = SubFromIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Rational) -> SubFromIntegerIncomplete<'_>

Performs the - operation.

impl<'a> Sub<&'a Rational> for Integer

type Output = SubFromOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &Rational) -> SubFromOwnedIntegerIncomplete<'_>

Performs the - operation.

impl<'b> Sub<&i128> for &'b Integer

type Output = SubI128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> SubI128Incomplete<'b>

Performs the - operation.

impl Sub<&i128> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> Integer

Performs the - operation.

impl<'b> Sub<&i16> for &'b Integer

type Output = SubI16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> SubI16Incomplete<'b>

Performs the - operation.

impl Sub<&i16> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Integer

Performs the - operation.

impl<'b> Sub<&i32> for &'b Integer

type Output = SubI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> SubI32Incomplete<'b>

Performs the - operation.

impl Sub<&i32> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Integer

Performs the - operation.

impl<'b> Sub<&i64> for &'b Integer

type Output = SubI64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> SubI64Incomplete<'b>

Performs the - operation.

impl Sub<&i64> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Integer

Performs the - operation.

impl<'b> Sub<&i8> for &'b Integer

type Output = SubI8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> SubI8Incomplete<'b>

Performs the - operation.

impl Sub<&i8> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> Integer

Performs the - operation.

impl<'b> Sub<&isize> for &'b Integer

type Output = SubIsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> SubIsizeIncomplete<'b>

Performs the - operation.

impl Sub<&isize> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Integer

Performs the - operation.

impl<'b> Sub<&u128> for &'b Integer

type Output = SubU128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> SubU128Incomplete<'b>

Performs the - operation.

impl Sub<&u128> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> Integer

Performs the - operation.

impl<'b> Sub<&u16> for &'b Integer

type Output = SubU16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> SubU16Incomplete<'b>

Performs the - operation.

impl Sub<&u16> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Integer

Performs the - operation.

impl<'b> Sub<&u32> for &'b Integer

type Output = SubU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> SubU32Incomplete<'b>

Performs the - operation.

impl Sub<&u32> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Integer

Performs the - operation.

impl<'b> Sub<&u64> for &'b Integer

type Output = SubU64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> SubU64Incomplete<'b>

Performs the - operation.

impl Sub<&u64> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Integer

Performs the - operation.

impl<'b> Sub<&u8> for &'b Integer

type Output = SubU8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> SubU8Incomplete<'b>

Performs the - operation.

impl Sub<&u8> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> Integer

Performs the - operation.

impl<'b> Sub<&usize> for &'b Integer

type Output = SubUsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> SubUsizeIncomplete<'b>

Performs the - operation.

impl Sub<&usize> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> Integer

Performs the - operation.

impl Sub<Complex> for &Integer

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: Complex) -> Complex

Performs the - operation.

impl Sub<Complex> for Integer

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: Complex) -> Complex

Performs the - operation.

impl Sub<Float> for &Integer

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: Float) -> Float

Performs the - operation.

impl Sub<Float> for Integer

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: Float) -> Float

Performs the - operation.

impl<'a> Sub<Integer> for &'a Complex

type Output = SubOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> SubOwnedIntegerIncomplete<'a>

Performs the - operation.

impl<'a> Sub<Integer> for &'a Float

type Output = SubOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> SubOwnedIntegerIncomplete<'a>

Performs the - operation.

impl Sub<Integer> for &Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl<'a> Sub<Integer> for &'a Rational

type Output = SubOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> SubOwnedIntegerIncomplete<'a>

Performs the - operation.

impl Sub<Integer> for &i128

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for &i16

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for &i32

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for &i64

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for &i8

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for &isize

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for &u128

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for &u16

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for &u32

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for &u64

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for &u8

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for &usize

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for Complex

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Complex

Performs the - operation.

impl Sub<Integer> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Float

Performs the - operation.

impl Sub<Integer> for Rational

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Rational

Performs the - operation.

impl Sub<Integer> for i128

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for i16

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for i32

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for i64

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for i8

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for isize

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for u128

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for u16

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for u32

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for u64

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for u8

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Integer> for usize

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl Sub<Rational> for &Integer

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: Rational) -> Rational

Performs the - operation.

impl Sub<Rational> for Integer

type Output = Rational

The resulting type after applying the - operator.

fn sub(self, rhs: Rational) -> Rational

Performs the - operation.

impl<'b> Sub<i128> for &'b Integer

type Output = SubI128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> SubI128Incomplete<'b>

Performs the - operation.

impl Sub<i128> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> Integer

Performs the - operation.

impl<'b> Sub<i16> for &'b Integer

type Output = SubI16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> SubI16Incomplete<'b>

Performs the - operation.

impl Sub<i16> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Integer

Performs the - operation.

impl<'b> Sub<i32> for &'b Integer

type Output = SubI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> SubI32Incomplete<'b>

Performs the - operation.

impl Sub<i32> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Integer

Performs the - operation.

impl<'b> Sub<i64> for &'b Integer

type Output = SubI64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> SubI64Incomplete<'b>

Performs the - operation.

impl Sub<i64> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Integer

Performs the - operation.

impl<'b> Sub<i8> for &'b Integer

type Output = SubI8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> SubI8Incomplete<'b>

Performs the - operation.

impl Sub<i8> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Integer

Performs the - operation.

impl<'b> Sub<isize> for &'b Integer

type Output = SubIsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> SubIsizeIncomplete<'b>

Performs the - operation.

impl Sub<isize> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> Integer

Performs the - operation.

impl<'b> Sub<u128> for &'b Integer

type Output = SubU128Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> SubU128Incomplete<'b>

Performs the - operation.

impl Sub<u128> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Integer

Performs the - operation.

impl<'b> Sub<u16> for &'b Integer

type Output = SubU16Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> SubU16Incomplete<'b>

Performs the - operation.

impl Sub<u16> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Integer

Performs the - operation.

impl<'b> Sub<u32> for &'b Integer

type Output = SubU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> SubU32Incomplete<'b>

Performs the - operation.

impl Sub<u32> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Integer

Performs the - operation.

impl<'b> Sub<u64> for &'b Integer

type Output = SubU64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> SubU64Incomplete<'b>

Performs the - operation.

impl Sub<u64> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Integer

Performs the - operation.

impl<'b> Sub<u8> for &'b Integer

type Output = SubU8Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> SubU8Incomplete<'b>

Performs the - operation.

impl Sub<u8> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Integer

Performs the - operation.

impl<'b> Sub<usize> for &'b Integer

type Output = SubUsizeIncomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> SubUsizeIncomplete<'b>

Performs the - operation.

impl Sub<usize> for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Integer

Performs the - operation.

impl<'a> Sub for &'a Integer

type Output = SubIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Integer) -> SubIncomplete<'_>

Performs the - operation.

impl Sub for Integer

type Output = Integer

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Integer

Performs the - operation.

impl SubAssign<&Integer> for Complex

fn sub_assign(&mut self, rhs: &Integer)

Performs the -= operation.

impl SubAssign<&Integer> for Float

fn sub_assign(&mut self, rhs: &Integer)

Performs the -= operation.

impl SubAssign<&Integer> for Integer

fn sub_assign(&mut self, rhs: &Integer)

Performs the -= operation.

impl SubAssign<&Integer> for Rational

fn sub_assign(&mut self, rhs: &Integer)

Performs the -= operation.

impl SubAssign<&i128> for Integer

fn sub_assign(&mut self, rhs: &i128)

Performs the -= operation.

impl SubAssign<&i16> for Integer

fn sub_assign(&mut self, rhs: &i16)

Performs the -= operation.

impl SubAssign<&i32> for Integer

fn sub_assign(&mut self, rhs: &i32)

Performs the -= operation.

impl SubAssign<&i64> for Integer

fn sub_assign(&mut self, rhs: &i64)

Performs the -= operation.

impl SubAssign<&i8> for Integer

fn sub_assign(&mut self, rhs: &i8)

Performs the -= operation.

impl SubAssign<&isize> for Integer

fn sub_assign(&mut self, rhs: &isize)

Performs the -= operation.

impl SubAssign<&u128> for Integer

fn sub_assign(&mut self, rhs: &u128)

Performs the -= operation.

impl SubAssign<&u16> for Integer

fn sub_assign(&mut self, rhs: &u16)

Performs the -= operation.

impl SubAssign<&u32> for Integer

fn sub_assign(&mut self, rhs: &u32)

Performs the -= operation.

impl SubAssign<&u64> for Integer

fn sub_assign(&mut self, rhs: &u64)

Performs the -= operation.

impl SubAssign<&u8> for Integer

fn sub_assign(&mut self, rhs: &u8)

Performs the -= operation.

impl SubAssign<&usize> for Integer

fn sub_assign(&mut self, rhs: &usize)

Performs the -= operation.

impl SubAssign<Integer> for Complex

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

impl SubAssign<Integer> for Float

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

impl SubAssign<Integer> for Rational

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

impl SubAssign<i128> for Integer

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl SubAssign<i16> for Integer

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl SubAssign<i32> for Integer

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign<i64> for Integer

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl SubAssign<i8> for Integer

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl SubAssign<isize> for Integer

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl SubAssign<u128> for Integer

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl SubAssign<u16> for Integer

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl SubAssign<u32> for Integer

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl SubAssign<u64> for Integer

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl SubAssign<u8> for Integer

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl SubAssign<usize> for Integer

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl SubAssign for Integer

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

impl SubAssignRound<&Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round( &mut self, rhs: &Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the subtraction.

impl SubAssignRound<&Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering

Performs the subtraction.

impl SubAssignRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round( &mut self, rhs: Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the subtraction.

impl SubAssignRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering

Performs the subtraction.

impl SubFrom<&Integer> for Complex

fn sub_from(&mut self, lhs: &Integer)

Peforms the subtraction.

impl SubFrom<&Integer> for Float

fn sub_from(&mut self, lhs: &Integer)

Peforms the subtraction.

impl SubFrom<&Integer> for Integer

fn sub_from(&mut self, lhs: &Integer)

Peforms the subtraction.

impl SubFrom<&Integer> for Rational

fn sub_from(&mut self, lhs: &Integer)

Peforms the subtraction.

impl SubFrom<&i128> for Integer

fn sub_from(&mut self, lhs: &i128)

Peforms the subtraction.

impl SubFrom<&i16> for Integer

fn sub_from(&mut self, lhs: &i16)

Peforms the subtraction.

impl SubFrom<&i32> for Integer

fn sub_from(&mut self, lhs: &i32)

Peforms the subtraction.

impl SubFrom<&i64> for Integer

fn sub_from(&mut self, lhs: &i64)

Peforms the subtraction.

impl SubFrom<&i8> for Integer

fn sub_from(&mut self, lhs: &i8)

Peforms the subtraction.

impl SubFrom<&isize> for Integer

fn sub_from(&mut self, lhs: &isize)

Peforms the subtraction.

impl SubFrom<&u128> for Integer

fn sub_from(&mut self, lhs: &u128)

Peforms the subtraction.

impl SubFrom<&u16> for Integer

fn sub_from(&mut self, lhs: &u16)

Peforms the subtraction.

impl SubFrom<&u32> for Integer

fn sub_from(&mut self, lhs: &u32)

Peforms the subtraction.

impl SubFrom<&u64> for Integer

fn sub_from(&mut self, lhs: &u64)

Peforms the subtraction.

impl SubFrom<&u8> for Integer

fn sub_from(&mut self, lhs: &u8)

Peforms the subtraction.

impl SubFrom<&usize> for Integer

fn sub_from(&mut self, lhs: &usize)

Peforms the subtraction.

impl SubFrom<Integer> for Complex

fn sub_from(&mut self, lhs: Integer)

Peforms the subtraction.

impl SubFrom<Integer> for Float

fn sub_from(&mut self, lhs: Integer)

Peforms the subtraction.

impl SubFrom<Integer> for Rational

fn sub_from(&mut self, lhs: Integer)

Peforms the subtraction.

impl SubFrom<i128> for Integer

fn sub_from(&mut self, lhs: i128)

Peforms the subtraction.

impl SubFrom<i16> for Integer

fn sub_from(&mut self, lhs: i16)

Peforms the subtraction.

impl SubFrom<i32> for Integer

fn sub_from(&mut self, lhs: i32)

Peforms the subtraction.

impl SubFrom<i64> for Integer

fn sub_from(&mut self, lhs: i64)

Peforms the subtraction.

impl SubFrom<i8> for Integer

fn sub_from(&mut self, lhs: i8)

Peforms the subtraction.

impl SubFrom<isize> for Integer

fn sub_from(&mut self, lhs: isize)

Peforms the subtraction.

impl SubFrom<u128> for Integer

fn sub_from(&mut self, lhs: u128)

Peforms the subtraction.

impl SubFrom<u16> for Integer

fn sub_from(&mut self, lhs: u16)

Peforms the subtraction.

impl SubFrom<u32> for Integer

fn sub_from(&mut self, lhs: u32)

Peforms the subtraction.

impl SubFrom<u64> for Integer

fn sub_from(&mut self, lhs: u64)

Peforms the subtraction.

impl SubFrom<u8> for Integer

fn sub_from(&mut self, lhs: u8)

Peforms the subtraction.

impl SubFrom<usize> for Integer

fn sub_from(&mut self, lhs: usize)

Peforms the subtraction.

impl SubFrom for Integer

fn sub_from(&mut self, lhs: Integer)

Peforms the subtraction.

impl SubFromRound<&Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round( &mut self, lhs: &Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the subtraction.

impl SubFromRound<&Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering

Performs the subtraction.

impl SubFromRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round( &mut self, lhs: Integer, round: (Round, Round) ) -> (Ordering, Ordering)

Performs the subtraction.

impl SubFromRound<Integer> for Float

type Round = Round

The rounding method.

type Ordering = Ordering

The direction from rounding.

fn sub_from_round(&mut self, lhs: Integer, round: Round) -> Ordering

Performs the subtraction.

impl<T> Sum<T> for Integer

where Integer: AddAssign<T>,

fn sum<I>(iter: I) -> Integer

where I: Iterator<Item = T>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl ToPrimitive for Integer

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl TryFrom<&Integer> for i128

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<&Integer> for i16

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<&Integer> for i32

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<&Integer> for i64

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<&Integer> for i8

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<&Integer> for isize

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<&Integer> for u128

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<&Integer> for u16

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<&Integer> for u32

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<&Integer> for u64

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<&Integer> for u8

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<&Integer> for usize

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for i128

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for i16

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for i32

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for i64

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for i8

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for isize

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for u128

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for u16

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for u32

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for u64

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for u8

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl TryFrom<Integer> for usize

type Error = TryFromIntegerError

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

Performs the conversion.

impl UnwrappedCast<Integer> for &Float

fn unwrapped_cast(self) -> Integer

Casts the value.

impl UnwrappedCast<Integer> for Float

fn unwrapped_cast(self) -> Integer

Casts the value.

impl UnwrappedCast<Integer> for Round<f32>

fn unwrapped_cast(self) -> Integer

Casts the value.

impl UnwrappedCast<Integer> for Round<f64>

fn unwrapped_cast(self) -> Integer

Casts the value.

impl UnwrappedCast<Integer> for f32

fn unwrapped_cast(self) -> Integer

Casts the value.

impl UnwrappedCast<Integer> for f64

fn unwrapped_cast(self) -> Integer

Casts the value.

impl UnwrappedCast<i128> for &Integer

fn unwrapped_cast(self) -> i128

Casts the value.

impl UnwrappedCast<i128> for Integer

fn unwrapped_cast(self) -> i128

Casts the value.

impl UnwrappedCast<i16> for &Integer

fn unwrapped_cast(self) -> i16

Casts the value.

impl UnwrappedCast<i16> for Integer

fn unwrapped_cast(self) -> i16

Casts the value.

impl UnwrappedCast<i32> for &Integer

fn unwrapped_cast(self) -> i32

Casts the value.

impl UnwrappedCast<i32> for Integer

fn unwrapped_cast(self) -> i32

Casts the value.

impl UnwrappedCast<i64> for &Integer

fn unwrapped_cast(self) -> i64

Casts the value.

impl UnwrappedCast<i64> for Integer

fn unwrapped_cast(self) -> i64

Casts the value.

impl UnwrappedCast<i8> for &Integer

fn unwrapped_cast(self) -> i8

Casts the value.

impl UnwrappedCast<i8> for Integer

fn unwrapped_cast(self) -> i8

Casts the value.

impl UnwrappedCast<isize> for &Integer

fn unwrapped_cast(self) -> isize

Casts the value.

impl UnwrappedCast<isize> for Integer

fn unwrapped_cast(self) -> isize

Casts the value.

impl UnwrappedCast<u128> for &Integer

fn unwrapped_cast(self) -> u128

Casts the value.

impl UnwrappedCast<u128> for Integer

fn unwrapped_cast(self) -> u128

Casts the value.

impl UnwrappedCast<u16> for &Integer

fn unwrapped_cast(self) -> u16

Casts the value.

impl UnwrappedCast<u16> for Integer

fn unwrapped_cast(self) -> u16

Casts the value.

impl UnwrappedCast<u32> for &Integer

fn unwrapped_cast(self) -> u32

Casts the value.

impl UnwrappedCast<u32> for Integer

fn unwrapped_cast(self) -> u32

Casts the value.

impl UnwrappedCast<u64> for &Integer

fn unwrapped_cast(self) -> u64

Casts the value.

impl UnwrappedCast<u64> for Integer

fn unwrapped_cast(self) -> u64

Casts the value.

impl UnwrappedCast<u8> for &Integer

fn unwrapped_cast(self) -> u8

Casts the value.

impl UnwrappedCast<u8> for Integer

fn unwrapped_cast(self) -> u8

Casts the value.

impl UnwrappedCast<usize> for &Integer

fn unwrapped_cast(self) -> usize

Casts the value.

impl UnwrappedCast<usize> for Integer

fn unwrapped_cast(self) -> usize

Casts the value.

impl UpperExp for Integer

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl UpperHex for Integer

fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult

Formats the value using the given formatter.

impl WrappingCast<i128> for &Integer

fn wrapping_cast(self) -> i128

Casts the value.

impl WrappingCast<i128> for Integer

fn wrapping_cast(self) -> i128

Casts the value.

impl WrappingCast<i16> for &Integer

fn wrapping_cast(self) -> i16

Casts the value.

impl WrappingCast<i16> for Integer

fn wrapping_cast(self) -> i16

Casts the value.

impl WrappingCast<i32> for &Integer

fn wrapping_cast(self) -> i32

Casts the value.

impl WrappingCast<i32> for Integer

fn wrapping_cast(self) -> i32

Casts the value.

impl WrappingCast<i64> for &Integer

fn wrapping_cast(self) -> i64

Casts the value.

impl WrappingCast<i64> for Integer

fn wrapping_cast(self) -> i64

Casts the value.

impl WrappingCast<i8> for &Integer

fn wrapping_cast(self) -> i8

Casts the value.

impl WrappingCast<i8> for Integer

fn wrapping_cast(self) -> i8

Casts the value.

impl WrappingCast<isize> for &Integer

fn wrapping_cast(self) -> isize

Casts the value.

impl WrappingCast<isize> for Integer

fn wrapping_cast(self) -> isize

Casts the value.

impl WrappingCast<u128> for &Integer

fn wrapping_cast(self) -> u128

Casts the value.

impl WrappingCast<u128> for Integer

fn wrapping_cast(self) -> u128

Casts the value.

impl WrappingCast<u16> for &Integer

fn wrapping_cast(self) -> u16

Casts the value.

impl WrappingCast<u16> for Integer

fn wrapping_cast(self) -> u16

Casts the value.

impl WrappingCast<u32> for &Integer

fn wrapping_cast(self) -> u32

Casts the value.

impl WrappingCast<u32> for Integer

fn wrapping_cast(self) -> u32

Casts the value.

impl WrappingCast<u64> for &Integer

fn wrapping_cast(self) -> u64

Casts the value.

impl WrappingCast<u64> for Integer

fn wrapping_cast(self) -> u64

Casts the value.

impl WrappingCast<u8> for &Integer

fn wrapping_cast(self) -> u8

Casts the value.

impl WrappingCast<u8> for Integer

fn wrapping_cast(self) -> u8

Casts the value.

impl WrappingCast<usize> for &Integer

fn wrapping_cast(self) -> usize

Casts the value.

impl WrappingCast<usize> for Integer

fn wrapping_cast(self) -> usize

Casts the value.

impl Zero for Integer

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Eq for Integer

impl Send for Integer

impl Sync for Integer