Struct rug::Integer

pub struct Integer { /* fields omitted */ }

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

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

Methods

impl Integer

pub fn new() -> Self

Constructs a new arbitrary-precision Integer with value 0.

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 from_f32(val: f32) -> Option<Self>

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

Examples

use rug::Integer;
use std::f32;
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(val: f64) -> Option<Self>

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

Examples

use rug::Integer;
use std::f64;
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_digits<T: UnsignedPrimitive>(digits: &[T], order: Order) -> Self

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

The resulting value cannot be negative.

Examples

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

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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the unwrapped returned incomplete-computation value as 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::Integer;

let valid1 = Integer::parse("1223");
let i1 = Integer::from(valid1.unwrap());
assert_eq!(i1, 1223);
let valid2 = Integer::parse("123 456 789");
let i2 = Integer::from(valid2.unwrap());
assert_eq!(i2, 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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the unwrapped returned incomplete-computation value as 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.

Panics

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

Examples

use rug::Integer;

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

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

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

Converts to an i8 if the value fits.

If the compiler supports TryFrom, this conversion can also be performed using i8::try_from(&integer) or i8::try_from(integer).

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.

If the compiler supports TryFrom, this conversion can also be performed using i16::try_from(&integer) or i16::try_from(integer).

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.

If the compiler supports TryFrom, this conversion can also be performed using i32::try_from(&integer) or i32::try_from(integer).

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.

If the compiler supports TryFrom, this conversion can also be performed using i64::try_from(&integer) or i64::try_from(integer).

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 method is only present if the compiler supports the i128 primitive.

If the compiler supports TryFrom, this conversion can also be performed using i128::try_from(&integer) or i128::try_from(integer).

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.

If the compiler supports TryFrom, this conversion can also be performed using isize::try_from(&integer) or isize::try_from(integer).

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 a u8 if the value fits.

If the compiler supports TryFrom, this conversion can also be performed using u8::try_from(&integer) or u8::try_from(integer).

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 a u16 if the value fits.

If the compiler supports TryFrom, this conversion can also be performed using u16::try_from(&integer) or u16::try_from(integer).

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 a u32 if the value fits.

If the compiler supports TryFrom, this conversion can also be performed using u32::try_from(&integer) or u32::try_from(integer).

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 a u64 if the value fits.

If the compiler supports TryFrom, this conversion can also be performed using u64::try_from(&integer) or u64::try_from(integer).

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 a u128 if the value fits.

This method is only present if the compiler supports the u128 primitive.

If the compiler supports TryFrom, this conversion can also be performed using u128::try_from(&integer) or u128::try_from(integer).

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 a usize if the value fits.

If the compiler supports TryFrom, this conversion can also be performed using usize::try_from(&integer) or usize::try_from(integer).

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.

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.

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.

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.

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 method is only present if the compiler supports the i128 primitive.

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.

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.

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.

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.

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.

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 method is only present if the compiler supports the u128 primitive.

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.

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.

Examples

use rug::Integer;
use std::f32;
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.

Examples

use rug::Integer;
use std::f64;

// 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_digits<T: UnsignedPrimitive>(&self, order: Order) -> Vec<T>

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

Examples

use rug::Integer;
use rug::integer::Order;
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()]);

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;
use std::f32;
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 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 of the unsigned integer primitive types.

The resulting value cannot be negative.

Examples

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

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 of the unsigned integer primitive types.

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

The contents of the slice can be uninitialized before this method is called; this method sets all the elements of the slice, padding with zeros if the slice is larger than required.

Panics

Panics if the slice does not have sufficient capacity.

Examples

use rug::Integer;
use rug::integer::Order;
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()]);

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

use rug::Integer;
use rug::integer::Order;
use std::slice;
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);
// The dst slice points to allocated but uninitialized memory.
// All the digits will be initialized by write_digits.
unsafe {
    let ptr = digits.as_mut_ptr();
    let dst = slice::from_raw_parts_mut(ptr, len);
    i.write_digits(dst, Order::MsfBe);
    digits.set_len(len);
}

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

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

Creates an Integer from an initialized GMP integer.

Safety

• The value must be initialized.
• The gmp_mpfr_sys::gmp::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

extern crate gmp_mpfr_sys;
extern crate rug;
use gmp_mpfr_sys::gmp;
use rug::Integer;
use std::mem;
fn main() {
    let i = unsafe {
        let mut z = mem::uninitialized();
        gmp::mpz_init_set_ui(&mut z, 15);
        // z is initialized and unique
        Integer::from_raw(z)
    };
    assert_eq!(i, 15);
    // since i is an Integer now, deallocation is automatic
}

pub fn into_raw(self) -> mpz_t

Converts an Integer into a GMP integer.

The returned object should be freed to avoid memory leaks.

Examples

