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 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 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);
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 intermediate 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 intermediate 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: one that consumes the operand, one that mutates the operand, and one that borrows the operand.

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

fn new() -> Integer

Constructs a new arbitrary-precision integer with value 0.

Examples

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

fn with_capacity(bits: usize) -> Integer

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

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

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);
i.reserve(34);
let capacity = i.capacity();
assert!(capacity >= 64);
i.reserve(34);
assert!(i.capacity() == capacity);
i.reserve(35);
assert!(i.capacity() >= 65);

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!(i.capacity() >= 100);
i >>= 80;
i.shrink_to_fit();
assert!(i.capacity() >= 20);

fn from_f32(val: f32) -> Option<Integer>

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

fn from_f64(val: f64) -> Option<Integer>

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

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

Parses an Integer using the given radix.

Examples

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

Panics

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

fn valid_str_radix(
    src: &str,
    radix: i32
) -> Result<ValidInteger, ParseIntegerError>

Checks if an Integer can be parsed.

If this method does not return an error, neither will any other function that parses an Integer. If this method returns an error, the other functions will return the same error.

The string can start with an optional minus or plus sign. Whitespace is not allowed anywhere in the string, including in the beginning and end.

Examples

use rug::Integer;

let valid1 = Integer::valid_str_radix("1223", 4);
let i1 = Integer::from(valid1.unwrap());
assert_eq!(i1, 3 + 4 * (2 + 4 * (2 + 4 * 1)));
let valid2 = Integer::valid_str_radix("12yz", 36);
let i2 = Integer::from(valid2.unwrap());
assert_eq!(i2, 35 + 36 * (34 + 36 * (2 + 36 * 1)));

let invalid = Integer::valid_str_radix("123", 3);
let invalid_f = Integer::from_str_radix("123", 3);
assert_eq!(invalid.unwrap_err(), invalid_f.unwrap_err());

Panics

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

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

Converts to an i32 if the value fits.

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_u64);
assert_eq!(large.to_i32(), None);

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

Converts to an i64 if the value fits.

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

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

Converts to a u32 if the value fits.

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 = "123456789012345".parse::<Integer>().unwrap();
assert_eq!(large.to_u32(), None);

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

Converts to a u64 if the value fits.

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

fn to_i32_wrapping(&self) -> i32

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

Examples

use rug::Integer;
let fits = Integer::from(-0xabcdef_i32);
assert_eq!(fits.to_i32_wrapping(), -0xabcdef);
let small = Integer::from(0x1_ffff_ffff_u64);
assert_eq!(small.to_i32_wrapping(), -1);
let large = Integer::from_str_radix("1234567890abcdef", 16).unwrap();
assert_eq!(large.to_i32_wrapping(), 0x90abcdef_u32 as i32);

fn to_i64_wrapping(&self) -> i64

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

Examples

use rug::Integer;
let fits = Integer::from(-0xabcdef);
assert_eq!(fits.to_i64_wrapping(), -0xabcdef);
let small = Integer::from_str_radix("1ffffffffffffffff", 16).unwrap();
assert_eq!(small.to_i64_wrapping(), -1);
let large = Integer::from_str_radix("f1234567890abcdef", 16).unwrap();
assert_eq!(large.to_i64_wrapping(), 0x1234567890abcdef_i64);

fn to_u32_wrapping(&self) -> u32

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

Examples

use rug::Integer;
let fits = Integer::from(0x90abcdef_u32);
assert_eq!(fits.to_u32_wrapping(), 0x90abcdef);
let neg = Integer::from(-1);
assert_eq!(neg.to_u32_wrapping(), 0xffffffff);
let large = Integer::from_str_radix("1234567890abcdef", 16).unwrap();
assert_eq!(large.to_u32_wrapping(), 0x90abcdef);

fn to_u64_wrapping(&self) -> u64

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

Examples

use rug::Integer;
let fits = Integer::from(0x90abcdef_u64);
assert_eq!(fits.to_u64_wrapping(), 0x90abcdef);
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(), 0x123456789abcdef0);

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

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

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

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

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

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

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_str_radix("1234567890aAbBcCdDeEfF", 16).unwrap();
assert_eq!(i.to_string_radix(16), "1234567890aabbccddeeff");

Panics

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

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

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

fn assign_str(&mut self, src: &str) -> Result<(), ParseIntegerError>

Parses an Integer from a string in decimal.

Examples

use rug::Integer;
let mut i = Integer::new();
i.assign_str("123").unwrap();
assert_eq!(i, 123);
let ret = i.assign_str("bad");
assert!(ret.is_err());

fn assign_str_radix(
    &mut self,
    src: &str,
    radix: i32
) -> Result<(), ParseIntegerError>

Parses an Integer from a string with the specified radix.

Examples

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

Panics

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

fn as_neg(&self) -> BorrowInteger

Borrows a negated copy of the Integer.

The returned object implements Deref with an Integer target. 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);

fn as_abs(&self) -> BorrowInteger

Borrows an absolute copy of the Integer.

The returned object implements Deref with an Integer target. 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);

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

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

fn is_divisible(&self, divisor: &Integer) -> 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()));

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

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

fn is_congruent(&self, c: &Integer, divisor: &Integer) -> 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)));

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

fn is_congruent_2pow(&self, c: &Integer, 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));

fn is_perfect_power(&self) -> bool

Returns true if the number is a perfect power.

Examples

use rug::{Assign, Integer};
// 0 is 0 to the power of anything
let mut i = Integer::from(0);
assert!(i.is_perfect_power());
// 243 is 3 to the power of 5
i.assign(243);
assert!(i.is_perfect_power());
// 10 is not a perfect power
i.assign(10);
assert!(!i.is_perfect_power());

