Struct rug::Integer
[−]
[src]
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 functions 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
[src]
fn new() -> Integer
[src]
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
[src]
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
[src]
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)
[src]
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)
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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)
[src]
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)
[src]
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
[src]
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<(), ()>
[src]
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<(), ()>
[src]
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>
[src]
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>
[src]
&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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
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
[src]
Returns true
if the number is divisible by 2b.
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
[src]
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
[src]
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
[src]
Returns true
if the number is congruent to c mod
2b, that is, if there exists a q such that
self
= c + q × 2b.
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
[src]
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
[src]
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 sign(&self) -> Ordering
[src]
Returns the same result as self.cmp(&0)
, but is faster.
Examples
use rug::Integer; use std::cmp::Ordering; assert_eq!(Integer::from(-5).sign(), Ordering::Less); assert_eq!(Integer::from(0).sign(), Ordering::Equal); assert_eq!(Integer::from(5).sign(), Ordering::Greater);
fn cmp_abs(&self, other: &Integer) -> Ordering
[src]
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
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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
[src]
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
[src]
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
[src]
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>
[src]
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
[src]
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)
[src]
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
[src]
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 keep_bits(self, n: u32) -> Integer
[src]
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)
[src]
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
[src]
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
[src]
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)
[src]
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
[src]
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)
[src]
Performs a division producing both the quotient and remainder.
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)
[src]
Performs a division producing both the quotient and 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_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>
[src]
Performs a division producing both the quotient and remainder.
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_exact(self, divisor: &Integer) -> Integer
[src]
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)
[src]
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>
[src]
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
[src]
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)
[src]
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
[src]
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>
[src]
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
[src]
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>
[src]
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>
[src]
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
[src]
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>
[src]
&'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)
[src]
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)
[src]
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
[src]
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)
[src]
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
[src]
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)
[src]
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)
[src]
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
[src]
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
[src]
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)
[src]
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
[src]
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)
[src]
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)
[src]
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
[src]
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
[src]
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
[src]
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)
[src]
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
[src]
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
[src]
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)
[src]
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>
[src]
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)
[src]
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)
[src]
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>
[src]
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
[src]
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)
[src]
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>
[src]
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
[src]
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
[src]
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
[src]
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)
[src]
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
[src]
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>
[src]
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)
[src]
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)
[src]
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)
[src]
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)
[src]
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
[src]
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)
[src]
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
[src]
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)
[src]
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)
[src]
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)
[src]
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)
[src]
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)
[src]
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)
[src]
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
[src]
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)
[src]
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)
[src]
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 Default for Integer
[src]
impl Clone for Integer
[src]
fn clone(&self) -> Integer
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Integer)
[src]
Performs copy-assignment from source
. Read more
impl Drop for Integer
[src]
impl Hash for Integer
[src]
fn hash<H: Hasher>(&self, state: &mut H)
[src]
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<'a> From<&'a Integer> for Integer
[src]
impl From<i32> for Integer
[src]
impl From<i64> for Integer
[src]
impl From<u32> for Integer
[src]
impl From<u64> for Integer
[src]
impl FromStr for Integer
[src]
type Err = ParseIntegerError
The associated error which can be returned from parsing.
fn from_str(src: &str) -> Result<Integer, ParseIntegerError>
[src]
Parses a string s
to return a value of this type. Read more
impl Display for Integer
[src]
fn fmt(&self, f: &mut Formatter) -> Result
[src]
Formats the value using the given formatter. Read more
impl Debug for Integer
[src]
impl Binary for Integer
[src]
impl Octal for Integer
[src]
impl LowerHex for Integer
[src]
impl UpperHex for Integer
[src]
impl Assign for Integer
[src]
impl<'a> Assign<&'a Integer> for Integer
[src]
impl Assign<i32> for Integer
[src]
impl Assign<i64> for Integer
[src]
impl Assign<u32> for Integer
[src]
impl Assign<u64> for Integer
[src]
impl<'a> From<AbsRef<'a>> for Integer
[src]
impl<'a> Assign<AbsRef<'a>> for Integer
[src]
impl<'a> From<KeepBitsRef<'a>> for Integer
[src]
impl<'a> Assign<KeepBitsRef<'a>> for Integer
[src]
impl<'a> From<NextPowerTwoRef<'a>> for Integer
[src]
impl<'a> Assign<NextPowerTwoRef<'a>> for Integer
[src]
impl<'a> From<DivExactRef<'a>> for Integer
[src]
impl<'a> Assign<DivExactRef<'a>> for Integer
[src]
impl<'a> From<DivExactURef<'a>> for Integer
[src]
impl<'a> Assign<DivExactURef<'a>> for Integer
[src]
impl<'a> From<RootRef<'a>> for Integer
[src]
impl<'a> Assign<RootRef<'a>> for Integer
[src]
impl<'a> From<SqrtRef<'a>> for Integer
[src]
impl<'a> Assign<SqrtRef<'a>> for Integer
[src]
impl<'a> From<NextPrimeRef<'a>> for Integer
[src]
impl<'a> Assign<NextPrimeRef<'a>> for Integer
[src]
impl<'a> From<GcdRef<'a>> for Integer
[src]
impl<'a> Assign<GcdRef<'a>> for Integer
[src]
impl<'a> From<LcmRef<'a>> for Integer
[src]
impl<'a> Assign<LcmRef<'a>> for Integer
[src]
impl<'a> From<BinomialRef<'a>> for Integer
[src]
impl<'a> Assign<BinomialRef<'a>> for Integer
[src]
impl Neg for Integer
[src]
type Output = Integer
The resulting type after applying the -
operator.
fn neg(self) -> Integer
[src]
Performs the unary -
operation.
impl NegAssign for Integer
[src]
fn neg_assign(&mut self)
[src]
Peforms the negation. Read more
impl<'a> Neg for &'a Integer
[src]
type Output = NegRef<'a>
The resulting type after applying the -
operator.
fn neg(self) -> NegRef<'a>
[src]
Performs the unary -
operation.
impl<'a> From<NegRef<'a>> for Integer
[src]
impl<'a> Assign<NegRef<'a>> for Integer
[src]
impl Add<Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> Integer
[src]
Performs the +
operation.
impl<'a> Add<&'a Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Integer) -> Integer
[src]
Performs the +
operation.
impl<'a> Add<Integer> for &'a Integer
[src]
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> Integer
[src]
Performs the +
operation.
impl AddAssign<Integer> for Integer
[src]
fn add_assign(&mut self, rhs: Integer)
[src]
Performs the +=
operation.
impl<'a> AddAssign<&'a Integer> for Integer
[src]
fn add_assign(&mut self, rhs: &'a Integer)
[src]
Performs the +=
operation.
impl AddFrom<Integer> for Integer
[src]
impl<'a> AddFrom<&'a Integer> for Integer
[src]
impl<'a> Add<&'a Integer> for &'a Integer
[src]
type Output = AddRef<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Integer) -> AddRef<'a>
[src]
Performs the +
operation.
impl<'a> From<AddRef<'a>> for Integer
[src]
impl<'a> Assign<AddRef<'a>> for Integer
[src]
impl Sub<Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> Integer
[src]
Performs the -
operation.
impl<'a> Sub<&'a Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Integer) -> Integer
[src]
Performs the -
operation.
impl<'a> Sub<Integer> for &'a Integer
[src]
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> Integer
[src]
Performs the -
operation.
impl SubAssign<Integer> for Integer
[src]
fn sub_assign(&mut self, rhs: Integer)
[src]
Performs the -=
operation.
impl<'a> SubAssign<&'a Integer> for Integer
[src]
fn sub_assign(&mut self, rhs: &'a Integer)
[src]
Performs the -=
operation.
impl SubFrom<Integer> for Integer
[src]
impl<'a> SubFrom<&'a Integer> for Integer
[src]
impl<'a> Sub<&'a Integer> for &'a Integer
[src]
type Output = SubRef<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Integer) -> SubRef<'a>
[src]
Performs the -
operation.
impl<'a> From<SubRef<'a>> for Integer
[src]
impl<'a> Assign<SubRef<'a>> for Integer
[src]
impl Mul<Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> Integer
[src]
Performs the *
operation.
impl<'a> Mul<&'a Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Integer) -> Integer
[src]
Performs the *
operation.
impl<'a> Mul<Integer> for &'a Integer
[src]
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> Integer
[src]
Performs the *
operation.
impl MulAssign<Integer> for Integer
[src]
fn mul_assign(&mut self, rhs: Integer)
[src]
Performs the *=
operation.
impl<'a> MulAssign<&'a Integer> for Integer
[src]
fn mul_assign(&mut self, rhs: &'a Integer)
[src]
Performs the *=
operation.
impl MulFrom<Integer> for Integer
[src]
impl<'a> MulFrom<&'a Integer> for Integer
[src]
impl<'a> Mul<&'a Integer> for &'a Integer
[src]
type Output = MulRef<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Integer) -> MulRef<'a>
[src]
Performs the *
operation.
impl<'a> From<MulRef<'a>> for Integer
[src]
impl<'a> Assign<MulRef<'a>> for Integer
[src]
impl Div<Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> Integer
[src]
Performs the /
operation.
impl<'a> Div<&'a Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Integer) -> Integer
[src]
Performs the /
operation.
impl<'a> Div<Integer> for &'a Integer
[src]
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> Integer
[src]
Performs the /
operation.
impl DivAssign<Integer> for Integer
[src]
fn div_assign(&mut self, rhs: Integer)
[src]
Performs the /=
operation.
impl<'a> DivAssign<&'a Integer> for Integer
[src]
fn div_assign(&mut self, rhs: &'a Integer)
[src]
Performs the /=
operation.
impl DivFrom<Integer> for Integer
[src]
impl<'a> DivFrom<&'a Integer> for Integer
[src]
impl<'a> Div<&'a Integer> for &'a Integer
[src]
type Output = DivRef<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Integer) -> DivRef<'a>
[src]
Performs the /
operation.
impl<'a> From<DivRef<'a>> for Integer
[src]
impl<'a> Assign<DivRef<'a>> for Integer
[src]
impl Rem<Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: Integer) -> Integer
[src]
Performs the %
operation.
impl<'a> Rem<&'a Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: &'a Integer) -> Integer
[src]
Performs the %
operation.
impl<'a> Rem<Integer> for &'a Integer
[src]
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: Integer) -> Integer
[src]
Performs the %
operation.
impl RemAssign<Integer> for Integer
[src]
fn rem_assign(&mut self, rhs: Integer)
[src]
Performs the %=
operation.
impl<'a> RemAssign<&'a Integer> for Integer
[src]
fn rem_assign(&mut self, rhs: &'a Integer)
[src]
Performs the %=
operation.
impl RemFrom<Integer> for Integer
[src]
impl<'a> RemFrom<&'a Integer> for Integer
[src]
impl<'a> Rem<&'a Integer> for &'a Integer
[src]
type Output = RemRef<'a>
The resulting type after applying the %
operator.
fn rem(self, rhs: &'a Integer) -> RemRef<'a>
[src]
Performs the %
operation.
impl<'a> From<RemRef<'a>> for Integer
[src]
impl<'a> Assign<RemRef<'a>> for Integer
[src]
impl Not for Integer
[src]
type Output = Integer
The resulting type after applying the !
operator.
fn not(self) -> Integer
[src]
Performs the unary !
operation.
impl NotAssign for Integer
[src]
fn not_assign(&mut self)
[src]
Peforms the complement. Read more
impl<'a> Not for &'a Integer
[src]
type Output = NotRef<'a>
The resulting type after applying the !
operator.
fn not(self) -> NotRef<'a>
[src]
Performs the unary !
operation.
impl<'a> From<NotRef<'a>> for Integer
[src]
impl<'a> Assign<NotRef<'a>> for Integer
[src]
impl BitAnd<Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: Integer) -> Integer
[src]
Performs the &
operation.
impl<'a> BitAnd<&'a Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: &'a Integer) -> Integer
[src]
Performs the &
operation.
impl<'a> BitAnd<Integer> for &'a Integer
[src]
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: Integer) -> Integer
[src]
Performs the &
operation.
impl BitAndAssign<Integer> for Integer
[src]
fn bitand_assign(&mut self, rhs: Integer)
[src]
Performs the &=
operation.
impl<'a> BitAndAssign<&'a Integer> for Integer
[src]
fn bitand_assign(&mut self, rhs: &'a Integer)
[src]
Performs the &=
operation.
impl BitAndFrom<Integer> for Integer
[src]
fn bitand_from(&mut self, lhs: Integer)
[src]
Peforms the AND operation. Read more
impl<'a> BitAndFrom<&'a Integer> for Integer
[src]
fn bitand_from(&mut self, lhs: &'a Integer)
[src]
Peforms the AND operation. Read more
impl<'a> BitAnd<&'a Integer> for &'a Integer
[src]
type Output = BitAndRef<'a>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &'a Integer) -> BitAndRef<'a>
[src]
Performs the &
operation.
impl<'a> From<BitAndRef<'a>> for Integer
[src]
impl<'a> Assign<BitAndRef<'a>> for Integer
[src]
impl BitOr<Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: Integer) -> Integer
[src]
Performs the |
operation.
impl<'a> BitOr<&'a Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: &'a Integer) -> Integer
[src]
Performs the |
operation.
impl<'a> BitOr<Integer> for &'a Integer
[src]
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: Integer) -> Integer
[src]
Performs the |
operation.
impl BitOrAssign<Integer> for Integer
[src]
fn bitor_assign(&mut self, rhs: Integer)
[src]
Performs the |=
operation.
impl<'a> BitOrAssign<&'a Integer> for Integer
[src]
fn bitor_assign(&mut self, rhs: &'a Integer)
[src]
Performs the |=
operation.
impl BitOrFrom<Integer> for Integer
[src]
fn bitor_from(&mut self, lhs: Integer)
[src]
Peforms the OR operation. Read more
impl<'a> BitOrFrom<&'a Integer> for Integer
[src]
fn bitor_from(&mut self, lhs: &'a Integer)
[src]
Peforms the OR operation. Read more
impl<'a> BitOr<&'a Integer> for &'a Integer
[src]
type Output = BitOrRef<'a>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &'a Integer) -> BitOrRef<'a>
[src]
Performs the |
operation.
impl<'a> From<BitOrRef<'a>> for Integer
[src]
impl<'a> Assign<BitOrRef<'a>> for Integer
[src]
impl BitXor<Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: Integer) -> Integer
[src]
Performs the ^
operation.
impl<'a> BitXor<&'a Integer> for Integer
[src]
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &'a Integer) -> Integer
[src]
Performs the ^
operation.
impl<'a> BitXor<Integer> for &'a Integer
[src]
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: Integer) -> Integer
[src]
Performs the ^
operation.
impl BitXorAssign<Integer> for Integer
[src]
fn bitxor_assign(&mut self, rhs: Integer)
[src]
Performs the ^=
operation.
impl<'a> BitXorAssign<&'a Integer> for Integer
[src]
fn bitxor_assign(&mut self, rhs: &'a Integer)
[src]
Performs the ^=
operation.
impl BitXorFrom<Integer> for Integer
[src]
fn bitxor_from(&mut self, lhs: Integer)
[src]
Peforms the XOR operation. Read more
impl<'a> BitXorFrom<&'a Integer> for Integer
[src]
fn bitxor_from(&mut self, lhs: &'a Integer)
[src]
Peforms the XOR operation. Read more
impl<'a> BitXor<&'a Integer> for &'a Integer
[src]
type Output = BitXorRef<'a>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &'a Integer) -> BitXorRef<'a>
[src]
Performs the ^
operation.
impl<'a> From<BitXorRef<'a>> for Integer
[src]
impl<'a> Assign<BitXorRef<'a>> for Integer
[src]
impl Add<i32> for Integer
[src]
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: i32) -> Integer
[src]
Performs the +
operation.
impl AddAssign<i32> for Integer
[src]
fn add_assign(&mut self, rhs: i32)
[src]
Performs the +=
operation.
impl<'a> Add<i32> for &'a Integer
[src]
type Output = AddRefI32<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: i32) -> AddRefI32<'a>
[src]
Performs the +
operation.
impl<'a> From<AddRefI32<'a>> for Integer
[src]
impl<'a> Assign<AddRefI32<'a>> for Integer
[src]
impl AddFrom<i32> for Integer
[src]
impl Sub<i32> for Integer
[src]
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: i32) -> Integer
[src]
Performs the -
operation.
impl SubAssign<i32> for Integer
[src]
fn sub_assign(&mut self, rhs: i32)
[src]
Performs the -=
operation.
impl<'a> Sub<i32> for &'a Integer
[src]
type Output = SubRefI32<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: i32) -> SubRefI32<'a>
[src]
Performs the -
operation.
impl<'a> From<SubRefI32<'a>> for Integer
[src]
impl<'a> Assign<SubRefI32<'a>> for Integer
[src]
impl SubFrom<i32> for Integer
[src]
impl<'a> From<SubFromRefI32<'a>> for Integer
[src]
impl<'a> Assign<SubFromRefI32<'a>> for Integer
[src]
impl Mul<i32> for Integer
[src]
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: i32) -> Integer
[src]
Performs the *
operation.
impl MulAssign<i32> for Integer
[src]
fn mul_assign(&mut self, rhs: i32)
[src]
Performs the *=
operation.
impl<'a> Mul<i32> for &'a Integer
[src]
type Output = MulRefI32<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: i32) -> MulRefI32<'a>
[src]
Performs the *
operation.
impl<'a> From<MulRefI32<'a>> for Integer
[src]
impl<'a> Assign<MulRefI32<'a>> for Integer
[src]
impl MulFrom<i32> for Integer
[src]
impl Div<i32> for Integer
[src]
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: i32) -> Integer
[src]
Performs the /
operation.
impl DivAssign<i32> for Integer
[src]
fn div_assign(&mut self, rhs: i32)
[src]
Performs the /=
operation.
impl<'a> Div<i32> for &'a Integer
[src]
type Output = DivRefI32<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: i32) -> DivRefI32<'a>
[src]
Performs the /
operation.
impl<'a> From<DivRefI32<'a>> for Integer
[src]
impl<'a> Assign<DivRefI32<'a>> for Integer
[src]
impl DivFrom<i32> for Integer
[src]
impl<'a> From<DivFromRefI32<'a>> for Integer
[src]
impl<'a> Assign<DivFromRefI32<'a>> for Integer
[src]
impl Rem<i32> for Integer
[src]
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: i32) -> Integer
[src]
Performs the %
operation.
impl RemAssign<i32> for Integer
[src]
fn rem_assign(&mut self, rhs: i32)
[src]
Performs the %=
operation.
impl<'a> Rem<i32> for &'a Integer
[src]
type Output = RemRefI32<'a>
The resulting type after applying the %
operator.
fn rem(self, rhs: i32) -> RemRefI32<'a>
[src]
Performs the %
operation.
impl<'a> From<RemRefI32<'a>> for Integer
[src]
impl<'a> Assign<RemRefI32<'a>> for Integer
[src]
impl RemFrom<i32> for Integer
[src]
impl<'a> From<RemFromRefI32<'a>> for Integer
[src]
impl<'a> Assign<RemFromRefI32<'a>> for Integer
[src]
impl Shl<i32> for Integer
[src]
type Output = Integer
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> Integer
[src]
Performs the <<
operation.
impl ShlAssign<i32> for Integer
[src]
fn shl_assign(&mut self, rhs: i32)
[src]
Performs the <<=
operation.
impl<'a> Shl<i32> for &'a Integer
[src]
type Output = ShlRefI32<'a>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> ShlRefI32<'a>
[src]
Performs the <<
operation.
impl<'a> From<ShlRefI32<'a>> for Integer
[src]
impl<'a> Assign<ShlRefI32<'a>> for Integer
[src]
impl Shr<i32> for Integer
[src]
type Output = Integer
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> Integer
[src]
Performs the >>
operation.
impl ShrAssign<i32> for Integer
[src]
fn shr_assign(&mut self, rhs: i32)
[src]
Performs the >>=
operation.
impl<'a> Shr<i32> for &'a Integer
[src]
type Output = ShrRefI32<'a>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> ShrRefI32<'a>
[src]
Performs the >>
operation.
impl<'a> From<ShrRefI32<'a>> for Integer
[src]
impl<'a> Assign<ShrRefI32<'a>> for Integer
[src]
impl BitAnd<i32> for Integer
[src]
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: i32) -> Integer
[src]
Performs the &
operation.
impl BitAndAssign<i32> for Integer
[src]
fn bitand_assign(&mut self, rhs: i32)
[src]
Performs the &=
operation.
impl<'a> BitAnd<i32> for &'a Integer
[src]
type Output = BitAndRefI32<'a>
The resulting type after applying the &
operator.
fn bitand(self, rhs: i32) -> BitAndRefI32<'a>
[src]
Performs the &
operation.
impl<'a> From<BitAndRefI32<'a>> for Integer
[src]
impl<'a> Assign<BitAndRefI32<'a>> for Integer
[src]
impl BitAndFrom<i32> for Integer
[src]
fn bitand_from(&mut self, lhs: i32)
[src]
Peforms the AND operation. Read more
impl BitOr<i32> for Integer
[src]
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: i32) -> Integer
[src]
Performs the |
operation.
impl BitOrAssign<i32> for Integer
[src]
fn bitor_assign(&mut self, rhs: i32)
[src]
Performs the |=
operation.
impl<'a> BitOr<i32> for &'a Integer
[src]
type Output = BitOrRefI32<'a>
The resulting type after applying the |
operator.
fn bitor(self, rhs: i32) -> BitOrRefI32<'a>
[src]
Performs the |
operation.
impl<'a> From<BitOrRefI32<'a>> for Integer
[src]
impl<'a> Assign<BitOrRefI32<'a>> for Integer
[src]
impl BitOrFrom<i32> for Integer
[src]
fn bitor_from(&mut self, lhs: i32)
[src]
Peforms the OR operation. Read more
impl BitXor<i32> for Integer
[src]
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: i32) -> Integer
[src]
Performs the ^
operation.
impl BitXorAssign<i32> for Integer
[src]
fn bitxor_assign(&mut self, rhs: i32)
[src]
Performs the ^=
operation.
impl<'a> BitXor<i32> for &'a Integer
[src]
type Output = BitXorRefI32<'a>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: i32) -> BitXorRefI32<'a>
[src]
Performs the ^
operation.
impl<'a> From<BitXorRefI32<'a>> for Integer
[src]
impl<'a> Assign<BitXorRefI32<'a>> for Integer
[src]
impl BitXorFrom<i32> for Integer
[src]
fn bitxor_from(&mut self, lhs: i32)
[src]
Peforms the XOR operation. Read more
impl Add<u32> for Integer
[src]
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: u32) -> Integer
[src]
Performs the +
operation.
impl AddAssign<u32> for Integer
[src]
fn add_assign(&mut self, rhs: u32)
[src]
Performs the +=
operation.
impl<'a> Add<u32> for &'a Integer
[src]
type Output = AddRefU32<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: u32) -> AddRefU32<'a>
[src]
Performs the +
operation.
impl<'a> From<AddRefU32<'a>> for Integer
[src]
impl<'a> Assign<AddRefU32<'a>> for Integer
[src]
impl AddFrom<u32> for Integer
[src]
impl Sub<u32> for Integer
[src]
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: u32) -> Integer
[src]
Performs the -
operation.
impl SubAssign<u32> for Integer
[src]
fn sub_assign(&mut self, rhs: u32)
[src]
Performs the -=
operation.
impl<'a> Sub<u32> for &'a Integer
[src]
type Output = SubRefU32<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: u32) -> SubRefU32<'a>
[src]
Performs the -
operation.
impl<'a> From<SubRefU32<'a>> for Integer
[src]
impl<'a> Assign<SubRefU32<'a>> for Integer
[src]
impl SubFrom<u32> for Integer
[src]
impl<'a> From<SubFromRefU32<'a>> for Integer
[src]
impl<'a> Assign<SubFromRefU32<'a>> for Integer
[src]
impl Mul<u32> for Integer
[src]
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: u32) -> Integer
[src]
Performs the *
operation.
impl MulAssign<u32> for Integer
[src]
fn mul_assign(&mut self, rhs: u32)
[src]
Performs the *=
operation.
impl<'a> Mul<u32> for &'a Integer
[src]
type Output = MulRefU32<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: u32) -> MulRefU32<'a>
[src]
Performs the *
operation.
impl<'a> From<MulRefU32<'a>> for Integer
[src]
impl<'a> Assign<MulRefU32<'a>> for Integer
[src]
impl MulFrom<u32> for Integer
[src]
impl Div<u32> for Integer
[src]
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: u32) -> Integer
[src]
Performs the /
operation.
impl DivAssign<u32> for Integer
[src]
fn div_assign(&mut self, rhs: u32)
[src]
Performs the /=
operation.
impl<'a> Div<u32> for &'a Integer
[src]
type Output = DivRefU32<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: u32) -> DivRefU32<'a>
[src]
Performs the /
operation.
impl<'a> From<DivRefU32<'a>> for Integer
[src]
impl<'a> Assign<DivRefU32<'a>> for Integer
[src]
impl DivFrom<u32> for Integer
[src]
impl<'a> From<DivFromRefU32<'a>> for Integer
[src]
impl<'a> Assign<DivFromRefU32<'a>> for Integer
[src]
impl Rem<u32> for Integer
[src]
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: u32) -> Integer
[src]
Performs the %
operation.
impl RemAssign<u32> for Integer
[src]
fn rem_assign(&mut self, rhs: u32)
[src]
Performs the %=
operation.
impl<'a> Rem<u32> for &'a Integer
[src]
type Output = RemRefU32<'a>
The resulting type after applying the %
operator.
fn rem(self, rhs: u32) -> RemRefU32<'a>
[src]
Performs the %
operation.
impl<'a> From<RemRefU32<'a>> for Integer
[src]
impl<'a> Assign<RemRefU32<'a>> for Integer
[src]
impl RemFrom<u32> for Integer
[src]
impl<'a> From<RemFromRefU32<'a>> for Integer
[src]
impl<'a> Assign<RemFromRefU32<'a>> for Integer
[src]
impl Shl<u32> for Integer
[src]
type Output = Integer
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> Integer
[src]
Performs the <<
operation.
impl ShlAssign<u32> for Integer
[src]
fn shl_assign(&mut self, rhs: u32)
[src]
Performs the <<=
operation.
impl<'a> Shl<u32> for &'a Integer
[src]
type Output = ShlRefU32<'a>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> ShlRefU32<'a>
[src]
Performs the <<
operation.
impl<'a> From<ShlRefU32<'a>> for Integer
[src]
impl<'a> Assign<ShlRefU32<'a>> for Integer
[src]
impl Shr<u32> for Integer
[src]
type Output = Integer
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> Integer
[src]
Performs the >>
operation.
impl ShrAssign<u32> for Integer
[src]
fn shr_assign(&mut self, rhs: u32)
[src]
Performs the >>=
operation.
impl<'a> Shr<u32> for &'a Integer
[src]
type Output = ShrRefU32<'a>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> ShrRefU32<'a>
[src]
Performs the >>
operation.
impl<'a> From<ShrRefU32<'a>> for Integer
[src]
impl<'a> Assign<ShrRefU32<'a>> for Integer
[src]
impl Pow<u32> for Integer
[src]
type Output = Integer
The resulting type after the power operation.
fn pow(self, rhs: u32) -> Integer
[src]
Performs the power operation. Read more
impl PowAssign<u32> for Integer
[src]
fn pow_assign(&mut self, rhs: u32)
[src]
Peforms the power operation. Read more
impl<'a> Pow<u32> for &'a Integer
[src]
type Output = PowRefU32<'a>
The resulting type after the power operation.
fn pow(self, rhs: u32) -> PowRefU32<'a>
[src]
Performs the power operation. Read more
impl<'a> From<PowRefU32<'a>> for Integer
[src]
impl<'a> Assign<PowRefU32<'a>> for Integer
[src]
impl BitAnd<u32> for Integer
[src]
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: u32) -> Integer
[src]
Performs the &
operation.
impl BitAndAssign<u32> for Integer
[src]
fn bitand_assign(&mut self, rhs: u32)
[src]
Performs the &=
operation.
impl<'a> BitAnd<u32> for &'a Integer
[src]
type Output = BitAndRefU32<'a>
The resulting type after applying the &
operator.
fn bitand(self, rhs: u32) -> BitAndRefU32<'a>
[src]
Performs the &
operation.
impl<'a> From<BitAndRefU32<'a>> for Integer
[src]
impl<'a> Assign<BitAndRefU32<'a>> for Integer
[src]
impl BitAndFrom<u32> for Integer
[src]
fn bitand_from(&mut self, lhs: u32)
[src]
Peforms the AND operation. Read more
impl BitOr<u32> for Integer
[src]
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: u32) -> Integer
[src]
Performs the |
operation.
impl BitOrAssign<u32> for Integer
[src]
fn bitor_assign(&mut self, rhs: u32)
[src]
Performs the |=
operation.
impl<'a> BitOr<u32> for &'a Integer
[src]
type Output = BitOrRefU32<'a>
The resulting type after applying the |
operator.
fn bitor(self, rhs: u32) -> BitOrRefU32<'a>
[src]
Performs the |
operation.
impl<'a> From<BitOrRefU32<'a>> for Integer
[src]
impl<'a> Assign<BitOrRefU32<'a>> for Integer
[src]
impl BitOrFrom<u32> for Integer
[src]
fn bitor_from(&mut self, lhs: u32)
[src]
Peforms the OR operation. Read more
impl BitXor<u32> for Integer
[src]
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: u32) -> Integer
[src]
Performs the ^
operation.
impl BitXorAssign<u32> for Integer
[src]
fn bitxor_assign(&mut self, rhs: u32)
[src]
Performs the ^=
operation.
impl<'a> BitXor<u32> for &'a Integer
[src]
type Output = BitXorRefU32<'a>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: u32) -> BitXorRefU32<'a>
[src]
Performs the ^
operation.
impl<'a> From<BitXorRefU32<'a>> for Integer
[src]
impl<'a> Assign<BitXorRefU32<'a>> for Integer
[src]
impl BitXorFrom<u32> for Integer
[src]
fn bitxor_from(&mut self, lhs: u32)
[src]
Peforms the XOR operation. Read more
impl<'a> Add<MulRef<'a>> for Integer
[src]
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: MulRef) -> Integer
[src]
Performs the +
operation.
impl<'a> AddAssign<MulRef<'a>> for Integer
[src]
fn add_assign(&mut self, rhs: MulRef)
[src]
Performs the +=
operation.
impl<'a> Add<MulRef<'a>> for &'a Integer
[src]
type Output = AddMulRef<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: MulRef<'a>) -> AddMulRef<'a>
[src]
Performs the +
operation.
impl<'a> From<AddMulRef<'a>> for Integer
[src]
impl<'a> Assign<AddMulRef<'a>> for Integer
[src]
impl<'a> AddFrom<MulRef<'a>> for Integer
[src]
impl<'a> Add<MulRefU32<'a>> for Integer
[src]
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: MulRefU32) -> Integer
[src]
Performs the +
operation.
impl<'a> AddAssign<MulRefU32<'a>> for Integer
[src]
fn add_assign(&mut self, rhs: MulRefU32)
[src]
Performs the +=
operation.
impl<'a> Add<MulRefU32<'a>> for &'a Integer
[src]
type Output = AddMulRefU32<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: MulRefU32<'a>) -> AddMulRefU32<'a>
[src]
Performs the +
operation.
impl<'a> From<AddMulRefU32<'a>> for Integer
[src]
impl<'a> Assign<AddMulRefU32<'a>> for Integer
[src]
impl<'a> AddFrom<MulRefU32<'a>> for Integer
[src]
impl<'a> Add<MulRefI32<'a>> for Integer
[src]
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: MulRefI32) -> Integer
[src]
Performs the +
operation.
impl<'a> AddAssign<MulRefI32<'a>> for Integer
[src]
fn add_assign(&mut self, rhs: MulRefI32)
[src]
Performs the +=
operation.
impl<'a> Add<MulRefI32<'a>> for &'a Integer
[src]
type Output = AddMulRefI32<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: MulRefI32<'a>) -> AddMulRefI32<'a>
[src]
Performs the +
operation.
impl<'a> From<AddMulRefI32<'a>> for Integer
[src]
impl<'a> Assign<AddMulRefI32<'a>> for Integer
[src]
impl<'a> AddFrom<MulRefI32<'a>> for Integer
[src]
impl<'a> Sub<MulRef<'a>> for Integer
[src]
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: MulRef) -> Integer
[src]
Performs the -
operation.
impl<'a> SubAssign<MulRef<'a>> for Integer
[src]
fn sub_assign(&mut self, rhs: MulRef)
[src]
Performs the -=
operation.
impl<'a> Sub<MulRef<'a>> for &'a Integer
[src]
type Output = SubMulRef<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: MulRef<'a>) -> SubMulRef<'a>
[src]
Performs the -
operation.
impl<'a> From<SubMulRef<'a>> for Integer
[src]
impl<'a> Assign<SubMulRef<'a>> for Integer
[src]
impl<'a> SubFrom<MulRef<'a>> for Integer
[src]
impl<'a> From<SubMulRefFrom<'a>> for Integer
[src]
impl<'a> Assign<SubMulRefFrom<'a>> for Integer
[src]
impl<'a> Sub<MulRefU32<'a>> for Integer
[src]
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: MulRefU32) -> Integer
[src]
Performs the -
operation.
impl<'a> SubAssign<MulRefU32<'a>> for Integer
[src]
fn sub_assign(&mut self, rhs: MulRefU32)
[src]
Performs the -=
operation.
impl<'a> Sub<MulRefU32<'a>> for &'a Integer
[src]
type Output = SubMulRefU32<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: MulRefU32<'a>) -> SubMulRefU32<'a>
[src]
Performs the -
operation.
impl<'a> From<SubMulRefU32<'a>> for Integer
[src]
impl<'a> Assign<SubMulRefU32<'a>> for Integer
[src]
impl<'a> SubFrom<MulRefU32<'a>> for Integer
[src]
impl<'a> From<SubMulRefFromU32<'a>> for Integer
[src]
impl<'a> Assign<SubMulRefFromU32<'a>> for Integer
[src]
impl<'a> Sub<MulRefI32<'a>> for Integer
[src]
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: MulRefI32) -> Integer
[src]
Performs the -
operation.
impl<'a> SubAssign<MulRefI32<'a>> for Integer
[src]
fn sub_assign(&mut self, rhs: MulRefI32)
[src]
Performs the -=
operation.
impl<'a> Sub<MulRefI32<'a>> for &'a Integer
[src]
type Output = SubMulRefI32<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: MulRefI32<'a>) -> SubMulRefI32<'a>
[src]
Performs the -
operation.
impl<'a> From<SubMulRefI32<'a>> for Integer
[src]
impl<'a> Assign<SubMulRefI32<'a>> for Integer
[src]
impl<'a> SubFrom<MulRefI32<'a>> for Integer
[src]
impl<'a> From<SubMulRefFromI32<'a>> for Integer
[src]
impl<'a> Assign<SubMulRefFromI32<'a>> for Integer
[src]
impl Eq for Integer
[src]
impl Ord for Integer
[src]
fn cmp(&self, other: &Integer) -> Ordering
[src]
This method returns an Ordering
between self
and other
. Read more
fn max(self, other: Self) -> Self
1.22.0[src]
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
1.22.0[src]
Compares and returns the minimum of two values. Read more
impl PartialEq for Integer
[src]
fn eq(&self, other: &Integer) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialOrd for Integer
[src]
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<i32> for Integer
[src]
fn eq(&self, other: &i32) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialOrd<i32> for Integer
[src]
fn partial_cmp(&self, other: &i32) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<i64> for Integer
[src]
fn eq(&self, other: &i64) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialOrd<i64> for Integer
[src]
fn partial_cmp(&self, other: &i64) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<u32> for Integer
[src]
fn eq(&self, other: &u32) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialOrd<u32> for Integer
[src]
fn partial_cmp(&self, other: &u32) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<u64> for Integer
[src]
fn eq(&self, other: &u64) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialOrd<u64> for Integer
[src]
fn partial_cmp(&self, other: &u64) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<f32> for Integer
[src]
fn eq(&self, other: &f32) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialOrd<f32> for Integer
[src]
fn partial_cmp(&self, other: &f32) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl PartialEq<f64> for Integer
[src]
fn eq(&self, other: &f64) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialOrd<f64> for Integer
[src]
fn partial_cmp(&self, other: &f64) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl Sum for Integer
[src]
fn sum<I>(iter: I) -> Integer where
I: Iterator<Item = Integer>,
[src]
I: Iterator<Item = Integer>,
Method which takes an iterator and generates Self
from the elements by "summing up" the items. Read more
impl<'a> Sum<&'a Integer> for Integer
[src]
fn sum<I>(iter: I) -> Integer where
I: Iterator<Item = &'a Integer>,
[src]
I: Iterator<Item = &'a Integer>,
Method which takes an iterator and generates Self
from the elements by "summing up" the items. Read more
impl Product for Integer
[src]
fn product<I>(iter: I) -> Integer where
I: Iterator<Item = Integer>,
[src]
I: Iterator<Item = Integer>,
Method which takes an iterator and generates Self
from the elements by multiplying the items. Read more
impl<'a> Product<&'a Integer> for Integer
[src]
fn product<I>(iter: I) -> Integer where
I: Iterator<Item = &'a Integer>,
[src]
I: Iterator<Item = &'a Integer>,
Method which takes an iterator and generates Self
from the elements by multiplying the items. Read more
impl<'a> From<ValidInteger<'a>> for Integer
[src]
fn from(t: ValidInteger<'a>) -> Integer
[src]
Performs the conversion.
impl<'a> Assign<ValidInteger<'a>> for Integer
[src]
fn assign(&mut self, rhs: ValidInteger)
[src]
Peforms the assignement. Read more
impl Send for Integer
[src]
impl Sync for Integer
[src]
impl<'a> From<CeilRef<'a>> for Integer
[src]
impl<'a> Assign<CeilRef<'a>> for Integer
[src]
impl<'a> From<FloorRef<'a>> for Integer
[src]
impl<'a> Assign<FloorRef<'a>> for Integer
[src]
impl<'a> From<RoundRef<'a>> for Integer
[src]
impl<'a> Assign<RoundRef<'a>> for Integer
[src]
impl<'a> From<TruncRef<'a>> for Integer
[src]
impl<'a> Assign<TruncRef<'a>> for Integer
[src]
impl PartialEq<Rational> for Integer
[src]
fn eq(&self, other: &Rational) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialOrd<Rational> for Integer
[src]
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl Add<Float> for Integer
[src]
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
Performs the +
operation.
impl<'a> Add<Float> for &'a Integer
[src]
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float
[src]
Performs the +
operation.
impl<'a> Add<&'a Float> for Integer
[src]
type Output = AddRefIntegerOwn<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> AddRefIntegerOwn<'a>
[src]
Performs the +
operation.
impl<'a> Add<&'a Float> for &'a Integer
[src]
type Output = AddRefInteger<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> AddRefInteger<'a>
[src]
Performs the +
operation.
impl Sub<Float> for Integer
[src]
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
Performs the -
operation.
impl<'a> Sub<Float> for &'a Integer
[src]
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float
[src]
Performs the -
operation.
impl<'a> Sub<&'a Float> for Integer
[src]
type Output = SubFromRefIntegerOwn<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> SubFromRefIntegerOwn<'a>
[src]
Performs the -
operation.
impl<'a> Sub<&'a Float> for &'a Integer
[src]
type Output = SubRefIntegerOwn<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> SubRefIntegerOwn<'a>
[src]
Performs the -
operation.
impl Mul<Float> for Integer
[src]
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
Performs the *
operation.
impl<'a> Mul<Float> for &'a Integer
[src]
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float
[src]
Performs the *
operation.
impl<'a> Mul<&'a Float> for Integer
[src]
type Output = MulRefIntegerOwn<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> MulRefIntegerOwn<'a>
[src]
Performs the *
operation.
impl<'a> Mul<&'a Float> for &'a Integer
[src]
type Output = MulRefInteger<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> MulRefInteger<'a>
[src]
Performs the *
operation.
impl Div<Float> for Integer
[src]
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
Performs the /
operation.
impl<'a> Div<Float> for &'a Integer
[src]
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float
[src]
Performs the /
operation.
impl<'a> Div<&'a Float> for Integer
[src]
type Output = DivFromRefIntegerOwn<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> DivFromRefIntegerOwn<'a>
[src]
Performs the /
operation.
impl<'a> Div<&'a Float> for &'a Integer
[src]
type Output = DivRefIntegerOwn<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> DivRefIntegerOwn<'a>
[src]
Performs the /
operation.
impl PartialEq<Float> for Integer
[src]
fn eq(&self, other: &Float) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialOrd<Float> for Integer
[src]
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more