extern crate gmp_mpfr_sys;
extern crate rug;
use gmp_mpfr_sys::gmp;
use rug::Integer;
fn main() {
    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 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

extern crate gmp_mpfr_sys;
extern crate rug;
use gmp_mpfr_sys::gmp;
use rug::Integer;
fn main() {
    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

extern crate gmp_mpfr_sys;
extern crate rug;
use gmp_mpfr_sys::gmp;
use rug::Integer;
fn main() {
    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 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 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 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 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 fn cmp0(&self) -> Ordering

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

Examples

use rug::Integer;
use std::cmp::Ordering;
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 rug::Integer;
use std::cmp::Ordering;
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 significant_digits<T>(&self) -> usize where
    T: UnsignedPrimitive, 

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

T can be any of the unsigned integer primitive types.

Examples

use rug::Integer;

let i: Integer = Integer::from(1) << 256;
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 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.

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.

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

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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<'a, 'b, Min, Max>(self, min: &'a Min, max: &'b Max) -> Self where
    Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b 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<'a, 'b, Min, Max>(&mut self, min: &'a Min, max: &'b Max) where
    Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'b 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<'a, Min, Max>(
    &'a self,
    min: &'a Min,
    max: &'a Max
) -> ClampIncomplete<'a, Min, Max> where
    Self: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>, 

Clamps the value within the specified bounds.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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.

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.

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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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 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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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 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.

Assign<Src> for (Integer, Integer), Assign<Src> for (&mut Integer, &mut Integer) and From<Src> for (Integer, Integer) are implemented with the returned incomplete-computation value as Src.

The remainder has the same sign as the dividend.

Examples

use rug::Integer;
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let r = dividend.div_rem_ref(&divisor);
let (quotient, rem) = <(Integer, Integer)>::from(r);
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.

Assign<Src> for (Integer, Integer), Assign<Src> for (&mut Integer, &mut Integer) and From<Src> for (Integer, Integer) are implemented with the returned incomplete-computation value as Src.

Examples

use rug::Integer;
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let r = dividend.div_rem_ceil_ref(&divisor);
let (quotient, rem) = <(Integer, Integer)>::from(r);
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.

Assign<Src> for (Integer, Integer), Assign<Src> for (&mut Integer, &mut Integer) and From<Src> for (Integer, Integer) are implemented with the returned incomplete-computation value as Src.

Examples

use rug::Integer;
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let r = dividend.div_rem_floor_ref(&divisor);
let (quotient, rem) = <(Integer, Integer)>::from(r);
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.

Assign<Src> for (Integer, Integer), Assign<Src> for (&mut Integer, &mut Integer) and From<Src> for (Integer, Integer) are implemented with the returned incomplete-computation value as Src.

Examples

use rug::Integer;
// -28 / -10 -> 3 rem 2
let dividend = Integer::from(-28);
let divisor = Integer::from(-10);
let r = dividend.div_rem_round_ref(&divisor);
let (quotient, rem) = <(Integer, Integer)>::from(r);
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.

Assign<Src> for (Integer, Integer), Assign<Src> for (&mut Integer, &mut Integer) and From<Src> for (Integer, Integer) are implemented with the returned incomplete-computation value as Src.

Examples

use rug::Integer;
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let r = dividend.div_rem_euc_ref(&divisor);
let (quotient, rem) = <(Integer, Integer)>::from(r);
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_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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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 x such that 2 * x = 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 x such that 2 * x = 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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the unwrapped returned incomplete-computation value as 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 x such that 2 * x = 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 x such that 2 * x =  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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the unwrapped returned incomplete-computation value as 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 x such that 2 * x =  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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as Src.

Examples

use rug::Integer;
let p = Integer::u_pow_u(13, 12);
let i = Integer::from(p);
assert_eq!(i, 13_u64.pow(12));

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

Raises base to the power of exponent.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as Src.

Examples

use rug::Integer;
let p1 = Integer::i_pow_u(-13, 13);
let i1 = Integer::from(p1);
assert_eq!(i1, (-13_i64).pow(13));
let p2 = Integer::i_pow_u(13, 13);
let i2 = Integer::from(p2);
assert_eq!(i2, (13_i64).pow(13));

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

Computes the nth root and truncates the result.

Panics

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

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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 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 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.

Assign<Src> for (Integer, Integer), Assign<Src> for (&mut Integer, &mut Integer) and From<Src> for (Integer, Integer) are implemented with the returned incomplete-computation value as Src.

Examples

use rug::{Assign, Integer};
let i = Integer::from(1004);
let mut root = Integer::new();
let mut rem = Integer::new();
let r = i.root_rem_ref(3);
(&mut root, &mut rem).assign(r);
assert_eq!(root, 10);
assert_eq!(rem, 4);
let r = i.root_rem_ref(3);
let (other_root, other_rem) = <(Integer, Integer)>::from(r);
assert_eq!(other_root, 10);
assert_eq!(other_rem, 4);

pub fn square(self) -> Self

Computes the square.

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.

Examples

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

pub fn square_ref(&self) -> SquareIncomplete

Computes the square.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as Src.

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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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.

Assign<Src> for (Integer, Integer), Assign<Src> for (&mut Integer, &mut Integer) and From<Src> for (Integer, Integer) are implemented with the returned incomplete-computation value as 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 using some trial divisions, then reps Miller-Rabin probabilistic primality tests.

Examples

use rug::Integer;
use rug::integer::IsPrime;
let no = Integer::from(163 * 4003);
assert_eq!(no.is_probably_prime(15), IsPrime::No);
let yes = Integer::from(21_751);
assert_eq!(yes.is_probably_prime(15), IsPrime::Yes);
// 817_504_243 is actually a prime.
let probably = Integer::from(817_504_243);
assert_eq!(probably.is_probably_prime(15), 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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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 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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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_cofactors(self, other: Self, rop: Self) -> (Self, Self, Self)

Finds the greatest common divisor (GCD) of the two inputs (self and other), and two cofactors 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 cofactors 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::Integer;
let a = Integer::from(4);
let b = Integer::from(6);
let (g, s, t) = a.gcd_cofactors(b, Integer::new());
assert_eq!(g, 2);
assert_eq!(s, -1);
assert_eq!(t, 1);

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

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

The GCD is stored in self, and the two cofactors 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 cofactors 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::Integer;
let mut a_g = Integer::from(4);
let mut b_s = Integer::from(6);
let mut t = Integer::new();
a_g.gcd_cofactors_mut(&mut b_s, &mut t);
assert_eq!(a_g, 2);
assert_eq!(b_s, -1);
assert_eq!(t, 1);

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

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

Assign<Src> for (Integer, Integer, Integer), Assign<Src> for (&mut Integer, &mut Integer, &mut Integer) and From<Src> for (Integer, Integer, Integer) are implemented with the returned incomplete-computation value as Src.

In the case that only one of the two cofactors is required, Assign<Src> for (Integer, Integer), Assign<Src> for (&mut Integer, &mut Integer) and From<Src> for (Integer, Integer) are also implemented with the returned incomplete-computation value as Src.

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 cofactors 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.gcd_cofactors_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 cofactors 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.gcd_cofactors_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.gcd_cofactors_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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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 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.

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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as Src.

Examples

use rug::Integer;
// 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
let f = Integer::factorial(10);
let i = Integer::from(f);
assert_eq!(i, 3628800);

pub fn factorial_2(n: u32) -> Factorial2Incomplete

Computes the double factorial of n.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as Src.

Examples

use rug::Integer;
// 10 * 8 * 6 * 4 * 2
let f = Integer::factorial_2(10);
let i = Integer::from(f);
assert_eq!(i, 3840);

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

Computes the m-multi factorial of n.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as Src.

Examples

use rug::Integer;
// 10 * 7 * 4 * 1
let f = Integer::factorial_m(10, 3);
let i = Integer::from(f);
assert_eq!(i, 280);

pub fn primorial(n: u32) -> PrimorialIncomplete

Computes the primorial of n.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as Src.

Examples

use rug::Integer;
// 7 * 5 * 3 * 2
let p = Integer::primorial(10);
let i = Integer::from(p);
assert_eq!(i, 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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as Src.

Examples

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

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

Computes the binomial coefficient n over k.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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::Integer;
let f = Integer::fibonacci(12);
let i = Integer::from(f);
assert_eq!(i, 144);

pub fn fibonacci_2(n: u32) -> FibonacciIncomplete

Computes a Fibonacci number, and the previous Fibonacci number.

Assign<Src> for (Integer, Integer), Assign<Src> for (&mut Integer, &mut Integer) and From<Src> for (Integer, Integer) are implemented with the returned incomplete-computation value as 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.

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as 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::Integer;
let l = Integer::lucas(12);
let i = Integer::from(l);
assert_eq!(i, 322);

pub fn lucas_2(n: u32) -> LucasIncomplete

Computes a Lucas number, and the previous Lucas number.

Assign<Src> for (Integer, Integer), Assign<Src> for (&mut Integer, &mut Integer) and From<Src> for (Integer, Integer) are implemented with the returned incomplete-computation value as 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<'a, 'b: 'a>(
    bits: u32,
    rng: &'a mut RandState<'b>
) -> RandomBitsIncomplete<'a, 'b>

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

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as Src.

Examples

use rug::{Assign, Integer};
use rug::rand::RandState;
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 RandState) -> 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::Integer;
use rug::rand::RandState;
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 RandState)

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::Integer;
use rug::rand::RandState;
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, 'b: 'a>(
    &'a self,
    rng: &'a mut RandState<'b>
) -> RandomBelowIncomplete<'a, 'b>

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

Assign<Src> for Integer and From<Src> for Integer are implemented with the returned incomplete-computation value as Src.

Panics

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

Examples

use rug::Integer;
use rug::rand::RandState;
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);

Trait Implementations

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> 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 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<&'a 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 Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> Add<&'a Integer> 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 AddAssign<Integer> for Integer

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

impl<'a> AddAssign<&'a Integer> for Integer

fn add_assign(&mut self, rhs: &Integer)

Performs the += operation.

impl AddFrom<Integer> for Integer

fn add_from(&mut self, lhs: Integer)

Peforms the addition.

impl<'a> AddFrom<&'a Integer> for Integer

fn add_from(&mut self, lhs: &Integer)

Peforms the addition.

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<&'a 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 Integer

type Output = Integer

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub<&'a Integer> 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 SubAssign<Integer> for Integer

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

impl<'a> SubAssign<&'a Integer> for Integer

fn sub_assign(&mut self, rhs: &Integer)

Performs the -= operation.

impl SubFrom<Integer> for Integer

fn sub_from(&mut self, lhs: Integer)

Peforms the subtraction.

impl<'a> SubFrom<&'a Integer> for Integer

fn sub_from(&mut self, lhs: &Integer)

Peforms the subtraction.

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<&'a 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 Integer

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul<&'a Integer> 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 MulAssign<Integer> for Integer

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

impl<'a> MulAssign<&'a Integer> for Integer

fn mul_assign(&mut self, rhs: &Integer)

Performs the *= operation.

impl MulFrom<Integer> for Integer

fn mul_from(&mut self, lhs: Integer)

Peforms the multiplication.

impl<'a> MulFrom<&'a Integer> for Integer

fn mul_from(&mut self, lhs: &Integer)

Peforms the multiplication.

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<&'a 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 Integer

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> Div<&'a Integer> 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 DivAssign<Integer> for Integer

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

impl<'a> DivAssign<&'a Integer> for Integer

fn div_assign(&mut self, rhs: &Integer)

Performs the /= operation.

impl DivFrom<Integer> for Integer

fn div_from(&mut self, lhs: Integer)

Peforms the division.

impl<'a> DivFrom<&'a Integer> for Integer

fn div_from(&mut self, lhs: &Integer)

Peforms the division.

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<'a> Rem<&'a Integer> for Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'a> Rem<Integer> for &'a Integer

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'a> Rem<&'a Integer> 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 RemAssign<Integer> for Integer

fn rem_assign(&mut self, rhs: Integer)

Performs the %= operation.

impl<'a> RemAssign<&'a Integer> 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<'a> RemFrom<&'a Integer> for Integer

fn rem_from(&mut self, lhs: &Integer)

Peforms the remainder 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<'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 BitAnd<Integer> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a> BitAnd<&'a Integer> for Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a> BitAnd<Integer> for &'a Integer

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a> BitAnd<&'a Integer> 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 BitAndAssign<Integer> for Integer

fn bitand_assign(&mut self, rhs: Integer)

Performs the &= operation.

impl<'a> BitAndAssign<&'a Integer> 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<'a> BitAndFrom<&'a Integer> for Integer

fn bitand_from(&mut self, lhs: &Integer)

Peforms the AND 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<'a> BitOr<&'a Integer> for Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a> BitOr<Integer> for &'a Integer

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a> BitOr<&'a Integer> 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 BitOrAssign<Integer> for Integer

fn bitor_assign(&mut self, rhs: Integer)

Performs the |= operation.

impl<'a> BitOrAssign<&'a Integer> 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<'a> BitOrFrom<&'a Integer> for Integer

fn bitor_from(&mut self, lhs: &Integer)

Peforms the OR 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<'a> BitXor<&'a Integer> for Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a> BitXor<Integer> for &'a Integer

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a> BitXor<&'a Integer> 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 BitXorAssign<Integer> for Integer

fn bitxor_assign(&mut self, rhs: Integer)

Performs the ^= operation.

impl<'a> BitXorAssign<&'a Integer> 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<'a> BitXorFrom<&'a Integer> for Integer

fn bitxor_from(&mut self, lhs: &Integer)

Peforms the XOR 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<'t> Add<&'t 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<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<'t, 'b> Add<&'t 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 AddAssign<i32> for Integer

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<'t> AddAssign<&'t i32> for Integer

fn add_assign(&mut self, rhs: &i32)

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<'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<'t> Add<Integer> for &'t i32

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddI32Incomplete<'b>

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddFrom<i32> for Integer

fn add_from(&mut self, lhs: i32)

Peforms the addition.

impl<'t> AddFrom<&'t i32> for Integer

fn add_from(&mut self, lhs: &i32)

Peforms the addition.

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<'t> Sub<&'t 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<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<'t, 'b> Sub<&'t 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 SubAssign<i32> for Integer

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<'t> SubAssign<&'t i32> for Integer

fn sub_assign(&mut self, rhs: &i32)

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<'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<'t> Sub<Integer> for &'t i32

type Output = Integer

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b, 't> Sub<&'b Integer> for &'t i32

type Output = SubFromI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromI32Incomplete<'b>

Performs the - operation.

impl SubFrom<i32> for Integer

fn sub_from(&mut self, lhs: i32)

Peforms the subtraction.

impl<'t> SubFrom<&'t i32> for Integer

fn sub_from(&mut self, lhs: &i32)

Peforms the subtraction.

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<'t> Mul<&'t 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<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<'t, 'b> Mul<&'t 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 MulAssign<i32> for Integer

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<'t> MulAssign<&'t i32> for Integer

fn mul_assign(&mut self, rhs: &i32)

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<'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<'t> Mul<Integer> for &'t i32

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, 't> Mul<&'b Integer> for &'t i32

type Output = MulI32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulI32Incomplete

Performs the * operation.

impl MulFrom<i32> for Integer

fn mul_from(&mut self, lhs: i32)

Peforms the multiplication.

impl<'t> MulFrom<&'t i32> for Integer

fn mul_from(&mut self, lhs: &i32)

Peforms the multiplication.

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<'t> Div<&'t 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<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<'t, 'b> Div<&'t 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 DivAssign<i32> for Integer

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<'t> DivAssign<&'t i32> for Integer

fn div_assign(&mut self, rhs: &i32)

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<'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<'t> Div<Integer> for &'t i32

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b, 't> Div<&'b Integer> for &'t i32

type Output = DivFromI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromI32Incomplete<'b>

Performs the / operation.

impl DivFrom<i32> for Integer

fn div_from(&mut self, lhs: i32)

Peforms the division.

impl<'t> DivFrom<&'t i32> for Integer

fn div_from(&mut self, lhs: &i32)

Peforms the division.

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<'t> Rem<&'t 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<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<'t, 'b> Rem<&'t 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 RemAssign<i32> for Integer

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl<'t> RemAssign<&'t i32> for Integer

fn rem_assign(&mut self, rhs: &i32)

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<'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<'t> Rem<Integer> for &'t i32

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b, 't> Rem<&'b Integer> for &'t i32

type Output = RemFromI32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromI32Incomplete<'b>

Performs the % operation.

impl RemFrom<i32> for Integer

fn rem_from(&mut self, lhs: i32)

Peforms the remainder operation.

impl<'t> RemFrom<&'t i32> for Integer

fn rem_from(&mut self, lhs: &i32)

Peforms the remainder 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<'t> Shl<&'t 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<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<'t, 'b> Shl<&'t 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 ShlAssign<i32> for Integer

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl<'t> ShlAssign<&'t i32> for Integer

fn shl_assign(&mut self, rhs: &i32)

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<'t> Shr<&'t 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<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<'t, 'b> Shr<&'t 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 ShrAssign<i32> for Integer

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl<'t> ShrAssign<&'t i32> for Integer

fn shr_assign(&mut self, rhs: &i32)

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<'t> BitAnd<&'t 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<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<'t, 'b> BitAnd<&'t 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 BitAndAssign<i32> for Integer

fn bitand_assign(&mut self, rhs: i32)

Performs the &= operation.

impl<'t> BitAndAssign<&'t i32> for Integer

fn bitand_assign(&mut self, rhs: &i32)

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<'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<'t> BitAnd<Integer> for &'t i32

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b, 't> BitAnd<&'b Integer> for &'t i32

type Output = BitAndI32Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndI32Incomplete

Performs the & operation.

impl BitAndFrom<i32> for Integer

fn bitand_from(&mut self, lhs: i32)

Peforms the AND operation.

impl<'t> BitAndFrom<&'t i32> for Integer

fn bitand_from(&mut self, lhs: &i32)

Peforms the AND 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<'t> BitOr<&'t 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<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<'t, 'b> BitOr<&'t 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 BitOrAssign<i32> for Integer

fn bitor_assign(&mut self, rhs: i32)

Performs the |= operation.

impl<'t> BitOrAssign<&'t i32> for Integer

fn bitor_assign(&mut self, rhs: &i32)

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<'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<'t> BitOr<Integer> for &'t i32

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b, 't> BitOr<&'b Integer> for &'t i32

type Output = BitOrI32Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrI32Incomplete

Performs the | operation.

impl BitOrFrom<i32> for Integer

fn bitor_from(&mut self, lhs: i32)

Peforms the OR operation.

impl<'t> BitOrFrom<&'t i32> for Integer

fn bitor_from(&mut self, lhs: &i32)

Peforms the OR 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<'t> BitXor<&'t 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<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<'t, 'b> BitXor<&'t 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 BitXorAssign<i32> for Integer

fn bitxor_assign(&mut self, rhs: i32)

Performs the ^= operation.

impl<'t> BitXorAssign<&'t i32> for Integer

fn bitxor_assign(&mut self, rhs: &i32)

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<'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<'t> BitXor<Integer> for &'t i32

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b, 't> BitXor<&'b Integer> for &'t i32

type Output = BitXorI32Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorI32Incomplete

Performs the ^ operation.

impl BitXorFrom<i32> for Integer

fn bitxor_from(&mut self, lhs: i32)

Peforms the XOR operation.

impl<'t> BitXorFrom<&'t i32> for Integer

fn bitxor_from(&mut self, lhs: &i32)

Peforms the XOR 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<'t> Add<&'t 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<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<'t, 'b> Add<&'t 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 AddAssign<u32> for Integer

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<'t> AddAssign<&'t u32> for Integer

fn add_assign(&mut self, rhs: &u32)

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<'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<'t> Add<Integer> for &'t u32

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddU32Incomplete<'b>

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddFrom<u32> for Integer

fn add_from(&mut self, lhs: u32)

Peforms the addition.

impl<'t> AddFrom<&'t u32> for Integer

fn add_from(&mut self, lhs: &u32)

Peforms the addition.

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<'t> Sub<&'t 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<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<'t, 'b> Sub<&'t 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 SubAssign<u32> for Integer

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<'t> SubAssign<&'t u32> for Integer

fn sub_assign(&mut self, rhs: &u32)

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<'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<'t> Sub<Integer> for &'t u32

type Output = Integer

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'b, 't> Sub<&'b Integer> for &'t u32

type Output = SubFromU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Integer) -> SubFromU32Incomplete<'b>