fn is_perfect_square(&self) -> bool

Returns true if the number is a perfect square.

Examples

use rug::{Assign, Integer};
let mut i = Integer::from(1);
assert!(i.is_perfect_square());
i.assign(9);
assert!(i.is_perfect_square());
i.assign(15);
assert!(!i.is_perfect_square());

fn cmp0(&self) -> Ordering

Returns the same result as self.cmp(&0), 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);

fn cmp_abs(&self, other: &Integer) -> 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);

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);
assert_eq!(Integer::from(-1).significant_bits(), 1);
assert_eq!(Integer::from(4).significant_bits(), 3);
assert_eq!(Integer::from(-4).significant_bits(), 3);
assert_eq!(Integer::from(7).significant_bits(), 3);
assert_eq!(Integer::from(-7).significant_bits(), 3);

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

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

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

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

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

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

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

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

Toggles the bit at location index.

Examples

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

fn hamming_dist(&self, other: &Integer) -> 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));

fn abs(self) -> Integer

Computes the absolute value.

Examples

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

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

fn abs_ref(&self) -> AbsRef

Computes the absolute value.

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

fn clamp<'a, Min, Max>(self, min: &'a Min, max: &'a Max) -> Integer where
    Integer: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>, 

Clamps the value within the specified bounds.

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

Panics

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

fn clamp_mut<'a, Min, Max>(&mut self, min: &'a Min, max: &'a Max) where
    Integer: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>, 

Clamps the value within the specified bounds.

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

Panics

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

fn clamp_ref<'a, Min, Max>(
    &'a self,
    min: &'a Min,
    max: &'a Max
) -> ClampRef<'a, Min, Max> where
    Integer: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>, 

Clamps the value within the specified bounds.

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

Panics

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

fn keep_bits(self, n: u32) -> Integer

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

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

fn keep_bits_ref(&self, n: u32) -> KeepBitsRef

Keeps the n least significant bits only.

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

fn next_power_of_two(self) -> Integer

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

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

fn next_power_of_two_ref(&self) -> NextPowerTwoRef

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

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

fn div_rem(self, divisor: Integer) -> (Integer, Integer)

Performs a division producing both the quotient and remainder.

The remainder has the same sign as the dividend.

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

Panics

Panics if divisor is zero.

fn div_rem_mut(&mut self, divisor: &mut Integer)

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.

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

Panics

Panics if divisor is zero.

fn div_rem_ref<'a>(&'a self, divisor: &'a Integer) -> DivRemRef<'a>

Performs a division producing both the quotient and remainder.

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

fn div_rem_ceil(self, divisor: Integer) -> (Integer, Integer)

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.

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

Panics

Panics if divisor is zero.

fn div_rem_ceil_mut(&mut self, divisor: &mut Integer)

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.

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

Panics

Panics if divisor is zero.

fn div_rem_ceil_ref<'a>(&'a self, divisor: &'a Integer) -> DivRemCeilRef<'a>

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.

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

fn div_rem_floor(self, divisor: Integer) -> (Integer, Integer)

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

The remainder has the same sign as the divisor.

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

Panics

Panics if divisor is zero.

fn div_rem_floor_mut(&mut self, divisor: &mut Integer)

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.

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

Panics

Panics if divisor is zero.

fn div_rem_floor_ref<'a>(&'a self, divisor: &'a Integer) -> DivRemFloorRef<'a>

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

The remainder has the same sign as the divisor.

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

fn div_rem_euc(self, divisor: Integer) -> (Integer, Integer)

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

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

Panics

Panics if divisor is zero.

fn div_rem_euc_mut(&mut self, divisor: &mut Integer)

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.

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

Panics

Panics if divisor is zero.

fn div_rem_euc_ref<'a>(&'a self, divisor: &'a Integer) -> DivRemEucRef<'a>

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

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

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.

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

Panics

Panics if modulo is zero.

fn div_exact(self, divisor: &Integer) -> Integer

Performs an exact division.

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

Examples

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

Panics

Panics if divisor is zero.

fn div_exact_mut(&mut self, divisor: &Integer)

Performs an exact division.

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

Examples

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

Panics

Panics if divisor is zero.

fn div_exact_ref<'a>(&'a self, divisor: &'a Integer) -> DivExactRef<'a>

Performs an exact division.

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

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

fn div_exact_u(self, divisor: u32) -> Integer

Performs an exact division.

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

Examples

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

Panics

Panics if divisor is zero.

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.

Examples

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

Panics

Panics if divisor is zero.

fn div_exact_u_ref(&self, divisor: u32) -> DivExactURef

Performs an exact division.

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

Examples

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

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

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

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

Panics

Panics if modulo is zero.

fn invert_mut(&mut self, modulo: &Integer) -> bool

Finds the inverse modulo modulo and returns true if an inverse exists.

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.
let exists_4 = n.invert_mut(&Integer::from(4));
assert!(!exists_4);
assert_eq!(n, 2);
// Modulo 5, the inverse of 2 is 3, as 2 * 3 = 1.
let exists_5 = n.invert_mut(&Integer::from(5));
assert!(exists_5);
assert_eq!(n, 3);

Panics

Panics if modulo is zero.

fn invert_ref<'a>(&'a self, modulo: &'a Integer) -> InvertRef<'a>

Finds the inverse modulo modulo if an inverse exists.

Examples