Performs the - operation.

impl SubFrom<u32> for Integer

fn sub_from(&mut self, lhs: u32)

Peforms the subtraction.

impl<'t> SubFrom<&'t u32> for Integer

fn sub_from(&mut self, lhs: &u32)

Peforms the subtraction.

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<'t> Mul<&'t 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<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<'t, 'b> Mul<&'t 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 MulAssign<u32> for Integer

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<'t> MulAssign<&'t u32> for Integer

fn mul_assign(&mut self, rhs: &u32)

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<'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<'t> Mul<Integer> for &'t u32

type Output = Integer

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'b, 't> Mul<&'b Integer> for &'t u32

type Output = MulU32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &Integer) -> MulU32Incomplete

Performs the * operation.

impl MulFrom<u32> for Integer

fn mul_from(&mut self, lhs: u32)

Peforms the multiplication.

impl<'t> MulFrom<&'t u32> for Integer

fn mul_from(&mut self, lhs: &u32)

Peforms the multiplication.

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<'t> Div<&'t 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<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<'t, 'b> Div<&'t 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 DivAssign<u32> for Integer

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<'t> DivAssign<&'t u32> for Integer

fn div_assign(&mut self, rhs: &u32)

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<'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<'t> Div<Integer> for &'t u32

type Output = Integer

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'b, 't> Div<&'b Integer> for &'t u32

type Output = DivFromU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Integer) -> DivFromU32Incomplete<'b>

Performs the / operation.

impl DivFrom<u32> for Integer

fn div_from(&mut self, lhs: u32)

Peforms the division.

impl<'t> DivFrom<&'t u32> for Integer

fn div_from(&mut self, lhs: &u32)

Peforms the division.

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<'t> Rem<&'t 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<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<'t, 'b> Rem<&'t 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 RemAssign<u32> for Integer

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl<'t> RemAssign<&'t u32> for Integer

fn rem_assign(&mut self, rhs: &u32)

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<'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<'t> Rem<Integer> for &'t u32

type Output = Integer

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'b, 't> Rem<&'b Integer> for &'t u32

type Output = RemFromU32Incomplete<'b>

The resulting type after applying the % operator.

fn rem(self, rhs: &'b Integer) -> RemFromU32Incomplete<'b>

Performs the % operation.

impl RemFrom<u32> for Integer

fn rem_from(&mut self, lhs: u32)

Peforms the remainder operation.

impl<'t> RemFrom<&'t u32> for Integer

fn rem_from(&mut self, lhs: &u32)

Peforms the remainder 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<'t> Shl<&'t 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<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<'t, 'b> Shl<&'t 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 ShlAssign<u32> for Integer

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<'t> ShlAssign<&'t u32> for Integer

fn shl_assign(&mut self, rhs: &u32)

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<'t> Shr<&'t 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<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<'t, 'b> Shr<&'t 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 ShrAssign<u32> for Integer

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<'t> ShrAssign<&'t u32> for Integer

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl Pow<u32> for Integer

type Output = Integer

The resulting type after the power operation.

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

Performs the power operation.

impl<'t> Pow<&'t u32> for Integer

type Output = Integer

The resulting type after the power operation.

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

Performs the power operation.

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

type Output = PowU32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: u32) -> PowU32Incomplete<'b>