use rug::{Assign, Integer};
let n = Integer::from(2);
// 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.
let mut ans = Result::from(n.invert_ref(&Integer::from(4)));
match ans {
    Ok(_) => unreachable!(),
    Err(ref unchanged) => assert_eq!(*unchanged, 0),
}
// Modulo 5, the inverse of 2 is 3, as 2 * 3 = 1.
ans.assign(n.invert_ref(&Integer::from(5)));
match ans {
    Ok(ref inverse) => assert_eq!(*inverse, 3),
    Err(_) => unreachable!(),
};

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

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 exponent is negative, then the number must have an inverse modulo modulo for an answer to exist.

Examples

When the exponent is positive, an answer always exists.

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

fn pow_mod_mut(&mut self, exponent: &Integer, modulo: &Integer) -> bool

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

If exponent is negative, then the number must have an inverse modulo modulo 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);
let exists = n.pow_mod_mut(&e, &m);
assert!(!exists);
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);
let exists = n.pow_mod_mut(&e, &m);
assert!(exists);
assert_eq!(n, 943);

fn pow_mod_ref<'a>(
    &'a self,
    exponent: &'a Integer,
    modulo: &'a Integer
) -> PowModRef<'a>

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

If exponent is negative, then the number must have an inverse modulo modulo 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 two = Integer::from(2);
let e = Integer::from(-5);
let m = Integer::from(1000);
let mut ans = Result::from(two.pow_mod_ref(&e, &m));
match ans {
    Ok(_) => unreachable!(),
    Err(ref unchanged) => assert_eq!(*unchanged, 0),
}
// 7 * 143 modulo 1000 = 1, so 7 has an inverse 143.
// 7 ^ -5 modulo 1000 = 143 ^ 5 modulo 1000 = 943.
let seven = Integer::from(7);
ans.assign(seven.pow_mod_ref(&e, &m));
match ans {
    Ok(ref power) => assert_eq!(*power, 943),
    Err(_) => unreachable!(),
}

fn assign_u_pow_u(&mut self, base: u32, exponent: u32)

Raises base to the power of exponent.

Examples

use rug::Integer;
let mut i = Integer::new();
i.assign_u_pow_u(13, 12);
assert_eq!(i, 13_u64.pow(12));

fn assign_i_pow_u(&mut self, base: i32, exponent: u32)

Raises base to the power of exponent.

Examples

use rug::Integer;
let mut i = Integer::new();
i.assign_i_pow_u(-13, 12);
assert_eq!(i, (-13_i64).pow(12));
i.assign_i_pow_u(-13, 13);
assert_eq!(i, (-13_i64).pow(13));

fn root(self, n: u32) -> Integer

Computes the nth root and truncates the result.

Examples

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

fn root_mut(&mut self, n: u32)

Computes the nth root and truncates the result.

Examples

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

fn root_ref(&self, n: u32) -> RootRef

Computes the nth root and truncates the result.

Examples

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

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

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.

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

fn root_rem_mut(&mut self, remainder: &mut Integer, 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.

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

fn root_rem_ref(&self, n: u32) -> RootRemRef

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.

Examples

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

fn sqrt(self) -> Integer

Computes the square root and truncates the result.

Examples

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

fn sqrt_mut(&mut self)

Computes the square root and truncates the result.

Examples

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

fn sqrt_ref(&self) -> SqrtRef

Computes the square root and truncates the result.

Examples

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

fn sqrt_rem(self, remainder: Integer) -> (Integer, Integer)

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.

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

fn sqrt_rem_mut(&mut self, remainder: &mut Integer)

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.

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

fn sqrt_rem_ref(&self) -> SqrtRemRef

Computes the square root and the remainder.

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

Examples

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

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

fn next_prime(self) -> Integer

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

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

fn next_prime_ref(&self) -> NextPrimeRef

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 r = i.next_prime_ref();
let prime = Integer::from(r);
assert_eq!(prime, 800_000_011);

fn gcd(self, other: &Integer) -> Integer

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

fn gcd_mut(&mut self, other: &Integer)

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

fn gcd_ref<'a>(&'a self, other: &'a Integer) -> GcdRef<'a>

Finds the greatest common divisor.

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

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

fn gcd_coeffs(self, other: Integer, rop: Integer) -> (Integer, Integer, Integer)

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

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

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_coeffs(b, Integer::new());
assert_eq!(g, 2);
assert_eq!(s, -1);
assert_eq!(t, 1);

fn gcd_coeffs_mut(&mut self, other: &mut Integer, rop: &mut Integer)

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

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

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

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_coeffs_mut(&mut b_s, &mut t);
assert_eq!(a_g, 2);
assert_eq!(b_s, -1);
assert_eq!(t, 1);

fn gcd_coeffs_ref<'a>(&'a self, other: &'a Integer) -> GcdCoeffsRef<'a>

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

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

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

fn lcm(self, other: &Integer) -> Integer

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

fn lcm_mut(&mut self, other: &Integer)

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

fn lcm_ref<'a>(&'a self, other: &'a Integer) -> LcmRef<'a>

Finds the least common multiple.

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

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

fn jacobi(&self, n: &Integer) -> 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);

fn legendre(&self, p: &Integer) -> 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);

fn kronecker(&self, n: &Integer) -> 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);

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

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

Examples

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

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

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

Examples

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

fn remove_factor_ref<'a>(&'a self, factor: &'a Integer) -> RemoveFactorRef<'a>

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

Examples

use rug::{Assign, Integer};
let mut i = Integer::new();
i.assign_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);

fn assign_factorial(&mut self, n: u32)

Computes the factorial of n.

Examples

use rug::Integer;
let mut i = Integer::new();
// 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
i.assign_factorial(10);
assert_eq!(i, 3628800);