Performs the power operation.

impl<'t, 'b> Pow<&'t u32> for &'b Integer

type Output = PowU32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &u32) -> PowU32Incomplete<'b>

Performs the power operation.

impl PowAssign<u32> for Integer

fn pow_assign(&mut self, rhs: u32)

Peforms the power operation.

impl<'t> PowAssign<&'t u32> for Integer

fn pow_assign(&mut self, rhs: &u32)

Peforms the power 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<'t> BitAnd<&'t 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<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<'t, 'b> BitAnd<&'t 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 BitAndAssign<u32> for Integer

fn bitand_assign(&mut self, rhs: u32)

Performs the &= operation.

impl<'t> BitAndAssign<&'t u32> for Integer

fn bitand_assign(&mut self, rhs: &u32)

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<'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<'t> BitAnd<Integer> for &'t u32

type Output = Integer

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'b, 't> BitAnd<&'b Integer> for &'t u32

type Output = BitAndU32Incomplete<'b>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Integer) -> BitAndU32Incomplete

Performs the & operation.

impl BitAndFrom<u32> for Integer

fn bitand_from(&mut self, lhs: u32)

Peforms the AND operation.

impl<'t> BitAndFrom<&'t u32> for Integer

fn bitand_from(&mut self, lhs: &u32)

Peforms the AND 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<'t> BitOr<&'t 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<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<'t, 'b> BitOr<&'t 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 BitOrAssign<u32> for Integer

fn bitor_assign(&mut self, rhs: u32)

Performs the |= operation.

impl<'t> BitOrAssign<&'t u32> for Integer

fn bitor_assign(&mut self, rhs: &u32)

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<'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<'t> BitOr<Integer> for &'t u32

type Output = Integer

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'b, 't> BitOr<&'b Integer> for &'t u32

type Output = BitOrU32Incomplete<'b>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Integer) -> BitOrU32Incomplete

Performs the | operation.

impl BitOrFrom<u32> for Integer

fn bitor_from(&mut self, lhs: u32)

Peforms the OR operation.

impl<'t> BitOrFrom<&'t u32> for Integer

fn bitor_from(&mut self, lhs: &u32)

Peforms the OR 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<'t> BitXor<&'t 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<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<'t, 'b> BitXor<&'t 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 BitXorAssign<u32> for Integer

fn bitxor_assign(&mut self, rhs: u32)

Performs the ^= operation.

impl<'t> BitXorAssign<&'t u32> for Integer

fn bitxor_assign(&mut self, rhs: &u32)

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<'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<'t> BitXor<Integer> for &'t u32

type Output = Integer

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'b, 't> BitXor<&'b Integer> for &'t u32

type Output = BitXorU32Incomplete<'b>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Integer) -> BitXorU32Incomplete

Performs the ^ operation.

impl BitXorFrom<u32> for Integer

fn bitxor_from(&mut self, lhs: u32)

Peforms the XOR operation.

impl<'t> BitXorFrom<&'t u32> for Integer

fn bitxor_from(&mut self, lhs: &u32)

Peforms the XOR operation.

impl Sum for Integer

fn sum<I>(iter: I) -> Integer where
    I: Iterator<Item = Integer>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a> Sum<&'a Integer> for Integer

fn sum<I>(iter: I) -> Integer where
    I: Iterator<Item = &'a Integer>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl Product for Integer

fn product<I>(iter: I) -> Integer where
    I: Iterator<Item = Integer>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a> Product<&'a Integer> for Integer

fn product<I>(iter: I) -> Integer where
    I: Iterator<Item = &'a Integer>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl Eq for Integer

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

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

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 !=.

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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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 !=.

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 !=.

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<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 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<'i> DivRounding<&'i 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<Integer> for &'i 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 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 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<'i> DivRoundingAssign<&'i 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 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<'i> DivRoundingFrom<&'i 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 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<'i> RemRounding<&'i 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<Integer> for &'i 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 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 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<'i> RemRoundingAssign<&'i 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 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<'i> RemRoundingFrom<&'i 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 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> DivRounding<&'t 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<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<'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 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<'t> DivRoundingAssign<&'t 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 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<'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<'t> DivRounding<Integer> for &'t 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<'i, 't> DivRounding<&'i Integer> for &'t 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 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<'t> DivRoundingFrom<&'t 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 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> RemRounding<&'t 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<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<'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 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<'t> RemRoundingAssign<&'t 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 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<'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<'t> RemRounding<Integer> for &'t 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<'i, 't> RemRounding<&'i Integer> for &'t 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 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<'t> RemRoundingFrom<&'t 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 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> DivRounding<&'t 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<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<'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 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<'t> DivRoundingAssign<&'t 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 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<'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<'t> DivRounding<Integer> for &'t 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<'i, 't> DivRounding<&'i Integer> for &'t 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 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<'t> DivRoundingFrom<&'t 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 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> RemRounding<&'t 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<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<'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 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<'t> RemRoundingAssign<&'t 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 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<'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<'t> RemRounding<Integer> for &'t 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<'i, 't> RemRounding<&'i Integer> for &'t 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 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<'t> RemRoundingFrom<&'t 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 Serialize for Integer

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for Integer