fn assign_factorial_2(&mut self, n: u32)

Computes the double factorial of n.

Examples

use rug::Integer;
let mut i = Integer::new();
// 10 * 8 * 6 * 4 * 2
i.assign_factorial_2(10);
assert_eq!(i, 3840);

fn assign_factorial_m(&mut self, n: u32, m: u32)

Computes the m-multi factorial of n.

Examples

use rug::Integer;
let mut i = Integer::new();
// 10 * 7 * 4 * 1
i.assign_factorial_m(10, 3);
assert_eq!(i, 280);

fn assign_primorial(&mut self, n: u32)

Computes the primorial of n.

Examples

use rug::Integer;
let mut i = Integer::new();
// 7 * 5 * 3 * 2
i.assign_primorial(10);
assert_eq!(i, 210);

fn binomial(self, k: u32) -> Integer

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

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

fn binomial_ref(&self, k: u32) -> BinomialRef

Computes the binomial coefficient over k.

Examples

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

fn assign_binomial_u(&mut self, n: u32, k: u32)

Computes the binomial coefficient n over k.

Examples

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

fn assign_fibonacci(&mut self, n: u32)

Computes the Fibonacci number.

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 assign_fibonacci_2 method, then iterations should be used.

Examples

use rug::Integer;
let mut i = Integer::new();
i.assign_fibonacci(12);
assert_eq!(i, 144);

fn assign_fibonacci_2(&mut self, previous: &mut Integer, n: u32)

Computes a Fibonacci number, and the previous Fibonacci number.

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::Integer;
let mut i = Integer::new();
let mut j = Integer::new();
i.assign_fibonacci_2(&mut j, 12);
assert_eq!(i, 144);
assert_eq!(j, 89);
// Fibonacci number F[-1] is 1
i.assign_fibonacci_2(&mut j, 0);
assert_eq!(i, 0);
assert_eq!(j, 1);

fn assign_lucas(&mut self, n: u32)

Computes the Lucas number.

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 assign_lucas_2 method, then iterations should be used.

Examples

use rug::Integer;
let mut i = Integer::new();
i.assign_lucas(12);
assert_eq!(i, 322);

fn assign_lucas_2(&mut self, previous: &mut Integer, n: u32)

Computes a Lucas number, and the previous Lucas number.

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::Integer;
let mut i = Integer::new();
let mut j = Integer::new();
i.assign_lucas_2(&mut j, 12);
assert_eq!(i, 322);
assert_eq!(j, 199);
i.assign_lucas_2(&mut j, 0);
assert_eq!(i, 2);
assert_eq!(j, -1);

fn assign_random_bits(&mut self, bits: u32, rng: &mut RandState)

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

Examples

use rug::Integer;
use rug::rand::RandState;
let mut rand = RandState::new();
let mut i = Integer::new();
i.assign_random_bits(0, &mut rand);
assert_eq!(i, 0);
i.assign_random_bits(80, &mut rand);
assert!(i.significant_bits() <= 80);

fn random_below(self, rng: &mut RandState) -> Integer

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

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

Panics

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

fn random_below_mut(&mut self, rng: &mut RandState)

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

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

Panics

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

fn assign_random_below(&mut self, bound: &Integer, rng: &mut RandState)

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

Examples

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

Panics

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

Trait Implementations

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