fn deserialize<D>(deserializer: D) -> Result<Integer, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut Integer
) -> Result<(), D::Error> where
    D: Deserializer<'de>, 

impl Default for Integer

fn default() -> Integer

Returns the "default value" for a type.

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 Drop for Integer

fn drop(&mut self)

Executes the destructor for 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, 

Feeds a slice of this type into the given [Hasher].

impl Assign for Integer

fn assign(&mut self, src: Integer)

Peforms the assignement.

impl<'a> Assign<&'a Integer> for Integer

fn assign(&mut self, src: &Integer)

Peforms the assignement.

impl<'a> From<&'a Integer> for Integer

fn from(val: &Integer) -> Self

Performs the conversion.

impl TryFrom<Integer> for i8

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for i8

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl TryFrom<Integer> for i16

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for i16

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl TryFrom<Integer> for i32

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for i32

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl TryFrom<Integer> for i64

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for i64

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl TryFrom<Integer> for isize

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for isize

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl TryFrom<Integer> for i128

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for i128

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl TryFrom<Integer> for u8

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for u8

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl TryFrom<Integer> for u16

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for u16

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl TryFrom<Integer> for u32

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for u32

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl TryFrom<Integer> for u64

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for u64

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl TryFrom<Integer> for usize

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for usize

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl TryFrom<Integer> for u128

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl<'a> TryFrom<&'a Integer> for u128

type Error = TryFromIntegerError

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>

🔬 This is a nightly-only experimental API. (try_from)

Performs the conversion.

impl Assign<i8> for Integer

fn assign(&mut self, src: i8)

Peforms the assignement.

impl From<i8> for Integer

fn from(src: i8) -> Self

Performs the conversion.

impl<'a> Assign<&'a i8> for Integer

fn assign(&mut self, src: &i8)

Peforms the assignement.

impl Assign<i16> for Integer

fn assign(&mut self, src: i16)

Peforms the assignement.

impl From<i16> for Integer

fn from(src: i16) -> Self

Performs the conversion.

impl<'a> Assign<&'a 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 From<i32> for Integer

fn from(src: i32) -> Self

Performs the conversion.

impl<'a> Assign<&'a 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 From<i64> for Integer

fn from(src: i64) -> Self

Performs the conversion.

impl<'a> Assign<&'a i64> for Integer

fn assign(&mut self, src: &i64)

Peforms the assignement.

impl Assign<isize> for Integer

fn assign(&mut self, src: isize)

Peforms the assignement.

impl From<isize> for Integer

fn from(src: isize) -> Self

Performs the conversion.

impl<'a> Assign<&'a isize> for Integer

fn assign(&mut self, src: &isize)

Peforms the assignement.

impl Assign<i128> for Integer

fn assign(&mut self, src: i128)

Peforms the assignement.

impl From<i128> for Integer

fn from(src: i128) -> Self

Performs the conversion.

impl<'a> Assign<&'a i128> for Integer

fn assign(&mut self, src: &i128)

Peforms the assignement.

impl Assign<u8> for Integer

fn assign(&mut self, src: u8)

Peforms the assignement.

impl From<u8> for Integer

fn from(src: u8) -> Self

Performs the conversion.

impl<'a> Assign<&'a u8> for Integer

fn assign(&mut self, src: &u8)

Peforms the assignement.

impl Assign<u16> for Integer

fn assign(&mut self, src: u16)

Peforms the assignement.

impl From<u16> for Integer

fn from(src: u16) -> Self

Performs the conversion.

impl<'a> Assign<&'a 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 From<u32> for Integer

fn from(src: u32) -> Self

Performs the conversion.

impl<'a> Assign<&'a 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 From<u64> for Integer

fn from(src: u64) -> Self

Performs the conversion.

impl<'a> Assign<&'a u64> for Integer

fn assign(&mut self, src: &u64)

Peforms the assignement.

impl Assign<usize> for Integer

fn assign(&mut self, src: usize)

Peforms the assignement.

impl From<usize> for Integer

fn from(src: usize) -> Self

Performs the conversion.

impl<'a> Assign<&'a usize> for Integer

fn assign(&mut self, src: &usize)

Peforms the assignement.

impl Assign<u128> for Integer

fn assign(&mut self, src: u128)

Peforms the assignement.

impl From<u128> for Integer

fn from(src: u128) -> Self

Performs the conversion.

impl<'a> Assign<&'a u128> for Integer

fn assign(&mut self, src: &u128)

Peforms the assignement.

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 Display for Integer

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Debug for Integer

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Binary for Integer

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Octal for Integer

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl LowerHex for Integer

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl UpperHex for Integer

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Send for Integer

impl Sync for Integer

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 !=.

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 !=.

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<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 Add<Integer> for Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Float

The resulting type after applying the + operator.

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

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 AddAssign<Integer> for Float

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

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

fn add_assign(&mut self, rhs: &Integer)

Performs the += operation.

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<'a> AddAssignRound<&'a 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<'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<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<&'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<Float> for &'a Integer

type Output = Float

The resulting type after applying the + operator.

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

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 AddFrom<Integer> for Float

fn add_from(&mut self, lhs: Integer)

Peforms the addition.

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

fn add_from(&mut self, lhs: &Integer)

Peforms 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<'a> AddFromRound<&'a 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 Sub<Integer> for Float

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Float

Performs the - operation.

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

type Output = Float

The resulting type after applying the - operator.

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

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 SubAssign<Integer> for Float

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

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

fn sub_assign(&mut self, rhs: &Integer)

Performs the -= operation.

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<'a> SubAssignRound<&'a 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<'a> Sub<Integer> for &'a Float

type Output = SubFromIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> SubFromIntegerIncomplete<'a>

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<&'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<Float> for &'a Integer

type Output = Float

The resulting type after applying the - operator.

fn sub(self, rhs: Float) -> Float

Performs the - operation.

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

type Output = SubOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Float) -> SubOwnedIntegerIncomplete

Performs the - operation.

impl SubFrom<Integer> for Float

fn sub_from(&mut self, lhs: Integer)

Peforms the subtraction.

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

fn sub_from(&mut self, lhs: &Integer)

Peforms 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<'a> SubFromRound<&'a 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 Mul<Integer> for Float

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> Float

Performs the * operation.

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

type Output = Float

The resulting type after applying the * operator.

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

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 MulAssign<Integer> for Float

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

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

fn mul_assign(&mut self, rhs: &Integer)

Performs the *= operation.

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<'a> MulAssignRound<&'a 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<'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<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<&'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<Float> for &'a Integer

type Output = Float

The resulting type after applying the * operator.

fn mul(self, rhs: Float) -> Float

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 MulFrom<Integer> for Float

fn mul_from(&mut self, lhs: Integer)

Peforms the multiplication.

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

fn mul_from(&mut self, lhs: &Integer)

Peforms 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> MulFromRound<&'a 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 Div<Integer> for Float

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> Float

Performs the / operation.

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

type Output = Float

The resulting type after applying the / operator.

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

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 DivAssign<Integer> for Float

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

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

fn div_assign(&mut self, rhs: &Integer)

Performs the /= operation.

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<'a> DivAssignRound<&'a 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<'a> Div<Integer> for &'a Float

type Output = DivFromIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> DivFromIntegerIncomplete<'a>

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<&'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<Float> for &'a Integer

type Output = Float

The resulting type after applying the / operator.

fn div(self, rhs: Float) -> Float

Performs the / operation.

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

type Output = DivOwnedIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Float) -> DivOwnedIntegerIncomplete

Performs the / operation.

impl DivFrom<Integer> for Float

fn div_from(&mut self, lhs: Integer)

Peforms the division.

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

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<'a> DivFromRound<&'a 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 Pow<Integer> for Float

type Output = Float

The resulting type after the power operation.

fn pow(self, rhs: Integer) -> Float

Performs the power operation.

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

type Output = Float

The resulting type after the power operation.

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

Performs the power operation.

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

type Output = PowIntegerIncomplete<'a>

The resulting type after the power operation.

fn pow(self, rhs: &'a Integer) -> PowIntegerIncomplete

Performs the power operation.

impl PowAssign<Integer> for Float

fn pow_assign(&mut self, rhs: Integer)

Peforms the power operation.

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

fn pow_assign(&mut self, rhs: &Integer)

Peforms 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<'a> PowAssignRound<&'a 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<'a> Pow<Integer> for &'a Float

type Output = PowOwnedIntegerIncomplete<'a>

The resulting type after the power operation.

fn pow(self, rhs: Integer) -> PowOwnedIntegerIncomplete<'a>

Performs the power operation.

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 !=.

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 !=.

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, 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> AssignRound<&'a 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 Pow<Integer> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, rhs: Integer) -> Complex

Performs the power operation.

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

type Output = Complex

The resulting type after the power operation.

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

Performs the power operation.

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

type Output = PowIntegerIncomplete<'a>

The resulting type after the power operation.

fn pow(self, rhs: &'a Integer) -> PowIntegerIncomplete

Performs the power operation.

impl PowAssign<Integer> for Complex

fn pow_assign(&mut self, rhs: Integer)

Peforms the power operation.

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

fn pow_assign(&mut self, rhs: &Integer)

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<'a> PowAssignRound<&'a 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<'a> Pow<Integer> for &'a Complex

type Output = PowOwnedIntegerIncomplete<'a>

The resulting type after the power operation.

fn pow(self, rhs: Integer) -> PowOwnedIntegerIncomplete<'a>

Performs the power 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<'a> Add<&'a Integer> for Complex

type Output = Complex

The resulting type after applying the + operator.

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

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 AddAssign<Integer> for Complex

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

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

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<'a> AddAssignRound<&'a 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<'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 Add<Complex> for Integer

type Output = Complex

The resulting type after applying the + operator.

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

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<Complex> for &'a Integer

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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 AddFrom<Integer> for Complex

fn add_from(&mut self, lhs: Integer)

Peforms the addition.

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

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<'a> AddFromRound<&'a 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 Sub<Integer> for Complex

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> Complex

Performs the - operation.

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

type Output = Complex

The resulting type after applying the - operator.

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

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 SubAssign<Integer> for Complex

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

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

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<'a> SubAssignRound<&'a 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<'a> Sub<Integer> for &'a Complex

type Output = SubFromIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> SubFromIntegerIncomplete<'a>

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<'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<Complex> for &'a Integer

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: Complex) -> Complex

Performs the - operation.

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

type Output = SubOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Complex) -> SubOwnedIntegerIncomplete

Performs the - operation.

impl SubFrom<Integer> for Complex

fn sub_from(&mut self, lhs: Integer)

Peforms the subtraction.

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

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<'a> SubFromRound<&'a 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 Mul<Integer> for Complex

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> Complex

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

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 MulAssign<Integer> for Complex

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

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

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<'a> MulAssignRound<&'a 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<'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 Mul<Complex> for Integer

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: Complex) -> Complex

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<Complex> for &'a Integer

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: Complex) -> Complex

Performs the * operation.

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 MulFrom<Integer> for Complex

fn mul_from(&mut self, lhs: Integer)

Peforms the multiplication.

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

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<'a> MulFromRound<&'a 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 Div<Integer> for Complex

type Output = Complex

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> Complex

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

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 DivAssign<Integer> for Complex

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

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

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<'a> DivAssignRound<&'a 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<'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 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 !=.

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 !=.