fn from(t: AbsRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: AbsRef<'a>)

Peforms the assignement.

impl<'a, Min, Max> From<ClampRef<'a, Min, Max>> for Integer where
    Integer: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,
    Min: 'a,
    Max: 'a, 

fn from(t: ClampRef<'a, Min, Max>) -> Integer

Performs the conversion.

impl<'a, Min, Max> Assign<ClampRef<'a, Min, Max>> for Integer where
    Integer: PartialOrd<Min> + PartialOrd<Max> + Assign<&'a Min> + Assign<&'a Max>,
    Min: 'a,
    Max: 'a, 

fn assign(&mut self, src: ClampRef<'a, Min, Max>)

Peforms the assignement.

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

fn from(t: KeepBitsRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: KeepBitsRef<'a>)

Peforms the assignement.

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

fn from(t: NextPowerTwoRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: NextPowerTwoRef<'a>)

Peforms the assignement.

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

fn from(t: DivExactRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivExactRef<'a>)

Peforms the assignement.

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

fn from(t: DivExactURef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivExactURef<'a>)

Peforms the assignement.

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

fn from(t: RootRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RootRef<'a>)

Peforms the assignement.

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

fn from(t: SqrtRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SqrtRef<'a>)

Peforms the assignement.

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

fn from(t: NextPrimeRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: NextPrimeRef<'a>)

Peforms the assignement.

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

fn from(t: GcdRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: GcdRef<'a>)

Peforms the assignement.

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

fn from(t: LcmRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: LcmRef<'a>)

Peforms the assignement.

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

fn from(t: BinomialRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: BinomialRef<'a>)

Peforms the assignement.

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

fn assign(&mut self, rhs: ValidInteger)

Peforms the assignement.

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 = NegRef<'a>

The resulting type after applying the - operator.

fn neg(self) -> NegRef<'a>

Performs the unary - operation.

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

fn from(t: NegRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, rhs: NegRef)

Peforms the assignement.

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

Peforms the addition.

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

type Output = AddRef<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn from(t: AddRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: AddRef)

Peforms the assignement.

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

Peforms the subtraction.

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

type Output = SubRef<'a>

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn from(t: SubRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SubRef)

Peforms the assignement.

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

Peforms the multiplication.

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

type Output = MulRef<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Integer) -> MulRef<'a>

Performs the * operation.

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

fn from(t: MulRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: MulRef)

Peforms the assignement.

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

Peforms the division.

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

type Output = DivRef<'a>

The resulting type after applying the / operator.

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

Performs the / operation.

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

fn from(t: DivRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivRef)

Peforms the assignement.

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

Peforms the remainder operation.

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

type Output = RemRef<'a>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a Integer) -> RemRef<'a>

Performs the % operation.

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

fn from(t: RemRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RemRef)

Peforms the assignement.

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 = NotRef<'a>

The resulting type after applying the ! operator.

fn not(self) -> NotRef<'a>

Performs the unary ! operation.

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

fn from(t: NotRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, rhs: NotRef)

Peforms the assignement.

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

Peforms the AND operation.

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

type Output = BitAndRef<'a>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Integer) -> BitAndRef<'a>

Performs the & operation.

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

fn from(t: BitAndRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: BitAndRef)

Peforms the assignement.

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

Peforms the OR operation.

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

type Output = BitOrRef<'a>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Integer) -> BitOrRef<'a>

Performs the | operation.

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

fn from(t: BitOrRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: BitOrRef)

Peforms the assignement.

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

Peforms the XOR operation.

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

type Output = BitXorRef<'a>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Integer) -> BitXorRef<'a>

Performs the ^ operation.

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

fn from(t: BitXorRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: BitXorRef)

Peforms the assignement.

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

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

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

type Output = AddRefI32<'a>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> AddRefI32<'a>

Performs the + operation.

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

fn from(t: AddRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: AddRefI32)

Peforms the assignement.

impl AddFrom<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 SubAssign<i32> for Integer

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

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

type Output = SubRefI32<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> SubRefI32<'a>

Performs the - operation.

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

fn from(t: SubRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SubRefI32)

Peforms the assignement.

impl SubFrom<i32> for Integer

fn sub_from(&mut self, lhs: i32)

Peforms the subtraction.

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

fn from(t: SubFromRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SubFromRefI32)

Peforms the assignement.

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

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

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

type Output = MulRefI32<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> MulRefI32<'a>

Performs the * operation.

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

fn from(t: MulRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: MulRefI32)

Peforms the assignement.

impl MulFrom<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 DivAssign<i32> for Integer

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

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

type Output = DivRefI32<'a>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> DivRefI32<'a>

Performs the / operation.

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

fn from(t: DivRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivRefI32)

Peforms the assignement.

impl DivFrom<i32> for Integer

fn div_from(&mut self, lhs: i32)

Peforms the division.

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

fn from(t: DivFromRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivFromRefI32)

Peforms the assignement.

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 RemAssign<i32> for Integer

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

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

type Output = RemRefI32<'a>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> RemRefI32<'a>

Performs the % operation.

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

fn from(t: RemRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RemRefI32)

Peforms the assignement.

impl RemFrom<i32> for Integer

fn rem_from(&mut self, lhs: i32)

Peforms the remainder operation.

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

fn from(t: RemFromRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RemFromRefI32)

Peforms the assignement.

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 ShlAssign<i32> for Integer

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

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

type Output = ShlRefI32<'a>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> ShlRefI32<'a>

Performs the << operation.

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

fn from(t: ShlRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: ShlRefI32)

Peforms the assignement.

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 ShrAssign<i32> for Integer

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

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

type Output = ShrRefI32<'a>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> ShrRefI32<'a>

Performs the >> operation.

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

fn from(t: ShrRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: ShrRefI32)

Peforms the assignement.

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 BitAndAssign<i32> for Integer

fn bitand_assign(&mut self, rhs: i32)

Performs the &= operation.

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

type Output = BitAndRefI32<'a>

The resulting type after applying the & operator.

fn bitand(self, rhs: i32) -> BitAndRefI32<'a>

Performs the & operation.

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

fn from(t: BitAndRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: BitAndRefI32)

Peforms the assignement.

impl BitAndFrom<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 BitOrAssign<i32> for Integer

fn bitor_assign(&mut self, rhs: i32)

Performs the |= operation.

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

type Output = BitOrRefI32<'a>

The resulting type after applying the | operator.

fn bitor(self, rhs: i32) -> BitOrRefI32<'a>

Performs the | operation.

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

fn from(t: BitOrRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: BitOrRefI32)

Peforms the assignement.

impl BitOrFrom<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 BitXorAssign<i32> for Integer

fn bitxor_assign(&mut self, rhs: i32)

Performs the ^= operation.

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

type Output = BitXorRefI32<'a>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i32) -> BitXorRefI32<'a>

Performs the ^ operation.

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

fn from(t: BitXorRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: BitXorRefI32)

Peforms the assignement.

impl BitXorFrom<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 AddAssign<u32> for Integer

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

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

type Output = AddRefU32<'a>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> AddRefU32<'a>

Performs the + operation.

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

fn from(t: AddRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: AddRefU32)

Peforms the assignement.

impl AddFrom<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 SubAssign<u32> for Integer

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

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

type Output = SubRefU32<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> SubRefU32<'a>

Performs the - operation.

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

fn from(t: SubRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SubRefU32)

Peforms the assignement.

impl SubFrom<u32> for Integer

fn sub_from(&mut self, lhs: u32)

Peforms the subtraction.

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

fn from(t: SubFromRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SubFromRefU32)

Peforms the assignement.

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

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

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

type Output = MulRefU32<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> MulRefU32<'a>

Performs the * operation.

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

fn from(t: MulRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: MulRefU32)

Peforms the assignement.

impl MulFrom<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 DivAssign<u32> for Integer

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

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

type Output = DivRefU32<'a>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> DivRefU32<'a>

Performs the / operation.

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

fn from(t: DivRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivRefU32)

Peforms the assignement.

impl DivFrom<u32> for Integer

fn div_from(&mut self, lhs: u32)

Peforms the division.

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

fn from(t: DivFromRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivFromRefU32)

Peforms the assignement.

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 RemAssign<u32> for Integer

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

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

type Output = RemRefU32<'a>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> RemRefU32<'a>

Performs the % operation.

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

fn from(t: RemRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RemRefU32)

Peforms the assignement.

impl RemFrom<u32> for Integer

fn rem_from(&mut self, lhs: u32)

Peforms the remainder operation.

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

fn from(t: RemFromRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RemFromRefU32)

Peforms the assignement.

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 ShlAssign<u32> for Integer

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

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

type Output = ShlRefU32<'a>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> ShlRefU32<'a>

Performs the << operation.

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

fn from(t: ShlRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: ShlRefU32)

Peforms the assignement.

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 ShrAssign<u32> for Integer

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

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

type Output = ShrRefU32<'a>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> ShrRefU32<'a>

Performs the >> operation.

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

fn from(t: ShrRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: ShrRefU32)

Peforms the assignement.

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 PowAssign<u32> for Integer

fn pow_assign(&mut self, rhs: u32)

Peforms the power operation.

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

type Output = PowRefU32<'a>

The resulting type after the power operation.

fn pow(self, rhs: u32) -> PowRefU32<'a>

Performs the power operation.

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

fn from(t: PowRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: PowRefU32)

Peforms the assignement.

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 BitAndAssign<u32> for Integer

fn bitand_assign(&mut self, rhs: u32)

Performs the &= operation.

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

type Output = BitAndRefU32<'a>

The resulting type after applying the & operator.

fn bitand(self, rhs: u32) -> BitAndRefU32<'a>

Performs the & operation.

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

fn from(t: BitAndRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: BitAndRefU32)

Peforms the assignement.

impl BitAndFrom<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 BitOrAssign<u32> for Integer

fn bitor_assign(&mut self, rhs: u32)

Performs the |= operation.

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

type Output = BitOrRefU32<'a>

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> BitOrRefU32<'a>

Performs the | operation.

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

fn from(t: BitOrRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: BitOrRefU32)

Peforms the assignement.

impl BitOrFrom<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 BitXorAssign<u32> for Integer

fn bitxor_assign(&mut self, rhs: u32)

Performs the ^= operation.

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

type Output = BitXorRefU32<'a>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u32) -> BitXorRefU32<'a>

Performs the ^ operation.

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

fn from(t: BitXorRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: BitXorRefU32)

Peforms the assignement.

impl BitXorFrom<u32> for Integer

fn bitxor_from(&mut self, lhs: u32)

Peforms the XOR operation.

impl<'a> Add<MulRef<'a>> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, rhs: MulRef)

Performs the += operation.

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

type Output = AddMulRef<'a>

The resulting type after applying the + operator.

fn add(self, rhs: MulRef<'a>) -> AddMulRef<'a>

Performs the + operation.

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

fn from(t: AddMulRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: AddMulRef)

Peforms the assignement.

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

fn add_from(&mut self, lhs: MulRef)

Peforms the addition.

impl<'a> Add<MulRefU32<'a>> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, rhs: MulRefU32)

Performs the += operation.

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

type Output = AddMulRefU32<'a>

The resulting type after applying the + operator.

fn add(self, rhs: MulRefU32<'a>) -> AddMulRefU32<'a>

Performs the + operation.

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

fn from(t: AddMulRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: AddMulRefU32)

Peforms the assignement.

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

fn add_from(&mut self, lhs: MulRefU32)

Peforms the addition.

impl<'a> Add<MulRefI32<'a>> for Integer

type Output = Integer

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, rhs: MulRefI32)

Performs the += operation.

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

type Output = AddMulRefI32<'a>

The resulting type after applying the + operator.

fn add(self, rhs: MulRefI32<'a>) -> AddMulRefI32<'a>

Performs the + operation.

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

fn from(t: AddMulRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: AddMulRefI32)

Peforms the assignement.

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

fn add_from(&mut self, lhs: MulRefI32)

Peforms the addition.

impl<'a> Sub<MulRef<'a>> for Integer

type Output = Integer

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: MulRef)

Performs the -= operation.

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

type Output = SubMulRef<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: MulRef<'a>) -> SubMulRef<'a>

Performs the - operation.

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

fn from(t: SubMulRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SubMulRef)

Peforms the assignement.

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

fn sub_from(&mut self, lhs: MulRef)

Peforms the subtraction.

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

fn from(t: SubMulRefFrom<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SubMulRefFrom)

Peforms the assignement.

impl<'a> Sub<MulRefU32<'a>> for Integer

type Output = Integer

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: MulRefU32)

Performs the -= operation.

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

type Output = SubMulRefU32<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: MulRefU32<'a>) -> SubMulRefU32<'a>

Performs the - operation.

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

fn from(t: SubMulRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SubMulRefU32)

Peforms the assignement.

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

fn sub_from(&mut self, lhs: MulRefU32)

Peforms the subtraction.

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

fn from(t: SubMulRefFromU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SubMulRefFromU32)

Peforms the assignement.

impl<'a> Sub<MulRefI32<'a>> for Integer

type Output = Integer

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: MulRefI32)

Performs the -= operation.

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

type Output = SubMulRefI32<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: MulRefI32<'a>) -> SubMulRefI32<'a>

Performs the - operation.

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

fn from(t: SubMulRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SubMulRefI32)

Peforms the assignement.

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

fn sub_from(&mut self, lhs: MulRefI32)

Peforms the subtraction.

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

fn from(t: SubMulRefFromI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: SubMulRefFromI32)

Peforms the assignement.

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

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

Performs Euclidean division, rounding the quotient so that the remainder cannot be negative.

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

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

Performs Euclidean division, rounding the quotient so that the remainder cannot be negative.

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

type Output = Integer

The resulting type from the division operation.

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

Performs division, rounding the quotient towards zero.

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

Performs division, rounding the quotient up.

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

Performs division, rounding the quotient down.

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

Performs Euclidean division, rounding the quotient so that the remainder cannot be negative.

impl DivRoundingAssign<Integer> for Integer

fn div_trunc_assign(&mut self, rhs: Integer)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: Integer)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: Integer)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: Integer)

Performs Euclidean division, rounding the quotient so that the remainder cannot be negative.

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

fn div_trunc_assign(&mut self, rhs: &'a Integer)

Performs division, rounding the quotient towards zero.

fn div_ceil_assign(&mut self, rhs: &'a Integer)

Performs division, rounding the quotient up.

fn div_floor_assign(&mut self, rhs: &'a Integer)

Performs division, rounding the quotient down.

fn div_euc_assign(&mut self, rhs: &'a Integer)

Performs Euclidean division, rounding the quotient so that the remainder cannot be negative.

impl DivRoundingFrom<Integer> for Integer

fn div_trunc_from(&mut self, lhs: Integer)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: Integer)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: Integer)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: Integer)

Performs Euclidean division, rounding the quotient so that the remainder cannot be negative.

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

fn div_trunc_from(&mut self, lhs: &'a Integer)

Performs division, rounding the quotient towards zero.

fn div_ceil_from(&mut self, lhs: &'a Integer)

Performs division, rounding the quotient up.

fn div_floor_from(&mut self, lhs: &'a Integer)

Performs division, rounding the quotient down.

fn div_euc_from(&mut self, lhs: &'a Integer)

Performs Euclidean division, rounding the quotient so that the remainder cannot be negative.

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

type Output = DivRoundingRef<'a>

The resulting type from the division operation.

fn div_trunc(self, rhs: &'a Integer) -> DivRoundingRef

Performs division, rounding the quotient towards zero.

fn div_ceil(self, rhs: &'a Integer) -> DivRoundingRef

Performs division, rounding the quotient up.

fn div_floor(self, rhs: &'a Integer) -> DivRoundingRef

Performs division, rounding the quotient down.

fn div_euc(self, rhs: &'a Integer) -> DivRoundingRef

Performs Euclidean division, rounding the quotient so that the remainder cannot be negative.

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

fn from(t: DivRoundingRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivRoundingRef)

Peforms the assignement.

impl RemRounding<Integer> for Integer

type Output = Integer

The resulting type from the remainder operation.

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

Finds the remainder when the quotient is rounded towards zero.

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

Finds the remainder when the quotient is rounded up.

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

Finds the remainder when the quotient is rounded down.

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

Finds the positive remainder from Euclidean division.

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

type Output = Integer

The resulting type from the remainder operation.

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

Finds the remainder when the quotient is rounded towards zero.

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

Finds the remainder when the quotient is rounded up.

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

Finds the remainder when the quotient is rounded down.

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

Finds the positive remainder from Euclidean division.

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

type Output = Integer

The resulting type from the remainder operation.

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

Finds the remainder when the quotient is rounded towards zero.

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

Finds the remainder when the quotient is rounded up.

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

Finds the remainder when the quotient is rounded down.

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

Finds the positive remainder from Euclidean division.

impl RemRoundingAssign<Integer> for Integer

fn rem_trunc_assign(&mut self, rhs: Integer)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: Integer)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: Integer)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: Integer)

Finds the positive remainder from Euclidean division.

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

fn rem_trunc_assign(&mut self, rhs: &'a Integer)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_assign(&mut self, rhs: &'a Integer)

Finds the remainder when the quotient is rounded up.

fn rem_floor_assign(&mut self, rhs: &'a Integer)

Finds the remainder when the quotient is rounded down.

fn rem_euc_assign(&mut self, rhs: &'a Integer)

Finds the positive remainder from Euclidean division.

impl RemRoundingFrom<Integer> for Integer

fn rem_trunc_from(&mut self, lhs: Integer)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: Integer)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: Integer)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: Integer)

Finds the positive remainder from Euclidean division.

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

fn rem_trunc_from(&mut self, lhs: &'a Integer)

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil_from(&mut self, lhs: &'a Integer)

Finds the remainder when the quotient is rounded up.

fn rem_floor_from(&mut self, lhs: &'a Integer)

Finds the remainder when the quotient is rounded down.

fn rem_euc_from(&mut self, lhs: &'a Integer)

Finds the positive remainder from Euclidean division.

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

type Output = RemRoundingRef<'a>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: &'a Integer) -> RemRoundingRef

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: &'a Integer) -> RemRoundingRef

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: &'a Integer) -> RemRoundingRef

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: &'a Integer) -> RemRoundingRef

Finds the positive remainder from Euclidean division.

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

fn from(t: RemRoundingRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RemRoundingRef)

Peforms the assignement.

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

type Output = DivRoundingRefI32<'a>

The resulting type from the division operation.

fn div_trunc(self, rhs: i32) -> DivRoundingRefI32<'a>

Performs division, rounding the quotient towards zero.

fn div_ceil(self, rhs: i32) -> DivRoundingRefI32<'a>

Performs division, rounding the quotient up.

fn div_floor(self, rhs: i32) -> DivRoundingRefI32<'a>

Performs division, rounding the quotient down.

fn div_euc(self, rhs: i32) -> DivRoundingRefI32<'a>

Performs Euclidean division, rounding the quotient so that the remainder cannot be negative.

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

fn from(t: DivRoundingRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivRoundingRefI32)

Peforms the assignement.

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<'a> From<DivRoundingFromRefI32<'a>> for Integer

fn from(t: DivRoundingFromRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivRoundingFromRefI32)

Peforms the assignement.

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

type Output = RemRoundingRefI32<'a>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: i32) -> RemRoundingRefI32<'a>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: i32) -> RemRoundingRefI32<'a>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: i32) -> RemRoundingRefI32<'a>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: i32) -> RemRoundingRefI32<'a>

Finds the positive remainder from Euclidean division.

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

fn from(t: RemRoundingRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RemRoundingRefI32)

Peforms the assignement.

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<'a> From<RemRoundingFromRefI32<'a>> for Integer

fn from(t: RemRoundingFromRefI32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RemRoundingFromRefI32)

Peforms the assignement.

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

type Output = DivRoundingRefU32<'a>

The resulting type from the division operation.

fn div_trunc(self, rhs: u32) -> DivRoundingRefU32<'a>

Performs division, rounding the quotient towards zero.

fn div_ceil(self, rhs: u32) -> DivRoundingRefU32<'a>

Performs division, rounding the quotient up.

fn div_floor(self, rhs: u32) -> DivRoundingRefU32<'a>

Performs division, rounding the quotient down.

fn div_euc(self, rhs: u32) -> DivRoundingRefU32<'a>

Performs Euclidean division, rounding the quotient so that the remainder cannot be negative.

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

fn from(t: DivRoundingRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivRoundingRefU32)

Peforms the assignement.

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<'a> From<DivRoundingFromRefU32<'a>> for Integer

fn from(t: DivRoundingFromRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: DivRoundingFromRefU32)

Peforms the assignement.

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

type Output = RemRoundingRefU32<'a>

The resulting type from the remainder operation.

fn rem_trunc(self, rhs: u32) -> RemRoundingRefU32<'a>

Finds the remainder when the quotient is rounded towards zero.

fn rem_ceil(self, rhs: u32) -> RemRoundingRefU32<'a>

Finds the remainder when the quotient is rounded up.

fn rem_floor(self, rhs: u32) -> RemRoundingRefU32<'a>

Finds the remainder when the quotient is rounded down.

fn rem_euc(self, rhs: u32) -> RemRoundingRefU32<'a>

Finds the positive remainder from Euclidean division.

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

fn from(t: RemRoundingRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RemRoundingRefU32)

Peforms the assignement.

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<'a> From<RemRoundingFromRefU32<'a>> for Integer

fn from(t: RemRoundingFromRefU32<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RemRoundingFromRefU32)

Peforms the assignement.

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

fn from(val: &Integer) -> Integer

Performs the conversion.

impl From<i32> for Integer

fn from(val: i32) -> Integer

Performs the conversion.

impl From<i64> for Integer

fn from(val: i64) -> Integer

Performs the conversion.

impl From<u32> for Integer

fn from(val: u32) -> Integer

Performs the conversion.

impl From<u64> for Integer

fn from(val: u64) -> Integer

Performs the conversion.

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

fn assign(&mut self, other: Integer)

Peforms the assignement.

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

fn assign(&mut self, other: &'a Integer)

Peforms the assignement.

impl Assign<i32> for Integer

fn assign(&mut self, val: i32)

Peforms the assignement.

impl Assign<i64> for Integer

fn assign(&mut self, val: i64)

Peforms the assignement.

impl Assign<u32> for Integer

fn assign(&mut self, val: u32)

Peforms the assignement.

impl Assign<u64> for Integer

fn assign(&mut self, val: u64)

Peforms the assignement.

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

fn assign(&mut self, r: &'a i32)

Peforms the assignement.

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

fn assign(&mut self, r: &'a i64)

Peforms the assignement.

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

fn assign(&mut self, r: &'a u32)

Peforms the assignement.

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

fn assign(&mut self, r: &'a u64)

Peforms the assignement.

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

fn from(t: ValidInteger<'a>) -> Integer

Performs the conversion.

impl Send for Integer

impl Sync for Integer

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

fn from(t: CeilRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: CeilRef<'a>)

Peforms the assignement.

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

fn from(t: FloorRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: FloorRef<'a>)

Peforms the assignement.

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

fn from(t: RoundRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: RoundRef<'a>)

Peforms the assignement.

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

fn from(t: TruncRef<'a>) -> Integer

Performs the conversion.

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

fn assign(&mut self, src: TruncRef<'a>)

Peforms the assignement.

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

type Output = AddRefIntegerOwn<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddRefInteger<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Float) -> AddRefInteger<'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<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 Integer

type Output = SubFromRefIntegerOwn<'a>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubRefIntegerOwn<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Float) -> SubRefIntegerOwn<'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<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 Integer

type Output = MulRefIntegerOwn<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Float) -> MulRefIntegerOwn<'a>

Performs the * operation.

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

type Output = MulRefInteger<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Float) -> MulRefInteger<'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<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 Integer

type Output = DivFromRefIntegerOwn<'a>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivRefIntegerOwn<'a>

The resulting type after applying the / operator.

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

Performs the / operation.

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