[−][src]Struct rug::Integer
An arbitrary-precision integer.
Standard arithmetic operations, bitwise operations and comparisons are
supported. In standard arithmetic operations such as addition, you can
mix Integer
and primitive integer types; the result will be an
Integer
.
Internally the integer is not stored using a two’s-complement representation, however, for bitwise operations and shifts, the functionality is the same as if the representation was using two’s complement.
Examples
use rug::{Assign, Integer}; // Create an integer initialized as zero. let mut int = Integer::new(); assert_eq!(int, 0); assert_eq!(int.to_u32(), Some(0)); int.assign(-14); assert_eq!(int, -14); assert_eq!(int.to_u32(), None); assert_eq!(int.to_i32(), Some(-14));
Arithmetic operations with mixed arbitrary and primitive types are
allowed. Note that in the following example, there is only one
allocation. The Integer
instance is moved into the shift operation
so that the result can be stored in the same instance, then that
result is similarly consumed by the addition operation.
use rug::Integer; let mut a = Integer::from(0xc); a = (a << 80) + 0xffee; assert_eq!(a.to_string_radix(16), "c0000000000000000ffee"); // ↑ ↑ ↑ ↑ ↑ ↑ // 80 64 48 32 16 0
Bitwise operations on Integer
values behave as if the value uses a
two’s-complement representation.
use rug::Integer; let mut i = Integer::from(1); i = i << 1000; // i is now 1000000... (1000 zeros) assert_eq!(i.significant_bits(), 1001); assert_eq!(i.find_one(0), Some(1000)); i -= 1; // i is now 111111... (1000 ones) assert_eq!(i.count_ones(), Some(1000)); let a = Integer::from(0xf00d); // −1 is all ones in two’s complement let all_ones_xor_a = Integer::from(-1 ^ &a); // a is unchanged as we borrowed it let complement_a = !a; // now a has been moved, so this would cause an error: // assert!(a > 0); assert_eq!(all_ones_xor_a, complement_a); assert_eq!(complement_a, -0xf00e); assert_eq!(format!("{:x}", complement_a), "-f00e");
To initialize a large Integer
that does not fit in a primitive type,
you can parse a string.
use rug::Integer; let s1 = "123456789012345678901234567890"; let i1 = s1.parse::<Integer>().unwrap(); assert_eq!(i1.significant_bits(), 97); let s2 = "ffff0000ffff0000ffff0000ffff0000ffff0000"; let i2 = Integer::from_str_radix(s2, 16).unwrap(); assert_eq!(i2.significant_bits(), 160); assert_eq!(i2.count_ones(), Some(80));
Operations on two borrowed Integer
values result in an
incomplete-computation value that has to be assigned to a new
Integer
value.
use rug::Integer; let a = Integer::from(10); let b = Integer::from(3); let a_b_ref = &a + &b; let a_b = Integer::from(a_b_ref); assert_eq!(a_b, 13);
As a special case, when an incomplete-computation value is
obtained from multiplying two Integer
references, it can be added to
or subtracted from another Integer
(or reference). This can be
useful for multiply-accumulate operations.
use rug::Integer; let mut acc = Integer::from(100); let m1 = Integer::from(3); let m2 = Integer::from(7); // 100 + 3 × 7 = 121 acc += &m1 * &m2; assert_eq!(acc, 121); let other = Integer::from(2000); // Do not consume any values here: // 2000 − 3 × 7 = 1979 let sub = Integer::from(&other - &m1 * &m2); assert_eq!(sub, 1979);
The Integer
type supports various functions. Most methods have three
versions:
- The first method consumes the operand.
- The second method has a “
_mut
” suffix and mutates the operand. - The third method has a “
_ref
” suffix and borrows the operand. The returned item is an incomplete-computation value that can be assigned to anInteger
.
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]
impl Integer
pub fn new() -> Self | [src] |
Constructs a new arbitrary-precision Integer
with value 0.
Examples
use rug::Integer; let i = Integer::new(); assert_eq!(i, 0);
pub fn with_capacity(bits: usize) -> Self | [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);
pub 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);
pub 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); assert_eq!(i.significant_bits(), 30); i.reserve(290); let capacity = i.capacity(); assert!(capacity >= 320); i.reserve(0); assert_eq!(i.capacity(), capacity); i.reserve(291); assert!(i.capacity() >= 321);
pub fn shrink_to_fit(&mut self) | [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_eq!(i.significant_bits(), 100); assert!(i.capacity() >= 100); i >>= 80; i.shrink_to_fit(); assert!(i.capacity() >= 20);
pub unsafe fn from_raw(raw: mpz_t) -> Self | [src] |
Creates an Integer
from an initialized
GMP integer.
Safety
- The value must be initialized.
- The
gmp_mpfr_sys::gmp::mpz_t
type can be considered as a kind of pointer, so there can be multiple copies of it. Since this function takes over ownership, no other copies of the passed value should exist.
Examples
use gmp_mpfr_sys::gmp; use rug::Integer; use std::mem; let i = unsafe { let mut z = mem::uninitialized(); gmp::mpz_init_set_ui(&mut z, 15); // z is initialized and unique Integer::from_raw(z) }; assert_eq!(i, 15); // since i is an Integer now, deallocation is automatic
pub fn into_raw(self) -> mpz_t | [src] |
Converts an Integer
into a GMP integer.
The returned object should be freed to avoid memory leaks.
Examples
use gmp_mpfr_sys::gmp; use rug::Integer; let i = Integer::from(15); let mut z = i.into_raw(); unsafe { let u = gmp::mpz_get_ui(&z); assert_eq!(u, 15); // free object to prevent memory leak gmp::mpz_clear(&mut z); }
pub fn as_raw(&self) -> *const mpz_t | [src] |
Returns a pointer to the inner GMP integer.
The returned pointer will be valid for as long as self
is
valid.
Examples
use gmp_mpfr_sys::gmp; use rug::Integer; let i = Integer::from(15); let z_ptr = i.as_raw(); unsafe { let u = gmp::mpz_get_ui(z_ptr); assert_eq!(u, 15); } // i is still valid assert_eq!(i, 15);
pub fn as_raw_mut(&mut self) -> *mut mpz_t | [src] |
Returns an unsafe mutable pointer to the inner GMP integer.
The returned pointer will be valid for as long as self
is
valid.
Examples
use gmp_mpfr_sys::gmp; use rug::Integer; let mut i = Integer::from(15); let z_ptr = i.as_raw_mut(); unsafe { gmp::mpz_add_ui(z_ptr, z_ptr, 20); } assert_eq!(i, 35);
pub fn from_digits<T>(digits: &[T], order: Order) -> Self where | [src] |
Creates an Integer
from a slice of digits of type T
,
where T
can be any of the unsigned integer primitive types.
The resulting value cannot be negative.
Examples
use rug::integer::Order; use rug::Integer; let digits = [0x5678u16, 0x1234u16]; let i = Integer::from_digits(&digits, Order::Lsf); assert_eq!(i, 0x1234_5678);
pub fn assign_digits<T>(&mut self, digits: &[T], order: Order) where | [src] |
Assigns from a slice of digits of type T
, where T
can be
any of the unsigned integer primitive types.
The resulting value cannot be negative.
Examples
use rug::integer::Order; use rug::Integer; let digits = [0x5678u16, 0x1234u16]; let mut i = Integer::new(); i.assign_digits(&digits, Order::Lsf); assert_eq!(i, 0x1234_5678);
pub fn significant_digits<T>(&self) -> usize where | [src] |
Returns the number of digits of type T
required to represent
the absolute value.
T
can be any of the unsigned integer primitive types.
Examples
use rug::Integer; let i: Integer = Integer::from(1) << 256; assert_eq!(i.significant_digits::<u8>(), 33); assert_eq!(i.significant_digits::<u16>(), 17); assert_eq!(i.significant_digits::<u32>(), 9); assert_eq!(i.significant_digits::<u64>(), 5);
pub fn to_digits<T>(&self, order: Order) -> Vec<T> where | [src] |
Converts the absolute value to a Vec
of digits of type
T
, where T
can be any of the unsigned integer primitive
types.
Examples
use rug::integer::Order; use rug::Integer; let i = Integer::from(0x1234_5678_9abc_def0u64); let digits = i.to_digits::<u32>(Order::MsfBe); assert_eq!(digits, [0x1234_5678u32.to_be(), 0x9abc_def0u32.to_be()]); let zero = Integer::new(); let digits_zero = zero.to_digits::<u32>(Order::MsfBe); assert!(digits_zero.is_empty());
pub fn write_digits<T>(&self, digits: &mut [T], order: Order) where | [src] |
Writes the absolute value into a slice of digits of type
T
, where T
can be any of the unsigned integer primitive
types.
The slice must be large enough to hold the digits; the minimum
size can be obtained using the significant_digits
method.
The contents of the slice can be uninitialized before this method is called; this method sets all the elements of the slice, padding with zeros if the slice is larger than required.
Panics
Panics if the slice does not have sufficient capacity.
Examples
use rug::integer::Order; use rug::Integer; let i = Integer::from(0x1234_5678_9abc_def0u64); let mut digits = [0xffff_ffffu32; 4]; i.write_digits(&mut digits, Order::MsfBe); let word0 = 0x9abc_def0u32; let word1 = 0x1234_5678u32; assert_eq!(digits, [0, 0, word1.to_be(), word0.to_be()]);
The following example shows how to write into uninitialized
memory. In practice, the following code could be replaced by a
call to to_digits
.
use rug::integer::Order; use rug::Integer; use std::slice; let i = Integer::from(0x1234_5678_9abc_def0u64); let len = i.significant_digits::<u32>(); assert_eq!(len, 2); // The following code is equivalent to: // let digits = i.to_digits::<u32>(Order::MsfBe); let mut digits = Vec::<u32>::with_capacity(len); // The dst slice points to allocated but uninitialized memory. // All the digits will be initialized by write_digits. unsafe { let ptr = digits.as_mut_ptr(); let dst = slice::from_raw_parts_mut(ptr, len); i.write_digits(dst, Order::MsfBe); digits.set_len(len); } assert_eq!(digits, [0x1234_5678u32.to_be(), 0x9abc_def0u32.to_be()]);
pub fn from_f32(val: f32) -> Option<Self> | [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());
pub fn from_f64(val: f64) -> Option<Self> | [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());
pub fn from_str_radix(src: &str, radix: i32) -> Result<Self, ParseIntegerError> | [src] |
Parses an Integer
using the given radix.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::Integer; let i = Integer::from_str_radix("-ff", 16).unwrap(); assert_eq!(i, -0xff);
pub fn parse<S>(src: S) -> Result<ParseIncomplete, ParseIntegerError> where | [src] |
Parses a decimal string slice (&str
) or byte slice
(&[u8]
) into an Integer
.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
unwrapped returned incomplete-computation value as
Src
.
The string can start with an optional minus or plus sign. ASCII whitespace is ignored everywhere in the string. Underscores anywhere except before the first digit are ignored as well.
Examples
use rug::Integer; let valid1 = Integer::parse("1223"); let i1 = Integer::from(valid1.unwrap()); assert_eq!(i1, 1223); let valid2 = Integer::parse("123 456 789"); let i2 = Integer::from(valid2.unwrap()); assert_eq!(i2, 123_456_789); let invalid = Integer::parse("789a"); assert!(invalid.is_err());
pub fn parse_radix<S>( | [src] |
Parses a string slice (&str
) or byte slice
(&[u8]
) into an Integer
.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
unwrapped returned incomplete-computation value as
Src
.
The string can start with an optional minus or plus sign. ASCII whitespace is ignored everywhere in the string. Underscores anywhere except before the first digit are ignored as well.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::Integer; let valid1 = Integer::parse_radix("1223", 4); let i1 = Integer::from(valid1.unwrap()); assert_eq!(i1, 3 + 4 * (2 + 4 * (2 + 4 * 1))); let valid2 = Integer::parse_radix("1234 abcd", 16); let i2 = Integer::from(valid2.unwrap()); assert_eq!(i2, 0x1234_abcd); let invalid = Integer::parse_radix("123", 3); assert!(invalid.is_err());
pub fn to_i8(&self) -> Option<i8> | [src] |
Converts to an i8
if the value fits.
If the compiler supports TryFrom
, this conversion can also
be performed using i8::try_from(&integer)
or
i8::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(-100); assert_eq!(fits.to_i8(), Some(-100)); let small = Integer::from(-200); assert_eq!(small.to_i8(), None); let large = Integer::from(200); assert_eq!(large.to_i8(), None);
pub fn to_i16(&self) -> Option<i16> | [src] |
Converts to an i16
if the value fits.
If the compiler supports TryFrom
, this conversion can also
be performed using i16::try_from(&integer)
or
i16::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(-30_000); assert_eq!(fits.to_i16(), Some(-30_000)); let small = Integer::from(-40_000); assert_eq!(small.to_i16(), None); let large = Integer::from(40_000); assert_eq!(large.to_i16(), None);
pub fn to_i32(&self) -> Option<i32> | [src] |
Converts to an i32
if the value fits.
If the compiler supports TryFrom
, this conversion can also
be performed using i32::try_from(&integer)
or
i32::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(-50); assert_eq!(fits.to_i32(), Some(-50)); let small = Integer::from(-123456789012345_i64); assert_eq!(small.to_i32(), None); let large = Integer::from(123456789012345_i64); assert_eq!(large.to_i32(), None);
pub fn to_i64(&self) -> Option<i64> | [src] |
Converts to an i64
if the value fits.
If the compiler supports TryFrom
, this conversion can also
be performed using i64::try_from(&integer)
or
i64::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(-50); assert_eq!(fits.to_i64(), Some(-50)); let small = Integer::from_str_radix("-fedcba9876543210", 16).unwrap(); assert_eq!(small.to_i64(), None); let large = Integer::from_str_radix("fedcba9876543210", 16).unwrap(); assert_eq!(large.to_i64(), None);
pub fn to_i128(&self) -> Option<i128> | [src] |
Converts to an i128
if the value fits.
This method is only present if the compiler supports the
i128
primitive.
If the compiler supports TryFrom
, this conversion can also
be performed using i128::try_from(&integer)
or
i128::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(-50); assert_eq!(fits.to_i128(), Some(-50)); let small: Integer = Integer::from(-1) << 130; assert_eq!(small.to_i128(), None); let large: Integer = Integer::from(1) << 130; assert_eq!(large.to_i128(), None);
pub fn to_isize(&self) -> Option<isize> | [src] |
Converts to an isize
if the value fits.
If the compiler supports TryFrom
, this conversion can also
be performed using isize::try_from(&integer)
or
isize::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(0x1000); assert_eq!(fits.to_isize(), Some(0x1000)); let large: Integer = Integer::from(0x1000) << 128; assert_eq!(large.to_isize(), None);
pub fn to_u8(&self) -> Option<u8> | [src] |
Converts to a u8
if the value fits.
If the compiler supports TryFrom
, this conversion can also
be performed using u8::try_from(&integer)
or
u8::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(200); assert_eq!(fits.to_u8(), Some(200)); let neg = Integer::from(-1); assert_eq!(neg.to_u8(), None); let large = Integer::from(300); assert_eq!(large.to_u8(), None);
pub fn to_u16(&self) -> Option<u16> | [src] |
Converts to a u16
if the value fits.
If the compiler supports TryFrom
, this conversion can also
be performed using u16::try_from(&integer)
or
u16::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(60_000); assert_eq!(fits.to_u16(), Some(60_000)); let neg = Integer::from(-1); assert_eq!(neg.to_u16(), None); let large = Integer::from(70_000); assert_eq!(large.to_u16(), None);
pub fn to_u32(&self) -> Option<u32> | [src] |
Converts to a u32
if the value fits.
If the compiler supports TryFrom
, this conversion can also
be performed using u32::try_from(&integer)
or
u32::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(1234567890); assert_eq!(fits.to_u32(), Some(1234567890)); let neg = Integer::from(-1); assert_eq!(neg.to_u32(), None); let large = Integer::from(123456789012345_u64); assert_eq!(large.to_u32(), None);
pub fn to_u64(&self) -> Option<u64> | [src] |
Converts to a u64
if the value fits.
If the compiler supports TryFrom
, this conversion can also
be performed using u64::try_from(&integer)
or
u64::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(123456789012345_u64); assert_eq!(fits.to_u64(), Some(123456789012345)); let neg = Integer::from(-1); assert_eq!(neg.to_u64(), None); let large = "1234567890123456789012345".parse::<Integer>().unwrap(); assert_eq!(large.to_u64(), None);
pub fn to_u128(&self) -> Option<u128> | [src] |
Converts to a u128
if the value fits.
This method is only present if the compiler supports the
u128
primitive.
If the compiler supports TryFrom
, this conversion can also
be performed using u128::try_from(&integer)
or
u128::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(12345678901234567890_u128); assert_eq!(fits.to_u128(), Some(12345678901234567890)); let neg = Integer::from(-1); assert_eq!(neg.to_u128(), None); let large = "1234567890123456789012345678901234567890" .parse::<Integer>() .unwrap(); assert_eq!(large.to_u128(), None);
pub fn to_usize(&self) -> Option<usize> | [src] |
Converts to a usize
if the value fits.
If the compiler supports TryFrom
, this conversion can also
be performed using usize::try_from(&integer)
or
usize::try_from(integer)
.
Examples
use rug::Integer; let fits = Integer::from(0x1000); assert_eq!(fits.to_usize(), Some(0x1000)); let neg = Integer::from(-1); assert_eq!(neg.to_usize(), None); let large: Integer = Integer::from(0x1000) << 128; assert_eq!(large.to_usize(), None);
pub fn to_i8_wrapping(&self) -> i8 | [src] |
Converts to an i8
, wrapping if the value does not fit.
Examples
use rug::Integer; let large = Integer::from(0x1234); assert_eq!(large.to_i8_wrapping(), 0x34);
pub fn to_i16_wrapping(&self) -> i16 | [src] |
Converts to an i16
, wrapping if the value does not fit.
Examples
use rug::Integer; let large = Integer::from(0x1234_5678); assert_eq!(large.to_i16_wrapping(), 0x5678);
pub fn to_i32_wrapping(&self) -> i32 | [src] |
Converts to an i32
, wrapping if the value does not fit.
Examples
use rug::Integer; let large = Integer::from(0x1234_5678_9abc_def0_u64); assert_eq!(large.to_i32_wrapping(), 0x9abc_def0_u32 as i32);
pub fn to_i64_wrapping(&self) -> i64 | [src] |
Converts to an i64
, wrapping if the value does not fit.
Examples
use rug::Integer; let large = Integer::from_str_radix("f123456789abcdef0", 16).unwrap(); assert_eq!(large.to_i64_wrapping(), 0x1234_5678_9abc_def0);
pub fn to_i128_wrapping(&self) -> i128 | [src] |
Converts to an i128
, wrapping if the value does not fit.
This method is only present if the compiler supports the
i128
primitive.
Examples
use rug::Integer; let s = "f123456789abcdef0123456789abcdef0"; let large = Integer::from_str_radix(s, 16).unwrap(); assert_eq!( large.to_i128_wrapping(), 0x1234_5678_9abc_def0_1234_5678_9abc_def0 );
pub fn to_isize_wrapping(&self) -> isize | [src] |
Converts to an isize
, wrapping if the value does not fit.
Examples
use rug::Integer; let large: Integer = (Integer::from(0x1000) << 128) | 0x1234; assert_eq!(large.to_isize_wrapping(), 0x1234);
pub fn to_u8_wrapping(&self) -> u8 | [src] |
Converts to a u8
, wrapping if the value does not fit.
Examples
use rug::Integer; let neg = Integer::from(-1); assert_eq!(neg.to_u8_wrapping(), 0xff); let large = Integer::from(0x1234); assert_eq!(large.to_u8_wrapping(), 0x34);
pub fn to_u16_wrapping(&self) -> u16 | [src] |
Converts to a u16
, wrapping if the value does not fit.
Examples
use rug::Integer; let neg = Integer::from(-1); assert_eq!(neg.to_u16_wrapping(), 0xffff); let large = Integer::from(0x1234_5678); assert_eq!(large.to_u16_wrapping(), 0x5678);
pub fn to_u32_wrapping(&self) -> u32 | [src] |
Converts to a u32
, wrapping if the value does not fit.
Examples
use rug::Integer; let neg = Integer::from(-1); assert_eq!(neg.to_u32_wrapping(), 0xffff_ffff); let large = Integer::from(0x1234_5678_9abc_def0_u64); assert_eq!(large.to_u32_wrapping(), 0x9abc_def0);
pub fn to_u64_wrapping(&self) -> u64 | [src] |
Converts to a u64
, wrapping if the value does not fit.
Examples
use rug::Integer; let neg = Integer::from(-1); assert_eq!(neg.to_u64_wrapping(), 0xffff_ffff_ffff_ffff); let large = Integer::from_str_radix("f123456789abcdef0", 16).unwrap(); assert_eq!(large.to_u64_wrapping(), 0x1234_5678_9abc_def0);
pub fn to_u128_wrapping(&self) -> u128 | [src] |
Converts to a u128
, wrapping if the value does not fit.
This method is only present if the compiler supports the
u128
primitive.
Examples
use rug::Integer; let neg = Integer::from(-1); assert_eq!( neg.to_u128_wrapping(), 0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff ); let s = "f123456789abcdef0123456789abcdef0"; let large = Integer::from_str_radix(s, 16).unwrap(); assert_eq!( large.to_u128_wrapping(), 0x1234_5678_9abc_def0_1234_5678_9abc_def0 );
pub fn to_usize_wrapping(&self) -> usize | [src] |
Converts to a usize
, wrapping if the value does not fit.
Examples
use rug::Integer; let large: Integer = (Integer::from(0x1000) << 128) | 0x1234; assert_eq!(large.to_usize_wrapping(), 0x1234);
pub fn to_f32(&self) -> f32 | [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);
pub 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);
pub 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));
pub 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));
pub fn to_string_radix(&self, radix: i32) -> String | [src] |
Returns a string representation of the number for the
specified radix
.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::{Assign, Integer}; let mut i = Integer::new(); assert_eq!(i.to_string_radix(10), "0"); i.assign(-10); assert_eq!(i.to_string_radix(16), "-a"); i.assign(0x1234cdef); assert_eq!(i.to_string_radix(4), "102031030313233"); i.assign(Integer::parse_radix("123456789aAbBcCdDeEfF", 16).unwrap()); assert_eq!(i.to_string_radix(16), "123456789aabbccddeeff");
pub fn assign_f32(&mut self, val: f32) -> Result<(), ()> | [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);
pub 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);
pub fn as_neg(&self) -> BorrowInteger | [src] |
Borrows a negated copy of the Integer
.
The returned object implements
Deref<Target = Integer>
.
This method performs a shallow copy and negates it, and negation does not change the allocated data.
Examples
use rug::Integer; let i = Integer::from(42); let neg_i = i.as_neg(); assert_eq!(*neg_i, -42); // methods taking &self can be used on the returned object let reneg_i = neg_i.as_neg(); assert_eq!(*reneg_i, 42); assert_eq!(*reneg_i, i);
pub fn as_abs(&self) -> BorrowInteger | [src] |
Borrows an absolute copy of the Integer
.
The returned object implements
Deref<Target = Integer>
.
This method performs a shallow copy and possibly negates it, and negation does not change the allocated data.
Examples
use rug::Integer; let i = Integer::from(-42); let abs_i = i.as_abs(); assert_eq!(*abs_i, 42); // methods taking &self can be used on the returned object let reabs_i = abs_i.as_abs(); assert_eq!(*reabs_i, 42); assert_eq!(*reabs_i, *abs_i);
pub fn is_even(&self) -> bool | [src] |
Returns true
if the number is even.
Examples
use rug::Integer; assert!(!(Integer::from(13).is_even())); assert!(Integer::from(-14).is_even());
pub fn is_odd(&self) -> bool | [src] |
Returns true
if the number is odd.
Examples
use rug::Integer; assert!(Integer::from(13).is_odd()); assert!(!Integer::from(-14).is_odd());
pub fn is_divisible(&self, divisor: &Self) -> bool | [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()));
pub 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));
pub 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));
pub fn is_congruent(&self, c: &Self, divisor: &Self) -> 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)));
pub 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));
pub fn is_congruent_2pow(&self, c: &Self, 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));
pub fn is_perfect_power(&self) -> bool | [src] |
Returns true
if the number is a perfect power.
Examples
use rug::Integer; // 0 is 0 to the power of anything assert!(Integer::from(0).is_perfect_power()); // 25 is 5 to the power of 2 assert!(Integer::from(25).is_perfect_power()); // −243 is −3 to the power of 5 assert!(Integer::from(243).is_perfect_power()); assert!(!Integer::from(24).is_perfect_power()); assert!(!Integer::from(-100).is_perfect_power());
pub fn is_perfect_square(&self) -> bool | [src] |
Returns true
if the number is a perfect square.
Examples
use rug::Integer; assert!(Integer::from(0).is_perfect_square()); assert!(Integer::from(1).is_perfect_square()); assert!(Integer::from(4).is_perfect_square()); assert!(Integer::from(9).is_perfect_square()); assert!(!Integer::from(15).is_perfect_square()); assert!(!Integer::from(-9).is_perfect_square());
pub fn is_power_of_two(&self) -> bool | [src] |
Returns true
if the number is a power of two.
Examples
use rug::Integer; assert!(Integer::from(1).is_power_of_two()); assert!(Integer::from(4).is_power_of_two()); assert!(Integer::from(1 << 30).is_power_of_two()); assert!(!Integer::from(7).is_power_of_two()); assert!(!Integer::from(0).is_power_of_two()); assert!(!Integer::from(-1).is_power_of_two());
pub fn cmp0(&self) -> Ordering | [src] |
Returns the same result as self.cmp(&0.into())
, but
is faster.
Examples
use rug::Integer; use std::cmp::Ordering; assert_eq!(Integer::from(-5).cmp0(), Ordering::Less); assert_eq!(Integer::from(0).cmp0(), Ordering::Equal); assert_eq!(Integer::from(5).cmp0(), Ordering::Greater);
pub fn cmp_abs(&self, other: &Self) -> Ordering | [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);
pub 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); // “1” assert_eq!(Integer::from(4).significant_bits(), 3); // “100” assert_eq!(Integer::from(7).significant_bits(), 3); // “111” assert_eq!(Integer::from(-1).significant_bits(), 1); // “1” assert_eq!(Integer::from(-4).significant_bits(), 3); // “100” assert_eq!(Integer::from(-7).significant_bits(), 3); // “111”
pub fn signed_bits(&self) -> u32 | [src] |
Returns the number of bits required to represent the value using a two’s-complement representation.
For non-negative numbers, this method returns one more than
the significant_bits
method, since an extra zero is needed
before the most significant bit.
Examples
use rug::Integer; assert_eq!(Integer::from(-5).signed_bits(), 4); // “1011” assert_eq!(Integer::from(-4).signed_bits(), 3); // “100” assert_eq!(Integer::from(-3).signed_bits(), 3); // “101” assert_eq!(Integer::from(-2).signed_bits(), 2); // “10” assert_eq!(Integer::from(-1).signed_bits(), 1); // “1” assert_eq!(Integer::from(0).signed_bits(), 1); // “0” assert_eq!(Integer::from(1).signed_bits(), 2); // “01” assert_eq!(Integer::from(2).signed_bits(), 3); // “010” assert_eq!(Integer::from(3).signed_bits(), 3); // “011” assert_eq!(Integer::from(4).signed_bits(), 4); // “0100”
pub fn count_ones(&self) -> Option<u32> | [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);
pub 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));
pub 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));
pub 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));
pub fn set_bit(&mut self, index: u32, val: bool) -> &mut Self | [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);
pub 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));
pub fn toggle_bit(&mut self, index: u32) -> &mut Self | [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);
pub fn hamming_dist(&self, other: &Self) -> 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));
pub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I> where | [src] |
Adds a list of Integer
values.
Assign<Src> for Integer
,
From<Src> for Integer
,
AddAssign<Src> for Integer
and
Add<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let values = [ Integer::from(5), Integer::from(1024), Integer::from(-100_000), Integer::from(-4), ]; let r = Integer::sum(values.iter()); let sum = Integer::from(r); let expected = 5 + 1024 - 100_000 - 4; assert_eq!(sum, expected);
pub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I> where | [src] |
Finds the dot product of a list of Integer
value pairs.
Assign<Src> for Integer
,
From<Src> for Integer
,
AddAssign<Src> for Integer
and
Add<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let a = [Integer::from(270), Integer::from(-11)]; let b = [Integer::from(100), Integer::from(5)]; let r = Integer::dot(a.iter().zip(b.iter())); let dot = Integer::from(r); let expected = 270 * 100 - 11 * 5; assert_eq!(dot, expected);
pub fn product<'a, I>(values: I) -> ProductIncomplete<'a, I> where | [src] |
Multiplies a list of Integer
values.
Assign<Src> for Integer
,
From<Src> for Integer
,
MulAssign<Src> for Integer
and
Mul<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let values = [ Integer::from(5), Integer::from(1024), Integer::from(-100_000), Integer::from(-4), ]; let r = Integer::product(values.iter()); let product = Integer::from(r); let expected = 5 * 1024 * -100_000 * -4; assert_eq!(product, expected);
pub fn abs(self) -> Self | [src] |
Computes the absolute value.
Examples
use rug::Integer; let i = Integer::from(-100); let abs = i.abs(); assert_eq!(abs, 100);
pub fn abs_mut(&mut self) | [src] |
Computes the absolute value.
Examples
use rug::Integer; let mut i = Integer::from(-100); i.abs_mut(); assert_eq!(i, 100);
pub fn abs_ref(&self) -> AbsIncomplete | [src] |
Computes the absolute value.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let i = Integer::from(-100); let r = i.abs_ref(); let abs = Integer::from(r); assert_eq!(abs, 100); assert_eq!(i, -100);
pub fn signum(self) -> Self | [src] |
Computes the signum.
- 0 if the value is zero
- 1 if the value is positive
- −1 if the value is negative
Examples
use rug::Integer; assert_eq!(Integer::from(-100).signum(), -1); assert_eq!(Integer::from(0).signum(), 0); assert_eq!(Integer::from(100).signum(), 1);
pub fn signum_mut(&mut self) | [src] |
Computes the signum.
- 0 if the value is zero
- 1 if the value is positive
- −1 if the value is negative
Examples
use rug::Integer; let mut i = Integer::from(-100); i.signum_mut(); assert_eq!(i, -1);
pub fn signum_ref(&self) -> SignumIncomplete | [src] |
Computes the signum.
- 0 if the value is zero
- 1 if the value is positive
- −1 if the value is negative
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let i = Integer::from(-100); let r = i.signum_ref(); let signum = Integer::from(r); assert_eq!(signum, -1); assert_eq!(i, -100);
pub fn clamp<'a, 'b, Min, Max>(self, min: &'a Min, max: &'b Max) -> Self where | [src] |
Clamps the value within the specified bounds.
Panics
Panics if the maximum value is less than the minimum value.
Examples
use rug::Integer; let min = -10; let max = 10; let too_small = Integer::from(-100); let clamped1 = too_small.clamp(&min, &max); assert_eq!(clamped1, -10); let in_range = Integer::from(3); let clamped2 = in_range.clamp(&min, &max); assert_eq!(clamped2, 3);
pub fn clamp_mut<'a, 'b, Min, Max>(&mut self, min: &'a Min, max: &'b Max) where | [src] |
Clamps the value within the specified bounds.
Panics
Panics if the maximum value is less than the minimum value.
Examples
use rug::Integer; let min = -10; let max = 10; let mut too_small = Integer::from(-100); too_small.clamp_mut(&min, &max); assert_eq!(too_small, -10); let mut in_range = Integer::from(3); in_range.clamp_mut(&min, &max); assert_eq!(in_range, 3);
pub fn clamp_ref<'a, Min, Max>( | [src] |
Clamps the value within the specified bounds.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Panics
Panics if the maximum value is less than the minimum value.
Examples
use rug::Integer; let min = -10; let max = 10; let too_small = Integer::from(-100); let r1 = too_small.clamp_ref(&min, &max); let clamped1 = Integer::from(r1); assert_eq!(clamped1, -10); let in_range = Integer::from(3); let r2 = in_range.clamp_ref(&min, &max); let clamped2 = Integer::from(r2); assert_eq!(clamped2, 3);
pub fn keep_bits(self, n: u32) -> Self | [src] |
Keeps the n least significant bits only, producing a result that is greater or equal to 0.
Examples
use rug::Integer; let i = Integer::from(-1); let keep_8 = i.keep_bits(8); assert_eq!(keep_8, 0xff);
pub fn keep_bits_mut(&mut self, n: u32) | [src] |
Keeps the n least significant bits only, producing a result that is greater or equal to 0.
Examples
use rug::Integer; let mut i = Integer::from(-1); i.keep_bits_mut(8); assert_eq!(i, 0xff);
pub fn keep_bits_ref(&self, n: u32) -> KeepBitsIncomplete | [src] |
Keeps the n least significant bits only, producing a result that is greater or equal to 0.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let i = Integer::from(-1); let r = i.keep_bits_ref(8); let eight_bits = Integer::from(r); assert_eq!(eight_bits, 0xff);
pub fn keep_signed_bits(self, n: u32) -> Self | [src] |
Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.
Examples
use rug::Integer; let i = Integer::from(-1); let i_keep_8 = i.keep_signed_bits(8); assert_eq!(i_keep_8, -1); let j = Integer::from(15 << 8 | 15); let j_keep_8 = j.keep_signed_bits(8); assert_eq!(j_keep_8, 15);
pub fn keep_signed_bits_mut(&mut self, n: u32) | [src] |
Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.
Examples
use rug::Integer; let mut i = Integer::from(-1); i.keep_signed_bits_mut(8); assert_eq!(i, -1); let mut j = Integer::from(15 << 8 | 15); j.keep_signed_bits_mut(8); assert_eq!(j, 15);
pub fn keep_signed_bits_ref(&self, n: u32) -> KeepSignedBitsIncomplete | [src] |
Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let i = Integer::from(-1); let r = i.keep_signed_bits_ref(8); let eight_bits = Integer::from(r); assert_eq!(eight_bits, -1);
pub fn next_power_of_two(self) -> Self | [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);
pub 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);
pub fn next_power_of_two_ref(&self) -> NextPowerOfTwoIncomplete | [src] |
Finds the next power of two, or 1 if the number ≤ 0.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let i = Integer::from(53); let r = i.next_power_of_two_ref(); let next = Integer::from(r); assert_eq!(next, 64);
pub fn div_rem(self, divisor: Self) -> (Self, Self) | [src] |
Performs a division producing both the quotient and remainder.
The remainder has the same sign as the dividend.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let dividend = Integer::from(23); let divisor = Integer::from(-10); let (quotient, rem) = dividend.div_rem(divisor); assert_eq!(quotient, -2); assert_eq!(rem, 3);
pub fn div_rem_mut(&mut self, divisor: &mut Self) | [src] |
Performs a division producing both the quotient and remainder.
The remainder has the same sign as the dividend.
The quotient is stored in self
and the remainder is
stored in divisor
.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let mut dividend_quotient = Integer::from(-23); let mut divisor_rem = Integer::from(10); dividend_quotient.div_rem_mut(&mut divisor_rem); assert_eq!(dividend_quotient, -2); assert_eq!(divisor_rem, -3);
pub fn div_rem_ref<'a>(&'a self, divisor: &'a Self) -> DivRemIncomplete | [src] |
Performs a division producing both the quotient and remainder.
Assign<Src> for (Integer, Integer)
,
Assign<Src> for (&mut Integer, &mut Integer)
and From<Src> for (Integer, Integer)
are
implemented with the returned
incomplete-computation value as Src
.
The remainder has the same sign as the dividend.
Examples
use rug::Integer; let dividend = Integer::from(-23); let divisor = Integer::from(-10); let r = dividend.div_rem_ref(&divisor); let (quotient, rem) = <(Integer, Integer)>::from(r); assert_eq!(quotient, 2); assert_eq!(rem, -3);
pub fn div_rem_ceil(self, divisor: Self) -> (Self, Self) | [src] |
Performs a division producing both the quotient and remainder, with the quotient rounded up.
The sign of the remainder is the opposite of the divisor’s sign.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let dividend = Integer::from(23); let divisor = Integer::from(-10); let (quotient, rem) = dividend.div_rem_ceil(divisor); assert_eq!(quotient, -2); assert_eq!(rem, 3);
pub fn div_rem_ceil_mut(&mut self, divisor: &mut Self) | [src] |
Performs a division producing both the quotient and remainder, with the quotient rounded up.
The sign of the remainder is the opposite of the divisor’s sign.
The quotient is stored in self
and the remainder is
stored in divisor
.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let mut dividend_quotient = Integer::from(-23); let mut divisor_rem = Integer::from(10); dividend_quotient.div_rem_ceil_mut(&mut divisor_rem); assert_eq!(dividend_quotient, -2); assert_eq!(divisor_rem, -3);
pub fn div_rem_ceil_ref<'a>(&'a self, divisor: &'a Self) -> DivRemCeilIncomplete | [src] |
Performs a division producing both the quotient and remainder, with the quotient rounded up.
The sign of the remainder is the opposite of the divisor’s sign.
Assign<Src> for (Integer, Integer)
,
Assign<Src> for (&mut Integer, &mut Integer)
and From<Src> for (Integer, Integer)
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Integer; let dividend = Integer::from(-23); let divisor = Integer::from(-10); let r = dividend.div_rem_ceil_ref(&divisor); let (quotient, rem) = <(Integer, Integer)>::from(r); assert_eq!(quotient, 3); assert_eq!(rem, 7);
pub fn div_rem_floor(self, divisor: Self) -> (Self, Self) | [src] |
Performs a division producing both the quotient and remainder, with the quotient rounded down.
The remainder has the same sign as the divisor.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let dividend = Integer::from(23); let divisor = Integer::from(-10); let (quotient, rem) = dividend.div_rem_floor(divisor); assert_eq!(quotient, -3); assert_eq!(rem, -7);
pub fn div_rem_floor_mut(&mut self, divisor: &mut Self) | [src] |
Performs a division producing both the quotient and remainder, with the quotient rounded down.
The remainder has the same sign as the divisor.
The quotient is stored in self
and the remainder is
stored in divisor
.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let mut dividend_quotient = Integer::from(-23); let mut divisor_rem = Integer::from(10); dividend_quotient.div_rem_floor_mut(&mut divisor_rem); assert_eq!(dividend_quotient, -3); assert_eq!(divisor_rem, 7);
pub fn div_rem_floor_ref<'a>( | [src] |
Performs a division producing both the quotient and remainder, with the quotient rounded down.
The remainder has the same sign as the divisor.
Assign<Src> for (Integer, Integer)
,
Assign<Src> for (&mut Integer, &mut Integer)
and From<Src> for (Integer, Integer)
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Integer; let dividend = Integer::from(-23); let divisor = Integer::from(-10); let r = dividend.div_rem_floor_ref(&divisor); let (quotient, rem) = <(Integer, Integer)>::from(r); assert_eq!(quotient, 2); assert_eq!(rem, -3);
pub fn div_rem_round(self, divisor: Self) -> (Self, Self) | [src] |
Performs a division producing both the quotient and remainder, with the quotient rounded to the nearest integer.
When the quotient before rounding lies exactly between two integers, it is rounded away from zero.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; // 23 / −10 → −2 rem 3 let (q, rem) = Integer::from(23).div_rem_round((-10).into()); assert!(q == -2 && rem == 3); // 25 / 10 → 3 rem −5 let (q, rem) = Integer::from(25).div_rem_round(10.into()); assert!(q == 3 && rem == -5); // −27 / 10 → −3 rem 3 let (q, rem) = Integer::from(-27).div_rem_round(10.into()); assert!(q == -3 && rem == 3);
pub fn div_rem_round_mut(&mut self, divisor: &mut Self) | [src] |
Performs a division producing both the quotient and remainder, with the quotient rounded to the nearest integer.
When the quotient before rounding lies exactly between two integers, it is rounded away from zero.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; // −25 / −10 → 3 rem 5 let mut dividend_quotient = Integer::from(-25); let mut divisor_rem = Integer::from(-10); dividend_quotient.div_rem_round_mut(&mut divisor_rem); assert_eq!(dividend_quotient, 3); assert_eq!(divisor_rem, 5);
pub fn div_rem_round_ref<'a>( | [src] |
Performs a division producing both the quotient and remainder, with the quotient rounded to the nearest integer.
When the quotient before rounding lies exactly between two integers, it is rounded away from zero.
Assign<Src> for (Integer, Integer)
,
Assign<Src> for (&mut Integer, &mut Integer)
and From<Src> for (Integer, Integer)
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Integer; // −28 / −10 → 3 rem 2 let dividend = Integer::from(-28); let divisor = Integer::from(-10); let r = dividend.div_rem_round_ref(&divisor); let (quotient, rem) = <(Integer, Integer)>::from(r); assert_eq!(quotient, 3); assert_eq!(rem, 2);
pub fn div_rem_euc(self, divisor: Self) -> (Self, Self) | [src] |
Performs Euclidean division producing both the quotient and remainder, with a positive remainder.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let dividend = Integer::from(23); let divisor = Integer::from(-10); let (quotient, rem) = dividend.div_rem_euc(divisor); assert_eq!(quotient, -2); assert_eq!(rem, 3);
pub fn div_rem_euc_mut(&mut self, divisor: &mut Self) | [src] |
Performs Euclidean division producing both the quotient and remainder, with a positive remainder.
The quotient is stored in self
and the remainder is
stored in divisor
.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let mut dividend_quotient = Integer::from(-23); let mut divisor_rem = Integer::from(10); dividend_quotient.div_rem_euc_mut(&mut divisor_rem); assert_eq!(dividend_quotient, -3); assert_eq!(divisor_rem, 7);
pub fn div_rem_euc_ref<'a>(&'a self, divisor: &'a Self) -> DivRemEucIncomplete | [src] |
Performs Euclidan division producing both the quotient and remainder, with a positive remainder.
Assign<Src> for (Integer, Integer)
,
Assign<Src> for (&mut Integer, &mut Integer)
and From<Src> for (Integer, Integer)
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::Integer; let dividend = Integer::from(-23); let divisor = Integer::from(-10); let r = dividend.div_rem_euc_ref(&divisor); let (quotient, rem) = <(Integer, Integer)>::from(r); assert_eq!(quotient, 3); assert_eq!(rem, 7);
pub fn mod_u(&self, modulo: u32) -> u32 | [src] |
Returns the modulo, or the remainder of Euclidean division by
a u32
.
The result is always zero or positive.
Panics
Panics if modulo
is zero.
Examples
use rug::Integer; let pos = Integer::from(23); assert_eq!(pos.mod_u(1), 0); assert_eq!(pos.mod_u(10), 3); assert_eq!(pos.mod_u(100), 23); let neg = Integer::from(-23); assert_eq!(neg.mod_u(1), 0); assert_eq!(neg.mod_u(10), 7); assert_eq!(neg.mod_u(100), 77);
pub fn div_exact(self, divisor: &Self) -> Self | [src] |
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let i = Integer::from(12345 * 54321); let quotient = i.div_exact(&Integer::from(12345)); assert_eq!(quotient, 54321);
pub fn div_exact_mut(&mut self, divisor: &Self) | [src] |
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let mut i = Integer::from(12345 * 54321); i.div_exact_mut(&Integer::from(12345)); assert_eq!(i, 54321);
pub fn div_exact_ref<'a>(&'a self, divisor: &'a Self) -> DivExactIncomplete | [src] |
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let i = Integer::from(12345 * 54321); let divisor = Integer::from(12345); let r = i.div_exact_ref(&divisor); let quotient = Integer::from(r); assert_eq!(quotient, 54321);
pub fn div_exact_u(self, divisor: u32) -> Self | [src] |
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let i = Integer::from(12345 * 54321); let q = i.div_exact_u(12345); assert_eq!(q, 54321);
pub fn div_exact_u_mut(&mut self, divisor: u32) | [src] |
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer; let mut i = Integer::from(12345 * 54321); i.div_exact_u_mut(12345); assert_eq!(i, 54321);
pub fn div_exact_u_ref(&self, divisor: u32) -> DivExactUIncomplete | [src] |
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let i = Integer::from(12345 * 54321); let r = i.div_exact_u_ref(12345); assert_eq!(Integer::from(r), 54321);
pub fn invert(self, modulo: &Self) -> Result<Self, Self> | [src] |
Finds the inverse modulo modulo
and returns
Ok(inverse)
if it exists, or
Err(unchanged)
if the inverse does not exist.
The inverse exists if the modulo is not zero, and self
and
the modulo are co-prime, that is their GCD is 1.
Examples
use rug::Integer; let n = Integer::from(2); // Modulo 4, 2 has no inverse: there is no i such that 2 × i = 1. let inv_mod_4 = match n.invert(&Integer::from(4)) { Ok(_) => unreachable!(), Err(unchanged) => unchanged, }; // no inverse exists, so value is unchanged assert_eq!(inv_mod_4, 2); let n = inv_mod_4; // Modulo 5, the inverse of 2 is 3, as 2 × 3 = 1. let inv_mod_5 = match n.invert(&Integer::from(5)) { Ok(inverse) => inverse, Err(_) => unreachable!(), }; assert_eq!(inv_mod_5, 3);
pub fn invert_mut(&mut self, modulo: &Self) -> Result<(), ()> | [src] |
Finds the inverse modulo modulo
if an inverse exists.
The inverse exists if the modulo is not zero, and self
and
the modulo are co-prime, that is their GCD is 1.
Examples
use rug::Integer; let mut n = Integer::from(2); // Modulo 4, 2 has no inverse: there is no i such that 2 × i = 1. match n.invert_mut(&Integer::from(4)) { Ok(()) => unreachable!(), Err(()) => assert_eq!(n, 2), } // Modulo 5, the inverse of 2 is 3, as 2 × 3 = 1. match n.invert_mut(&Integer::from(5)) { Ok(()) => assert_eq!(n, 3), Err(()) => unreachable!(), }
pub fn invert_ref<'a>( | [src] |
Finds the inverse modulo modulo
if an inverse exists.
The inverse exists if the modulo is not zero, and self
and
the modulo are co-prime, that is their GCD is 1.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
unwrapped returned incomplete-computation value as
Src
.
Examples
use rug::Integer; let two = Integer::from(2); let four = Integer::from(4); let five = Integer::from(5); // Modulo 4, 2 has no inverse, there is no i such that 2 × i = 1. // For this conversion, if no inverse exists, the Integer // created is left unchanged as 0. assert!(two.invert_ref(&four).is_none()); // Modulo 5, the inverse of 2 is 3, as 2 × 3 = 1. let r = two.invert_ref(&five).unwrap(); let inverse = Integer::from(r); assert_eq!(inverse, 3);
pub fn pow_mod(self, exponent: &Self, modulo: &Self) -> Result<Self, Self> | [src] |
Raises a number to the power of exponent
modulo modulo
and
returns Ok(power)
if an answer exists, or
Err(unchanged)
if it does not.
If the exponent is negative, then the number must have an inverse for an answer to exist.
When the exponent is positive and the modulo is not zero, an answer always exists.
Examples
use rug::Integer; // 7 ^ 5 = 16807 let n = Integer::from(7); let e = Integer::from(5); let m = Integer::from(1000); let power = match n.pow_mod(&e, &m) { Ok(power) => power, Err(_) => unreachable!(), }; assert_eq!(power, 807);
When the exponent is negative, an answer exists if an inverse exists.
use rug::Integer; // 7 × 143 modulo 1000 = 1, so 7 has an inverse 143. // 7 ^ −5 modulo 1000 = 143 ^ 5 modulo 1000 = 943. let n = Integer::from(7); let e = Integer::from(-5); let m = Integer::from(1000); let power = match n.pow_mod(&e, &m) { Ok(power) => power, Err(_) => unreachable!(), }; assert_eq!(power, 943);
pub fn pow_mod_mut(&mut self, exponent: &Self, modulo: &Self) -> Result<(), ()> | [src] |
Raises a number to the power of exponent
modulo modulo
if
an answer exists.
If the exponent is negative, then the number must have an inverse for an answer to exist.
Examples
use rug::{Assign, Integer}; // Modulo 1000, 2 has no inverse: there is no i such that 2 × i = 1. let mut n = Integer::from(2); let e = Integer::from(-5); let m = Integer::from(1000); match n.pow_mod_mut(&e, &m) { Ok(()) => unreachable!(), Err(()) => assert_eq!(n, 2), } // 7 × 143 modulo 1000 = 1, so 7 has an inverse 143. // 7 ^ −5 modulo 1000 = 143 ^ 5 modulo 1000 = 943. n.assign(7); match n.pow_mod_mut(&e, &m) { Ok(()) => assert_eq!(n, 943), Err(()) => unreachable!(), }
pub fn pow_mod_ref<'a>( | [src] |
Raises a number to the power of exponent
modulo modulo
if
an answer exists.
If the exponent is negative, then the number must have an inverse for an answer to exist.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
unwrapped returned incomplete-computation value as
Src
.
Examples
use rug::Integer; let two = Integer::from(2); let thousand = Integer::from(1000); let minus_five = Integer::from(-5); let seven = Integer::from(7); // Modulo 1000, 2 has no inverse: there is no i such that 2 × i = 1. assert!(two.pow_mod_ref(&minus_five, &thousand).is_none()); // 7 × 143 modulo 1000 = 1, so 7 has an inverse 143. // 7 ^ −5 modulo 1000 = 143 ^ 5 modulo 1000 = 943. let r = seven.pow_mod_ref(&minus_five, &thousand).unwrap(); let power = Integer::from(r); assert_eq!(power, 943);
pub fn secure_pow_mod(self, exponent: &Self, modulo: &Self) -> Self | [src] |
Raises a number to the power of exponent
modulo modulo
,
with resilience to side-channel attacks.
The exponent must be greater than zero, and the modulo must be odd.
This method is intended for cryptographic purposes where resilience to side-channel attacks is desired. The function is designed to take the same time and use the same cache access patterns for same-sized arguments, assuming that the arguments are placed at the same position and the machine state is identical when starting.
Panics
Panics if exponent
≤ 0 or if modulo
is even.
Examples
use rug::Integer; // 7 ^ 4 mod 13 = 9 let n = Integer::from(7); let e = Integer::from(4); let m = Integer::from(13); let power = n.secure_pow_mod(&e, &m); assert_eq!(power, 9);
pub fn secure_pow_mod_mut(&mut self, exponent: &Self, modulo: &Self) | [src] |
Raises a number to the power of exponent
modulo modulo
,
with resilience to side-channel attacks.
The exponent must be greater than zero, and the modulo must be odd.
This method is intended for cryptographic purposes where resilience to side-channel attacks is desired. The function is designed to take the same time and use the same cache access patterns for same-sized arguments, assuming that the arguments are placed at the same position and the machine state is identical when starting.
Panics
Panics if exponent
≤ 0 or if modulo
is even.
Examples
use rug::Integer; // 7 ^ 4 mod 13 = 9 let mut n = Integer::from(7); let e = Integer::from(4); let m = Integer::from(13); n.secure_pow_mod_mut(&e, &m); assert_eq!(n, 9);
pub fn secure_pow_mod_ref<'a>( | [src] |
Raises a number to the power of exponent
modulo modulo
,
with resilience to side-channel attacks.
The exponent must be greater than zero, and the modulo must be odd.
This method is intended for cryptographic purposes where resilience to side-channel attacks is desired. The function is designed to take the same time and use the same cache access patterns for same-sized arguments, assuming that the arguments are placed at the same position and the machine state is identical when starting.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Panics
Panics if exponent
≤ 0 or if modulo
is even.
Examples
use rug::Integer; // 7 ^ 4 mod 13 = 9 let n = Integer::from(7); let e = Integer::from(4); let m = Integer::from(13); let power = Integer::from(n.secure_pow_mod_ref(&e, &m)); assert_eq!(power, 9);
pub fn u_pow_u(base: u32, exponent: u32) -> UPowUIncomplete | [src] |
Raises base
to the power of exponent
.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let p = Integer::u_pow_u(13, 12); let i = Integer::from(p); assert_eq!(i, 13_u64.pow(12));
pub fn i_pow_u(base: i32, exponent: u32) -> IPowUIncomplete | [src] |
Raises base
to the power of exponent
.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let p1 = Integer::i_pow_u(-13, 13); let i1 = Integer::from(p1); assert_eq!(i1, (-13_i64).pow(13)); let p2 = Integer::i_pow_u(13, 13); let i2 = Integer::from(p2); assert_eq!(i2, (13_i64).pow(13));
pub fn root(self, n: u32) -> Self | [src] |
Computes the nth root and truncates the result.
Panics
Panics if n is even and the value is negative.
Examples
use rug::Integer; let i = Integer::from(1004); let root = i.root(3); assert_eq!(root, 10);
pub fn root_mut(&mut self, n: u32) | [src] |
Computes the nth root and truncates the result.
Panics
Panics if n is even and the value is negative.
Examples
use rug::Integer; let mut i = Integer::from(1004); i.root_mut(3); assert_eq!(i, 10);
pub fn root_ref(&self, n: u32) -> RootIncomplete | [src] |
Computes the nth root and truncates the result.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let i = Integer::from(1004); assert_eq!(Integer::from(i.root_ref(3)), 10);
pub fn root_rem(self, remainder: Self, n: u32) -> (Self, Self) | [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.
Panics
Panics if n is even and the value is negative.
Examples
use rug::Integer; let i = Integer::from(1004); let (root, rem) = i.root_rem(Integer::new(), 3); assert_eq!(root, 10); assert_eq!(rem, 4);
pub fn root_rem_mut(&mut self, remainder: &mut Self, n: u32) | [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.
Panics
Panics if n is even and the value is negative.
Examples
use rug::Integer; let mut i = Integer::from(1004); let mut rem = Integer::new(); i.root_rem_mut(&mut rem, 3); assert_eq!(i, 10); assert_eq!(rem, 4);
pub fn root_rem_ref(&self, n: u32) -> RootRemIncomplete | [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.
Assign<Src> for (Integer, Integer)
,
Assign<Src> for (&mut Integer, &mut Integer)
and From<Src> for (Integer, Integer)
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::{Assign, Integer}; let i = Integer::from(1004); let mut root = Integer::new(); let mut rem = Integer::new(); let r = i.root_rem_ref(3); (&mut root, &mut rem).assign(r); assert_eq!(root, 10); assert_eq!(rem, 4); let r = i.root_rem_ref(3); let (other_root, other_rem) = <(Integer, Integer)>::from(r); assert_eq!(other_root, 10); assert_eq!(other_rem, 4);
pub fn square(self) -> Self | [src] |
Computes the square.
Examples
use rug::Integer; let i = Integer::from(13); let square = i.square(); assert_eq!(square, 169);
pub fn square_mut(&mut self) | [src] |
Computes the square.
Examples
use rug::Integer; let mut i = Integer::from(13); i.square_mut(); assert_eq!(i, 169);
pub fn square_ref(&self) -> SquareIncomplete | [src] |
Computes the square.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let i = Integer::from(13); assert_eq!(Integer::from(i.square_ref()), 169);
pub fn sqrt(self) -> Self | [src] |
Computes the square root and truncates the result.
Panics
Panics if the value is negative.
Examples
use rug::Integer; let i = Integer::from(104); let sqrt = i.sqrt(); assert_eq!(sqrt, 10);
pub fn sqrt_mut(&mut self) | [src] |
Computes the square root and truncates the result.
Panics
Panics if the value is negative.
Examples
use rug::Integer; let mut i = Integer::from(104); i.sqrt_mut(); assert_eq!(i, 10);
pub fn sqrt_ref(&self) -> SqrtIncomplete | [src] |
Computes the square root and truncates the result.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let i = Integer::from(104); assert_eq!(Integer::from(i.sqrt_ref()), 10);
pub fn sqrt_rem(self, remainder: Self) -> (Self, Self) | [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.
Panics
Panics if the value is negative.
Examples
use rug::Integer; let i = Integer::from(104); let (sqrt, rem) = i.sqrt_rem(Integer::new()); assert_eq!(sqrt, 10); assert_eq!(rem, 4);
pub fn sqrt_rem_mut(&mut self, remainder: &mut Self) | [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.
Panics
Panics if the value is negative.
Examples
use rug::Integer; let mut i = Integer::from(104); let mut rem = Integer::new(); i.sqrt_rem_mut(&mut rem); assert_eq!(i, 10); assert_eq!(rem, 4);
pub fn sqrt_rem_ref(&self) -> SqrtRemIncomplete | [src] |
Computes the square root and the remainder.
The remainder is the original number minus the truncated root squared.
Assign<Src> for (Integer, Integer)
,
Assign<Src> for (&mut Integer, &mut Integer)
and From<Src> for (Integer, Integer)
are
implemented with the returned
incomplete-computation value as Src
.
Examples
use rug::{Assign, Integer}; let i = Integer::from(104); let mut sqrt = Integer::new(); let mut rem = Integer::new(); let r = i.sqrt_rem_ref(); (&mut sqrt, &mut rem).assign(r); assert_eq!(sqrt, 10); assert_eq!(rem, 4); let r = i.sqrt_rem_ref(); let (other_sqrt, other_rem) = <(Integer, Integer)>::from(r); assert_eq!(other_sqrt, 10); assert_eq!(other_rem, 4);
pub fn is_probably_prime(&self, reps: u32) -> IsPrime | [src] |
Determines wheter a number is prime using some trial
divisions, then reps
Miller-Rabin probabilistic primality
tests.
Examples
use rug::integer::IsPrime; use rug::Integer; let no = Integer::from(163 * 4003); assert_eq!(no.is_probably_prime(15), IsPrime::No); let yes = Integer::from(21_751); assert_eq!(yes.is_probably_prime(15), IsPrime::Yes); // 817_504_243 is actually a prime. let probably = Integer::from(817_504_243); assert_eq!(probably.is_probably_prime(15), IsPrime::Probably);
pub fn next_prime(self) -> Self | [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);
pub 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);
pub fn next_prime_ref(&self) -> NextPrimeIncomplete | [src] |
Identifies primes using a probabilistic algorithm; the chance of a composite passing will be extremely small.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let i = Integer::from(800_000_000); let r = i.next_prime_ref(); let prime = Integer::from(r); assert_eq!(prime, 800_000_011);
pub fn gcd(self, other: &Self) -> Self | [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);
pub fn gcd_mut(&mut self, other: &Self) | [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);
pub fn gcd_ref<'a>(&'a self, other: &'a Self) -> GcdIncomplete | [src] |
Finds the greatest common divisor.
The result is always positive except when both inputs are zero.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let a = Integer::from(100); let b = Integer::from(125); let r = a.gcd_ref(&b); // gcd of 100, 125 is 25 assert_eq!(Integer::from(r), 25);
pub fn gcd_cofactors(self, other: Self, rop: Self) -> (Self, Self, Self) | [src] |
Finds the greatest common divisor (GCD) of the two inputs
(self
and other
), and two cofactors to obtain the GCD
from the two inputs.
The GCD is always positive except when both inputs are zero. If the inputs are a and b, then the GCD is g and the cofactors are s and t such that
a × s + b × t = g
The values s and t are chosen such that normally, |s| < |b| / (2g) and |t| < |a| / (2g), and these relations define s and t uniquely. There are a few exceptional cases:
- If |a| = |b|, then s = 0, t = sgn(b).
- Otherwise, if b = 0 or |b| = 2g, then s = sgn(a), and if a = 0 or |a| = 2g, then t = sgn(b).
Examples
use rug::Integer; let a = Integer::from(4); let b = Integer::from(6); let (g, s, t) = a.gcd_cofactors(b, Integer::new()); assert_eq!(g, 2); assert_eq!(s, -1); assert_eq!(t, 1);
pub fn gcd_cofactors_mut(&mut self, other: &mut Self, rop: &mut Self) | [src] |
Finds the greatest common divisor (GCD) of the two inputs
(self
and other
), and two cofactors to obtain the GCD
from the two inputs.
The GCD is stored in self
, and the two cofactors are
stored in other
and rop
.
The GCD is always positive except when both inputs are zero. If the inputs are a and b, then the GCD is g and the cofactors are s and t such that
a × s + b × t = g
The values s and t are chosen such that normally, |s| < |b| / (2g) and |t| < |a| / (2g), and these relations define s and t uniquely. There are a few exceptional cases:
- If |a| = |b|, then s = 0, t = sgn(b).
- Otherwise, if b = 0 or |b| = 2g, then s = sgn(a), and if a = 0 or |a| = 2g, then t = sgn(b).
Examples
use rug::Integer; let mut a_g = Integer::from(4); let mut b_s = Integer::from(6); let mut t = Integer::new(); a_g.gcd_cofactors_mut(&mut b_s, &mut t); assert_eq!(a_g, 2); assert_eq!(b_s, -1); assert_eq!(t, 1);
pub fn gcd_cofactors_ref<'a>(&'a self, other: &'a Self) -> GcdIncomplete | [src] |
Finds the greatest common divisor (GCD) of the two inputs
(self
and other
), and two cofactors to obtain the GCD
from the two inputs.
Assign<Src> for (Integer, Integer, Integer)
,
Assign<Src> for (&mut Integer, &mut Integer, &mut Integer)
and From<Src> for (Integer, Integer, Integer)
are implemented with the returned
incomplete-computation value as Src
.
In the case that only one of the two cofactors is
required, Assign<Src> for (Integer, Integer)
,
Assign<Src> for (&mut Integer, &mut Integer)
and
From<Src> for (Integer, Integer)
are also
implemented with the returned
incomplete-computation value as Src
.
The GCD is always positive except when both inputs are zero. If the inputs are a and b, then the GCD is g and the cofactors are s and t such that
a × s + b × t = g
The values s and t are chosen such that normally, |s| < |b| / (2g) and |t| < |a| / (2g), and these relations define s and t uniquely. There are a few exceptional cases:
- If |a| = |b|, then s = 0, t = sgn(b).
- Otherwise, if b = 0 or |b| = 2g, then s = sgn(a), and if a = 0 or |a| = 2g, then t = sgn(b).
Examples
use rug::{Assign, Integer}; let a = Integer::from(4); let b = Integer::from(6); let r = a.gcd_cofactors_ref(&b); let mut g = Integer::new(); let mut s = Integer::new(); let mut t = Integer::new(); (&mut g, &mut s, &mut t).assign(r); assert_eq!(a, 4); assert_eq!(b, 6); assert_eq!(g, 2); assert_eq!(s, -1); assert_eq!(t, 1);
In the case that only one of the two cofactors is required, this can be achieved as follows:
use rug::{Assign, Integer}; let a = Integer::from(4); let b = Integer::from(6); // no t required let (mut g1, mut s1) = (Integer::new(), Integer::new()); (&mut g1, &mut s1).assign(a.gcd_cofactors_ref(&b)); assert_eq!(g1, 2); assert_eq!(s1, -1); // no s required let (mut g2, mut t2) = (Integer::new(), Integer::new()); (&mut g2, &mut t2).assign(b.gcd_cofactors_ref(&a)); assert_eq!(g2, 2); assert_eq!(t2, 1);
pub fn lcm(self, other: &Self) -> Self | [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);
pub fn lcm_mut(&mut self, other: &Self) | [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);
pub fn lcm_ref<'a>(&'a self, other: &'a Self) -> LcmIncomplete | [src] |
Finds the least common multiple.
The result is always positive except when one or both inputs are zero.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; let a = Integer::from(100); let b = Integer::from(125); let r = a.lcm_ref(&b); // lcm of 100, 125 is 500 assert_eq!(Integer::from(r), 500);
pub fn jacobi(&self, n: &Self) -> i32 | [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);
pub fn legendre(&self, p: &Self) -> 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);
pub fn kronecker(&self, n: &Self) -> 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);
pub fn remove_factor(self, factor: &Self) -> (Self, u32) | [src] |
Removes all occurrences of factor
, and returns the number of
occurrences removed.
Examples
use rug::Integer; let mut i = Integer::from(Integer::u_pow_u(13, 50)); i *= 1000; let (remove, count) = i.remove_factor(&Integer::from(13)); assert_eq!(remove, 1000); assert_eq!(count, 50);
pub fn remove_factor_mut(&mut self, factor: &Self) -> u32 | [src] |
Removes all occurrences of factor
, and returns the number of
occurrences removed.
Examples
use rug::Integer; let mut i = Integer::from(Integer::u_pow_u(13, 50)); i *= 1000; let count = i.remove_factor_mut(&Integer::from(13)); assert_eq!(i, 1000); assert_eq!(count, 50);
pub fn remove_factor_ref<'a>( | [src] |
Removes all occurrences of factor
, and counts the number of
occurrences removed.
Examples
use rug::{Assign, Integer}; let mut i = Integer::from(Integer::u_pow_u(13, 50)); i *= 1000; let factor = Integer::from(13); let r = i.remove_factor_ref(&factor); let (mut j, mut count) = (Integer::new(), 0); (&mut j, &mut count).assign(r); assert_eq!(count, 50); assert_eq!(j, 1000);
pub fn factorial(n: u32) -> FactorialIncomplete | [src] |
Computes the factorial of n.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; // 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1 let f = Integer::factorial(10); let i = Integer::from(f); assert_eq!(i, 3628800);
pub fn factorial_2(n: u32) -> Factorial2Incomplete | [src] |
Computes the double factorial of n.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; // 10 × 8 × 6 × 4 × 2 let f = Integer::factorial_2(10); let i = Integer::from(f); assert_eq!(i, 3840);
pub fn factorial_m(n: u32, m: u32) -> FactorialMIncomplete | [src] |
Computes the m-multi factorial of n.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; // 10 × 7 × 4 × 1 let f = Integer::factorial_m(10, 3); let i = Integer::from(f); assert_eq!(i, 280);
pub fn primorial(n: u32) -> PrimorialIncomplete | [src] |
Computes the primorial of n.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; // 7 × 5 × 3 × 2 let p = Integer::primorial(10); let i = Integer::from(p); assert_eq!(i, 210);
pub fn binomial(self, k: u32) -> Self | [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);
pub 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);
pub fn binomial_ref(&self, k: u32) -> BinomialIncomplete | [src] |
Computes the binomial coefficient over k.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; // 7 choose 2 is 21 let i = Integer::from(7); assert_eq!(Integer::from(i.binomial_ref(2)), 21);
pub fn binomial_u(n: u32, k: u32) -> BinomialUIncomplete | [src] |
Computes the binomial coefficient n over k.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::Integer; // 7 choose 2 is 21 let b = Integer::binomial_u(7, 2); let i = Integer::from(b); assert_eq!(i, 21);
pub fn fibonacci(n: u32) -> FibonacciIncomplete | [src] |
Computes the Fibonacci number.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
This function is meant for an isolated number. If a
sequence of Fibonacci numbers is required, the first two
values of the sequence should be computed with the
fibonacci_2
method, then iterations should be used.
Examples
use rug::Integer; let f = Integer::fibonacci(12); let i = Integer::from(f); assert_eq!(i, 144);
pub fn fibonacci_2(n: u32) -> FibonacciIncomplete | [src] |
Computes a Fibonacci number, and the previous Fibonacci number.
Assign<Src> for (Integer, Integer)
,
Assign<Src> for (&mut Integer, &mut Integer)
and From<Src> for (Integer, Integer)
are
implemented with the returned
incomplete-computation value as Src
.
This function is meant to calculate isolated numbers. If a sequence of Fibonacci numbers is required, the first two values of the sequence should be computed with this function, then iterations should be used.
Examples
use rug::{Assign, Integer}; let f = Integer::fibonacci_2(12); let mut pair = <(Integer, Integer)>::from(f); assert_eq!(pair.0, 144); assert_eq!(pair.1, 89); // Fibonacci number F[−1] is 1 pair.assign(Integer::fibonacci_2(0)); assert_eq!(pair.0, 0); assert_eq!(pair.1, 1);
pub fn lucas(n: u32) -> LucasIncomplete | [src] |
Computes the Lucas number.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
This function is meant for an isolated number. If a
sequence of Lucas numbers is required, the first two
values of the sequence should be computed with the
lucas_2
method, then iterations should be used.
Examples
use rug::Integer; let l = Integer::lucas(12); let i = Integer::from(l); assert_eq!(i, 322);
pub fn lucas_2(n: u32) -> LucasIncomplete | [src] |
Computes a Lucas number, and the previous Lucas number.
Assign<Src> for (Integer, Integer)
,
Assign<Src> for (&mut Integer, &mut Integer)
and From<Src> for (Integer, Integer)
are
implemented with the returned
incomplete-computation value as Src
.
This function is meant to calculate isolated numbers. If a sequence of Lucas numbers is required, the first two values of the sequence should be computed with this function, then iterations should be used.
Examples
use rug::{Assign, Integer}; let l = Integer::lucas_2(12); let mut pair = <(Integer, Integer)>::from(l); assert_eq!(pair.0, 322); assert_eq!(pair.1, 199); pair.assign(Integer::lucas_2(0)); assert_eq!(pair.0, 2); assert_eq!(pair.1, -1);
pub fn random_bits<'a, 'b>( | [src] |
Generates a random number with a specified maximum number of bits.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Examples
use rug::rand::RandState; use rug::{Assign, Integer}; let mut rand = RandState::new(); let mut i = Integer::from(Integer::random_bits(0, &mut rand)); assert_eq!(i, 0); i.assign(Integer::random_bits(80, &mut rand)); assert!(i.significant_bits() <= 80);
pub fn random_below(self, rng: &mut RandState) -> Self | [src] |
Generates a non-negative random number below the given boundary value.
Panics
Panics if the boundary value is less than or equal to zero.
Examples
use rug::rand::RandState; use rug::Integer; let mut rand = RandState::new(); let i = Integer::from(15); let below = i.random_below(&mut rand); println!("0 ≤ {} < 15", below); assert!(below < 15);
pub fn random_below_mut(&mut self, rng: &mut RandState) | [src] |
Generates a non-negative random number below the given boundary value.
Panics
Panics if the boundary value is less than or equal to zero.
Examples
use rug::rand::RandState; use rug::Integer; let mut rand = RandState::new(); let mut i = Integer::from(15); i.random_below_mut(&mut rand); println!("0 ≤ {} < 15", i); assert!(i < 15);
pub fn random_below_ref<'a, 'b>( | [src] |
Generates a non-negative random number below the given boundary value.
Assign<Src> for Integer
and
From<Src> for Integer
are implemented with the
returned incomplete-computation value as Src
.
Panics
Panics if the boundary value is less than or equal to zero.
Examples
use rug::rand::RandState; use rug::Integer; let mut rand = RandState::new(); let bound = Integer::from(15); let i = Integer::from(bound.random_below_ref(&mut rand)); println!("0 ≤ {} < {}", i, bound); assert!(i < bound);
Trait Implementations
impl NegAssign for Integer
[src]
impl NegAssign for Integer
fn neg_assign(&mut self) | [src] |
impl NotAssign for Integer
[src]
impl NotAssign for Integer
fn not_assign(&mut self) | [src] |
impl AddFrom<Integer> for Integer
[src]
impl AddFrom<Integer> for Integer
impl<'a> AddFrom<&'a Integer> for Integer
[src]
impl<'a> AddFrom<&'a Integer> for Integer
impl AddFrom<i32> for Integer
[src]
impl AddFrom<i32> for Integer
impl<'t> AddFrom<&'t i32> for Integer
[src]
impl<'t> AddFrom<&'t i32> for Integer
impl AddFrom<u32> for Integer
[src]
impl AddFrom<u32> for Integer
impl<'t> AddFrom<&'t u32> for Integer
[src]
impl<'t> AddFrom<&'t u32> for Integer
impl AddFrom<Integer> for Float
[src]
impl AddFrom<Integer> for Float
impl<'a> AddFrom<&'a Integer> for Float
[src]
impl<'a> AddFrom<&'a Integer> for Float
impl AddFrom<Integer> for Complex
[src]
impl AddFrom<Integer> for Complex
impl<'a> AddFrom<&'a Integer> for Complex
[src]
impl<'a> AddFrom<&'a Integer> for Complex
impl SubFrom<Integer> for Integer
[src]
impl SubFrom<Integer> for Integer
impl<'a> SubFrom<&'a Integer> for Integer
[src]
impl<'a> SubFrom<&'a Integer> for Integer
impl SubFrom<i32> for Integer
[src]
impl SubFrom<i32> for Integer
impl<'t> SubFrom<&'t i32> for Integer
[src]
impl<'t> SubFrom<&'t i32> for Integer
impl SubFrom<u32> for Integer
[src]
impl SubFrom<u32> for Integer
impl<'t> SubFrom<&'t u32> for Integer
[src]
impl<'t> SubFrom<&'t u32> for Integer
impl SubFrom<Integer> for Float
[src]
impl SubFrom<Integer> for Float
impl<'a> SubFrom<&'a Integer> for Float
[src]
impl<'a> SubFrom<&'a Integer> for Float
impl SubFrom<Integer> for Complex
[src]
impl SubFrom<Integer> for Complex
impl<'a> SubFrom<&'a Integer> for Complex
[src]
impl<'a> SubFrom<&'a Integer> for Complex
impl MulFrom<Integer> for Integer
[src]
impl MulFrom<Integer> for Integer
impl<'a> MulFrom<&'a Integer> for Integer
[src]
impl<'a> MulFrom<&'a Integer> for Integer
impl MulFrom<i32> for Integer
[src]
impl MulFrom<i32> for Integer
impl<'t> MulFrom<&'t i32> for Integer
[src]
impl<'t> MulFrom<&'t i32> for Integer
impl MulFrom<u32> for Integer
[src]
impl MulFrom<u32> for Integer
impl<'t> MulFrom<&'t u32> for Integer
[src]
impl<'t> MulFrom<&'t u32> for Integer
impl MulFrom<Integer> for Float
[src]
impl MulFrom<Integer> for Float
impl<'a> MulFrom<&'a Integer> for Float
[src]
impl<'a> MulFrom<&'a Integer> for Float
impl MulFrom<Integer> for Complex
[src]
impl MulFrom<Integer> for Complex
impl<'a> MulFrom<&'a Integer> for Complex
[src]
impl<'a> MulFrom<&'a Integer> for Complex
impl DivFrom<Integer> for Integer
[src]
impl DivFrom<Integer> for Integer
impl<'a> DivFrom<&'a Integer> for Integer
[src]
impl<'a> DivFrom<&'a Integer> for Integer
impl DivFrom<i32> for Integer
[src]
impl DivFrom<i32> for Integer
impl<'t> DivFrom<&'t i32> for Integer
[src]
impl<'t> DivFrom<&'t i32> for Integer
impl DivFrom<u32> for Integer
[src]
impl DivFrom<u32> for Integer
impl<'t> DivFrom<&'t u32> for Integer
[src]
impl<'t> DivFrom<&'t u32> for Integer
impl DivFrom<Integer> for Float
[src]
impl DivFrom<Integer> for Float
impl<'a> DivFrom<&'a Integer> for Float
[src]
impl<'a> DivFrom<&'a Integer> for Float
impl RemFrom<Integer> for Integer
[src]
impl RemFrom<Integer> for Integer
impl<'a> RemFrom<&'a Integer> for Integer
[src]
impl<'a> RemFrom<&'a Integer> for Integer
impl RemFrom<i32> for Integer
[src]
impl RemFrom<i32> for Integer
impl<'t> RemFrom<&'t i32> for Integer
[src]
impl<'t> RemFrom<&'t i32> for Integer
impl RemFrom<u32> for Integer
[src]
impl RemFrom<u32> for Integer
impl<'t> RemFrom<&'t u32> for Integer
[src]
impl<'t> RemFrom<&'t u32> for Integer
impl BitAndFrom<Integer> for Integer
[src]
impl BitAndFrom<Integer> for Integer
fn bitand_from(&mut self, lhs: Integer) | [src] |
impl<'a> BitAndFrom<&'a Integer> for Integer
[src]
impl<'a> BitAndFrom<&'a Integer> for Integer
fn bitand_from(&mut self, lhs: &Integer) | [src] |
impl BitAndFrom<i32> for Integer
[src]
impl BitAndFrom<i32> for Integer
fn bitand_from(&mut self, lhs: i32) | [src] |
impl<'t> BitAndFrom<&'t i32> for Integer
[src]
impl<'t> BitAndFrom<&'t i32> for Integer
fn bitand_from(&mut self, lhs: &i32) | [src] |
impl BitAndFrom<u32> for Integer
[src]
impl BitAndFrom<u32> for Integer
fn bitand_from(&mut self, lhs: u32) | [src] |
impl<'t> BitAndFrom<&'t u32> for Integer
[src]
impl<'t> BitAndFrom<&'t u32> for Integer
fn bitand_from(&mut self, lhs: &u32) | [src] |
impl BitOrFrom<Integer> for Integer
[src]
impl BitOrFrom<Integer> for Integer
fn bitor_from(&mut self, lhs: Integer) | [src] |
impl<'a> BitOrFrom<&'a Integer> for Integer
[src]
impl<'a> BitOrFrom<&'a Integer> for Integer
fn bitor_from(&mut self, lhs: &Integer) | [src] |
impl BitOrFrom<i32> for Integer
[src]
impl BitOrFrom<i32> for Integer
fn bitor_from(&mut self, lhs: i32) | [src] |
impl<'t> BitOrFrom<&'t i32> for Integer
[src]
impl<'t> BitOrFrom<&'t i32> for Integer
fn bitor_from(&mut self, lhs: &i32) | [src] |
impl BitOrFrom<u32> for Integer
[src]
impl BitOrFrom<u32> for Integer
fn bitor_from(&mut self, lhs: u32) | [src] |
impl<'t> BitOrFrom<&'t u32> for Integer
[src]
impl<'t> BitOrFrom<&'t u32> for Integer
fn bitor_from(&mut self, lhs: &u32) | [src] |
impl BitXorFrom<Integer> for Integer
[src]
impl BitXorFrom<Integer> for Integer
fn bitxor_from(&mut self, lhs: Integer) | [src] |
impl<'a> BitXorFrom<&'a Integer> for Integer
[src]
impl<'a> BitXorFrom<&'a Integer> for Integer
fn bitxor_from(&mut self, lhs: &Integer) | [src] |
impl BitXorFrom<i32> for Integer
[src]
impl BitXorFrom<i32> for Integer
fn bitxor_from(&mut self, lhs: i32) | [src] |
impl<'t> BitXorFrom<&'t i32> for Integer
[src]
impl<'t> BitXorFrom<&'t i32> for Integer
fn bitxor_from(&mut self, lhs: &i32) | [src] |
impl BitXorFrom<u32> for Integer
[src]
impl BitXorFrom<u32> for Integer
fn bitxor_from(&mut self, lhs: u32) | [src] |
impl<'t> BitXorFrom<&'t u32> for Integer
[src]
impl<'t> BitXorFrom<&'t u32> for Integer
fn bitxor_from(&mut self, lhs: &u32) | [src] |
impl Pow<u32> for Integer
[src]
impl Pow<u32> for Integer
type Output = Integer
The resulting type after the power operation.
fn pow(self, rhs: u32) -> Integer | [src] |
impl<'t> Pow<&'t u32> for Integer
[src]
impl<'t> Pow<&'t u32> for Integer
type Output = Integer
The resulting type after the power operation.
fn pow(self, rhs: &u32) -> Integer | [src] |
impl<'b> Pow<u32> for &'b Integer
[src]
impl<'b> Pow<u32> for &'b Integer
type Output = PowU32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: u32) -> PowU32Incomplete<'b> | [src] |
impl<'t, 'b> Pow<&'t u32> for &'b Integer
[src]
impl<'t, 'b> Pow<&'t u32> for &'b Integer
type Output = PowU32Incomplete<'b>
The resulting type after the power operation.
fn pow(self, rhs: &u32) -> PowU32Incomplete<'b> | [src] |
impl Pow<Integer> for Float
[src]
impl Pow<Integer> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: Integer) -> Float | [src] |
impl<'a> Pow<&'a Integer> for Float
[src]
impl<'a> Pow<&'a Integer> for Float
type Output = Float
The resulting type after the power operation.
fn pow(self, rhs: &Integer) -> Float | [src] |
impl<'a> Pow<&'a Integer> for &'a Float
[src]
impl<'a> Pow<&'a Integer> for &'a Float
type Output = PowIntegerIncomplete<'a>
The resulting type after the power operation.
fn pow(self, rhs: &'a Integer) -> PowIntegerIncomplete | [src] |
impl<'a> Pow<Integer> for &'a Float
[src]
impl<'a> Pow<Integer> for &'a Float
type Output = PowOwnedIntegerIncomplete<'a>
The resulting type after the power operation.
fn pow(self, rhs: Integer) -> PowOwnedIntegerIncomplete<'a> | [src] |
impl Pow<Integer> for Complex
[src]
impl Pow<Integer> for Complex
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: Integer) -> Complex | [src] |
impl<'a> Pow<&'a Integer> for Complex
[src]
impl<'a> Pow<&'a Integer> for Complex
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: &Integer) -> Complex | [src] |
impl<'a> Pow<&'a Integer> for &'a Complex
[src]
impl<'a> Pow<&'a Integer> for &'a Complex
type Output = PowIntegerIncomplete<'a>
The resulting type after the power operation.
fn pow(self, rhs: &'a Integer) -> PowIntegerIncomplete | [src] |
impl<'a> Pow<Integer> for &'a Complex
[src]
impl<'a> Pow<Integer> for &'a Complex
type Output = PowOwnedIntegerIncomplete<'a>
The resulting type after the power operation.
fn pow(self, rhs: Integer) -> PowOwnedIntegerIncomplete<'a> | [src] |
impl PowAssign<u32> for Integer
[src]
impl PowAssign<u32> for Integer
fn pow_assign(&mut self, rhs: u32) | [src] |
impl<'t> PowAssign<&'t u32> for Integer
[src]
impl<'t> PowAssign<&'t u32> for Integer
fn pow_assign(&mut self, rhs: &u32) | [src] |
impl PowAssign<Integer> for Float
[src]
impl PowAssign<Integer> for Float
fn pow_assign(&mut self, rhs: Integer) | [src] |
impl<'a> PowAssign<&'a Integer> for Float
[src]
impl<'a> PowAssign<&'a Integer> for Float
fn pow_assign(&mut self, rhs: &Integer) | [src] |
impl PowAssign<Integer> for Complex
[src]
impl PowAssign<Integer> for Complex
fn pow_assign(&mut self, rhs: Integer) | [src] |
impl<'a> PowAssign<&'a Integer> for Complex
[src]
impl<'a> PowAssign<&'a Integer> for Complex
fn pow_assign(&mut self, rhs: &Integer) | [src] |
impl<'a> AssignRound<&'a Integer> for Float
[src]
impl<'a> AssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: &Integer, round: Round) -> Ordering | [src] |
impl AssignRound<Integer> for Float
[src]
impl AssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn assign_round(&mut self, src: Integer, round: Round) -> Ordering | [src] |
impl AddAssignRound<Integer> for Float
[src]
impl AddAssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering | [src] |
impl<'a> AddAssignRound<&'a Integer> for Float
[src]
impl<'a> AddAssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering | [src] |
impl AddAssignRound<Integer> for Complex
[src]
impl AddAssignRound<Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_assign_round( | [src] |
impl<'a> AddAssignRound<&'a Integer> for Complex
[src]
impl<'a> AddAssignRound<&'a Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_assign_round( | [src] |
impl AddFromRound<Integer> for Float
[src]
impl AddFromRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: Integer, round: Round) -> Ordering | [src] |
impl<'a> AddFromRound<&'a Integer> for Float
[src]
impl<'a> AddFromRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn add_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering | [src] |
impl AddFromRound<Integer> for Complex
[src]
impl AddFromRound<Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_from_round( | [src] |
impl<'a> AddFromRound<&'a Integer> for Complex
[src]
impl<'a> AddFromRound<&'a Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_from_round( | [src] |
impl SubAssignRound<Integer> for Float
[src]
impl SubAssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering | [src] |
impl<'a> SubAssignRound<&'a Integer> for Float
[src]
impl<'a> SubAssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering | [src] |
impl SubAssignRound<Integer> for Complex
[src]
impl SubAssignRound<Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_assign_round( | [src] |
impl<'a> SubAssignRound<&'a Integer> for Complex
[src]
impl<'a> SubAssignRound<&'a Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_assign_round( | [src] |
impl SubFromRound<Integer> for Float
[src]
impl SubFromRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: Integer, round: Round) -> Ordering | [src] |
impl<'a> SubFromRound<&'a Integer> for Float
[src]
impl<'a> SubFromRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn sub_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering | [src] |
impl SubFromRound<Integer> for Complex
[src]
impl SubFromRound<Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_from_round( | [src] |
impl<'a> SubFromRound<&'a Integer> for Complex
[src]
impl<'a> SubFromRound<&'a Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_from_round( | [src] |
impl MulAssignRound<Integer> for Float
[src]
impl MulAssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering | [src] |
impl<'a> MulAssignRound<&'a Integer> for Float
[src]
impl<'a> MulAssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering | [src] |
impl MulAssignRound<Integer> for Complex
[src]
impl MulAssignRound<Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_assign_round( | [src] |
impl<'a> MulAssignRound<&'a Integer> for Complex
[src]
impl<'a> MulAssignRound<&'a Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_assign_round( | [src] |
impl MulFromRound<Integer> for Float
[src]
impl MulFromRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: Integer, round: Round) -> Ordering | [src] |
impl<'a> MulFromRound<&'a Integer> for Float
[src]
impl<'a> MulFromRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn mul_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering | [src] |
impl MulFromRound<Integer> for Complex
[src]
impl MulFromRound<Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_from_round( | [src] |
impl<'a> MulFromRound<&'a Integer> for Complex
[src]
impl<'a> MulFromRound<&'a Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn mul_from_round( | [src] |
impl DivAssignRound<Integer> for Float
[src]
impl DivAssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering | [src] |
impl<'a> DivAssignRound<&'a Integer> for Float
[src]
impl<'a> DivAssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering | [src] |
impl DivAssignRound<Integer> for Complex
[src]
impl DivAssignRound<Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn div_assign_round( | [src] |
impl<'a> DivAssignRound<&'a Integer> for Complex
[src]
impl<'a> DivAssignRound<&'a Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn div_assign_round( | [src] |
impl DivFromRound<Integer> for Float
[src]
impl DivFromRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: Integer, round: Round) -> Ordering | [src] |
impl<'a> DivFromRound<&'a Integer> for Float
[src]
impl<'a> DivFromRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn div_from_round(&mut self, lhs: &Integer, round: Round) -> Ordering | [src] |
impl PowAssignRound<Integer> for Float
[src]
impl PowAssignRound<Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: Integer, round: Round) -> Ordering | [src] |
impl<'a> PowAssignRound<&'a Integer> for Float
[src]
impl<'a> PowAssignRound<&'a Integer> for Float
type Round = Round
The rounding method.
type Ordering = Ordering
The direction from rounding.
fn pow_assign_round(&mut self, rhs: &Integer, round: Round) -> Ordering | [src] |
impl PowAssignRound<Integer> for Complex
[src]
impl PowAssignRound<Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn pow_assign_round( | [src] |
impl<'a> PowAssignRound<&'a Integer> for Complex
[src]
impl<'a> PowAssignRound<&'a Integer> for Complex
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn pow_assign_round( | [src] |
impl DivRounding<Integer> for Integer
[src]
impl DivRounding<Integer> for Integer
type Output = Integer
The resulting type from the division operation.
fn div_trunc(self, rhs: Integer) -> Integer | [src] |
fn div_ceil(self, rhs: Integer) -> Integer | [src] |
fn div_floor(self, rhs: Integer) -> Integer | [src] |
fn div_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i> DivRounding<&'i Integer> for Integer
[src]
impl<'i> DivRounding<&'i Integer> for Integer
type Output = Integer
The resulting type from the division operation.
fn div_trunc(self, rhs: &Integer) -> Integer | [src] |
fn div_ceil(self, rhs: &Integer) -> Integer | [src] |
fn div_floor(self, rhs: &Integer) -> Integer | [src] |
fn div_euc(self, rhs: &Integer) -> Integer | [src] |
impl<'i> DivRounding<Integer> for &'i Integer
[src]
impl<'i> DivRounding<Integer> for &'i Integer
type Output = Integer
The resulting type from the division operation.
fn div_trunc(self, rhs: Integer) -> Integer | [src] |
fn div_ceil(self, rhs: Integer) -> Integer | [src] |
fn div_floor(self, rhs: Integer) -> Integer | [src] |
fn div_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i> DivRounding<&'i Integer> for &'i Integer
[src]
impl<'i> DivRounding<&'i Integer> for &'i Integer
type Output = DivRoundingIncomplete<'i>
The resulting type from the division operation.
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingIncomplete | [src] |
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingIncomplete | [src] |
fn div_floor(self, rhs: &'i Integer) -> DivRoundingIncomplete | [src] |
fn div_euc(self, rhs: &'i Integer) -> DivRoundingIncomplete | [src] |
impl DivRounding<i32> for Integer
[src]
impl DivRounding<i32> for Integer
type Output = Integer
The resulting type from the division operation.
fn div_trunc(self, rhs: i32) -> Integer | [src] |
fn div_ceil(self, rhs: i32) -> Integer | [src] |
fn div_floor(self, rhs: i32) -> Integer | [src] |
fn div_euc(self, rhs: i32) -> Integer | [src] |
impl<'t> DivRounding<&'t i32> for Integer
[src]
impl<'t> DivRounding<&'t i32> for Integer
type Output = Integer
The resulting type from the division operation.
fn div_trunc(self, rhs: &i32) -> Integer | [src] |
fn div_ceil(self, rhs: &i32) -> Integer | [src] |
fn div_floor(self, rhs: &i32) -> Integer | [src] |
fn div_euc(self, rhs: &i32) -> Integer | [src] |
impl<'i> DivRounding<i32> for &'i Integer
[src]
impl<'i> DivRounding<i32> for &'i Integer
type Output = DivRoundingI32Incomplete<'i>
The resulting type from the division operation.
fn div_trunc(self, rhs: i32) -> DivRoundingI32Incomplete<'i> | [src] |
fn div_ceil(self, rhs: i32) -> DivRoundingI32Incomplete<'i> | [src] |
fn div_floor(self, rhs: i32) -> DivRoundingI32Incomplete<'i> | [src] |
fn div_euc(self, rhs: i32) -> DivRoundingI32Incomplete<'i> | [src] |
impl<'t, 'i> DivRounding<&'t i32> for &'i Integer
[src]
impl<'t, 'i> DivRounding<&'t i32> for &'i Integer
type Output = DivRoundingI32Incomplete<'i>
The resulting type from the division operation.
fn div_trunc(self, rhs: &i32) -> DivRoundingI32Incomplete<'i> | [src] |
fn div_ceil(self, rhs: &i32) -> DivRoundingI32Incomplete<'i> | [src] |
fn div_floor(self, rhs: &i32) -> DivRoundingI32Incomplete<'i> | [src] |
fn div_euc(self, rhs: &i32) -> DivRoundingI32Incomplete<'i> | [src] |
impl DivRounding<Integer> for i32
[src]
impl DivRounding<Integer> for i32
type Output = Integer
The resulting type from the division operation.
fn div_trunc(self, rhs: Integer) -> Integer | [src] |
fn div_ceil(self, rhs: Integer) -> Integer | [src] |
fn div_floor(self, rhs: Integer) -> Integer | [src] |
fn div_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i> DivRounding<&'i Integer> for i32
[src]
impl<'i> DivRounding<&'i Integer> for i32
type Output = DivRoundingFromI32Incomplete<'i>
The resulting type from the division operation.
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromI32Incomplete | [src] |
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromI32Incomplete | [src] |
fn div_floor(self, rhs: &Integer) -> DivRoundingFromI32Incomplete | [src] |
fn div_euc(self, rhs: &Integer) -> DivRoundingFromI32Incomplete | [src] |
impl<'t> DivRounding<Integer> for &'t i32
[src]
impl<'t> DivRounding<Integer> for &'t i32
type Output = Integer
The resulting type from the division operation.
fn div_trunc(self, rhs: Integer) -> Integer | [src] |
fn div_ceil(self, rhs: Integer) -> Integer | [src] |
fn div_floor(self, rhs: Integer) -> Integer | [src] |
fn div_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i, 't> DivRounding<&'i Integer> for &'t i32
[src]
impl<'i, 't> DivRounding<&'i Integer> for &'t i32
type Output = DivRoundingFromI32Incomplete<'i>
The resulting type from the division operation.
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i> | [src] |
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i> | [src] |
fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i> | [src] |
fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i> | [src] |
impl DivRounding<u32> for Integer
[src]
impl DivRounding<u32> for Integer
type Output = Integer
The resulting type from the division operation.
fn div_trunc(self, rhs: u32) -> Integer | [src] |
fn div_ceil(self, rhs: u32) -> Integer | [src] |
fn div_floor(self, rhs: u32) -> Integer | [src] |
fn div_euc(self, rhs: u32) -> Integer | [src] |
impl<'t> DivRounding<&'t u32> for Integer
[src]
impl<'t> DivRounding<&'t u32> for Integer
type Output = Integer
The resulting type from the division operation.
fn div_trunc(self, rhs: &u32) -> Integer | [src] |
fn div_ceil(self, rhs: &u32) -> Integer | [src] |
fn div_floor(self, rhs: &u32) -> Integer | [src] |
fn div_euc(self, rhs: &u32) -> Integer | [src] |
impl<'i> DivRounding<u32> for &'i Integer
[src]
impl<'i> DivRounding<u32> for &'i Integer
type Output = DivRoundingU32Incomplete<'i>
The resulting type from the division operation.
fn div_trunc(self, rhs: u32) -> DivRoundingU32Incomplete<'i> | [src] |
fn div_ceil(self, rhs: u32) -> DivRoundingU32Incomplete<'i> | [src] |
fn div_floor(self, rhs: u32) -> DivRoundingU32Incomplete<'i> | [src] |
fn div_euc(self, rhs: u32) -> DivRoundingU32Incomplete<'i> | [src] |
impl<'t, 'i> DivRounding<&'t u32> for &'i Integer
[src]
impl<'t, 'i> DivRounding<&'t u32> for &'i Integer
type Output = DivRoundingU32Incomplete<'i>
The resulting type from the division operation.
fn div_trunc(self, rhs: &u32) -> DivRoundingU32Incomplete<'i> | [src] |
fn div_ceil(self, rhs: &u32) -> DivRoundingU32Incomplete<'i> | [src] |
fn div_floor(self, rhs: &u32) -> DivRoundingU32Incomplete<'i> | [src] |
fn div_euc(self, rhs: &u32) -> DivRoundingU32Incomplete<'i> | [src] |
impl DivRounding<Integer> for u32
[src]
impl DivRounding<Integer> for u32
type Output = Integer
The resulting type from the division operation.
fn div_trunc(self, rhs: Integer) -> Integer | [src] |
fn div_ceil(self, rhs: Integer) -> Integer | [src] |
fn div_floor(self, rhs: Integer) -> Integer | [src] |
fn div_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i> DivRounding<&'i Integer> for u32
[src]
impl<'i> DivRounding<&'i Integer> for u32
type Output = DivRoundingFromU32Incomplete<'i>
The resulting type from the division operation.
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromU32Incomplete | [src] |
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromU32Incomplete | [src] |
fn div_floor(self, rhs: &Integer) -> DivRoundingFromU32Incomplete | [src] |
fn div_euc(self, rhs: &Integer) -> DivRoundingFromU32Incomplete | [src] |
impl<'t> DivRounding<Integer> for &'t u32
[src]
impl<'t> DivRounding<Integer> for &'t u32
type Output = Integer
The resulting type from the division operation.
fn div_trunc(self, rhs: Integer) -> Integer | [src] |
fn div_ceil(self, rhs: Integer) -> Integer | [src] |
fn div_floor(self, rhs: Integer) -> Integer | [src] |
fn div_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i, 't> DivRounding<&'i Integer> for &'t u32
[src]
impl<'i, 't> DivRounding<&'i Integer> for &'t u32
type Output = DivRoundingFromU32Incomplete<'i>
The resulting type from the division operation.
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i> | [src] |
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i> | [src] |
fn div_floor(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i> | [src] |
fn div_euc(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i> | [src] |
impl DivRoundingAssign<Integer> for Integer
[src]
impl DivRoundingAssign<Integer> for Integer
fn div_trunc_assign(&mut self, rhs: Integer) | [src] |
fn div_ceil_assign(&mut self, rhs: Integer) | [src] |
fn div_floor_assign(&mut self, rhs: Integer) | [src] |
fn div_euc_assign(&mut self, rhs: Integer) | [src] |
impl<'i> DivRoundingAssign<&'i Integer> for Integer
[src]
impl<'i> DivRoundingAssign<&'i Integer> for Integer
fn div_trunc_assign(&mut self, rhs: &Integer) | [src] |
fn div_ceil_assign(&mut self, rhs: &Integer) | [src] |
fn div_floor_assign(&mut self, rhs: &Integer) | [src] |
fn div_euc_assign(&mut self, rhs: &Integer) | [src] |
impl DivRoundingAssign<i32> for Integer
[src]
impl DivRoundingAssign<i32> for Integer
fn div_trunc_assign(&mut self, rhs: i32) | [src] |
fn div_ceil_assign(&mut self, rhs: i32) | [src] |
fn div_floor_assign(&mut self, rhs: i32) | [src] |
fn div_euc_assign(&mut self, rhs: i32) | [src] |
impl<'t> DivRoundingAssign<&'t i32> for Integer
[src]
impl<'t> DivRoundingAssign<&'t i32> for Integer
fn div_trunc_assign(&mut self, rhs: &i32) | [src] |
fn div_ceil_assign(&mut self, rhs: &i32) | [src] |
fn div_floor_assign(&mut self, rhs: &i32) | [src] |
fn div_euc_assign(&mut self, rhs: &i32) | [src] |
impl DivRoundingAssign<u32> for Integer
[src]
impl DivRoundingAssign<u32> for Integer
fn div_trunc_assign(&mut self, rhs: u32) | [src] |
fn div_ceil_assign(&mut self, rhs: u32) | [src] |
fn div_floor_assign(&mut self, rhs: u32) | [src] |
fn div_euc_assign(&mut self, rhs: u32) | [src] |
impl<'t> DivRoundingAssign<&'t u32> for Integer
[src]
impl<'t> DivRoundingAssign<&'t u32> for Integer
fn div_trunc_assign(&mut self, rhs: &u32) | [src] |
fn div_ceil_assign(&mut self, rhs: &u32) | [src] |
fn div_floor_assign(&mut self, rhs: &u32) | [src] |
fn div_euc_assign(&mut self, rhs: &u32) | [src] |
impl DivRoundingFrom<Integer> for Integer
[src]
impl DivRoundingFrom<Integer> for Integer
fn div_trunc_from(&mut self, lhs: Integer) | [src] |
fn div_ceil_from(&mut self, lhs: Integer) | [src] |
fn div_floor_from(&mut self, lhs: Integer) | [src] |
fn div_euc_from(&mut self, lhs: Integer) | [src] |
impl<'i> DivRoundingFrom<&'i Integer> for Integer
[src]
impl<'i> DivRoundingFrom<&'i Integer> for Integer
fn div_trunc_from(&mut self, lhs: &Integer) | [src] |
fn div_ceil_from(&mut self, lhs: &Integer) | [src] |
fn div_floor_from(&mut self, lhs: &Integer) | [src] |
fn div_euc_from(&mut self, lhs: &Integer) | [src] |
impl DivRoundingFrom<i32> for Integer
[src]
impl DivRoundingFrom<i32> for Integer
fn div_trunc_from(&mut self, lhs: i32) | [src] |
fn div_ceil_from(&mut self, lhs: i32) | [src] |
fn div_floor_from(&mut self, lhs: i32) | [src] |
fn div_euc_from(&mut self, lhs: i32) | [src] |
impl<'t> DivRoundingFrom<&'t i32> for Integer
[src]
impl<'t> DivRoundingFrom<&'t i32> for Integer
fn div_trunc_from(&mut self, lhs: &i32) | [src] |
fn div_ceil_from(&mut self, lhs: &i32) | [src] |
fn div_floor_from(&mut self, lhs: &i32) | [src] |
fn div_euc_from(&mut self, lhs: &i32) | [src] |
impl DivRoundingFrom<u32> for Integer
[src]
impl DivRoundingFrom<u32> for Integer
fn div_trunc_from(&mut self, lhs: u32) | [src] |
fn div_ceil_from(&mut self, lhs: u32) | [src] |
fn div_floor_from(&mut self, lhs: u32) | [src] |
fn div_euc_from(&mut self, lhs: u32) | [src] |
impl<'t> DivRoundingFrom<&'t u32> for Integer
[src]
impl<'t> DivRoundingFrom<&'t u32> for Integer
fn div_trunc_from(&mut self, lhs: &u32) | [src] |
fn div_ceil_from(&mut self, lhs: &u32) | [src] |
fn div_floor_from(&mut self, lhs: &u32) | [src] |
fn div_euc_from(&mut self, lhs: &u32) | [src] |
impl RemRounding<Integer> for Integer
[src]
impl RemRounding<Integer> for Integer
type Output = Integer
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: Integer) -> Integer | [src] |
fn rem_ceil(self, rhs: Integer) -> Integer | [src] |
fn rem_floor(self, rhs: Integer) -> Integer | [src] |
fn rem_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i> RemRounding<&'i Integer> for Integer
[src]
impl<'i> RemRounding<&'i Integer> for Integer
type Output = Integer
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: &Integer) -> Integer | [src] |
fn rem_ceil(self, rhs: &Integer) -> Integer | [src] |
fn rem_floor(self, rhs: &Integer) -> Integer | [src] |
fn rem_euc(self, rhs: &Integer) -> Integer | [src] |
impl<'i> RemRounding<Integer> for &'i Integer
[src]
impl<'i> RemRounding<Integer> for &'i Integer
type Output = Integer
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: Integer) -> Integer | [src] |
fn rem_ceil(self, rhs: Integer) -> Integer | [src] |
fn rem_floor(self, rhs: Integer) -> Integer | [src] |
fn rem_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i> RemRounding<&'i Integer> for &'i Integer
[src]
impl<'i> RemRounding<&'i Integer> for &'i Integer
type Output = RemRoundingIncomplete<'i>
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingIncomplete | [src] |
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingIncomplete | [src] |
fn rem_floor(self, rhs: &'i Integer) -> RemRoundingIncomplete | [src] |
fn rem_euc(self, rhs: &'i Integer) -> RemRoundingIncomplete | [src] |
impl RemRounding<i32> for Integer
[src]
impl RemRounding<i32> for Integer
type Output = Integer
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: i32) -> Integer | [src] |
fn rem_ceil(self, rhs: i32) -> Integer | [src] |
fn rem_floor(self, rhs: i32) -> Integer | [src] |
fn rem_euc(self, rhs: i32) -> Integer | [src] |
impl<'t> RemRounding<&'t i32> for Integer
[src]
impl<'t> RemRounding<&'t i32> for Integer
type Output = Integer
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: &i32) -> Integer | [src] |
fn rem_ceil(self, rhs: &i32) -> Integer | [src] |
fn rem_floor(self, rhs: &i32) -> Integer | [src] |
fn rem_euc(self, rhs: &i32) -> Integer | [src] |
impl<'i> RemRounding<i32> for &'i Integer
[src]
impl<'i> RemRounding<i32> for &'i Integer
type Output = RemRoundingI32Incomplete<'i>
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: i32) -> RemRoundingI32Incomplete<'i> | [src] |
fn rem_ceil(self, rhs: i32) -> RemRoundingI32Incomplete<'i> | [src] |
fn rem_floor(self, rhs: i32) -> RemRoundingI32Incomplete<'i> | [src] |
fn rem_euc(self, rhs: i32) -> RemRoundingI32Incomplete<'i> | [src] |
impl<'t, 'i> RemRounding<&'t i32> for &'i Integer
[src]
impl<'t, 'i> RemRounding<&'t i32> for &'i Integer
type Output = RemRoundingI32Incomplete<'i>
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: &i32) -> RemRoundingI32Incomplete<'i> | [src] |
fn rem_ceil(self, rhs: &i32) -> RemRoundingI32Incomplete<'i> | [src] |
fn rem_floor(self, rhs: &i32) -> RemRoundingI32Incomplete<'i> | [src] |
fn rem_euc(self, rhs: &i32) -> RemRoundingI32Incomplete<'i> | [src] |
impl RemRounding<Integer> for i32
[src]
impl RemRounding<Integer> for i32
type Output = Integer
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: Integer) -> Integer | [src] |
fn rem_ceil(self, rhs: Integer) -> Integer | [src] |
fn rem_floor(self, rhs: Integer) -> Integer | [src] |
fn rem_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i> RemRounding<&'i Integer> for i32
[src]
impl<'i> RemRounding<&'i Integer> for i32
type Output = RemRoundingFromI32Incomplete<'i>
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI32Incomplete | [src] |
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI32Incomplete | [src] |
fn rem_floor(self, rhs: &Integer) -> RemRoundingFromI32Incomplete | [src] |
fn rem_euc(self, rhs: &Integer) -> RemRoundingFromI32Incomplete | [src] |
impl<'t> RemRounding<Integer> for &'t i32
[src]
impl<'t> RemRounding<Integer> for &'t i32
type Output = Integer
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: Integer) -> Integer | [src] |
fn rem_ceil(self, rhs: Integer) -> Integer | [src] |
fn rem_floor(self, rhs: Integer) -> Integer | [src] |
fn rem_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i, 't> RemRounding<&'i Integer> for &'t i32
[src]
impl<'i, 't> RemRounding<&'i Integer> for &'t i32
type Output = RemRoundingFromI32Incomplete<'i>
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i> | [src] |
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i> | [src] |
fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i> | [src] |
fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i> | [src] |
impl RemRounding<u32> for Integer
[src]
impl RemRounding<u32> for Integer
type Output = Integer
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: u32) -> Integer | [src] |
fn rem_ceil(self, rhs: u32) -> Integer | [src] |
fn rem_floor(self, rhs: u32) -> Integer | [src] |
fn rem_euc(self, rhs: u32) -> Integer | [src] |
impl<'t> RemRounding<&'t u32> for Integer
[src]
impl<'t> RemRounding<&'t u32> for Integer
type Output = Integer
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: &u32) -> Integer | [src] |
fn rem_ceil(self, rhs: &u32) -> Integer | [src] |
fn rem_floor(self, rhs: &u32) -> Integer | [src] |
fn rem_euc(self, rhs: &u32) -> Integer | [src] |
impl<'i> RemRounding<u32> for &'i Integer
[src]
impl<'i> RemRounding<u32> for &'i Integer
type Output = RemRoundingU32Incomplete<'i>
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: u32) -> RemRoundingU32Incomplete<'i> | [src] |
fn rem_ceil(self, rhs: u32) -> RemRoundingU32Incomplete<'i> | [src] |
fn rem_floor(self, rhs: u32) -> RemRoundingU32Incomplete<'i> | [src] |
fn rem_euc(self, rhs: u32) -> RemRoundingU32Incomplete<'i> | [src] |
impl<'t, 'i> RemRounding<&'t u32> for &'i Integer
[src]
impl<'t, 'i> RemRounding<&'t u32> for &'i Integer
type Output = RemRoundingU32Incomplete<'i>
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: &u32) -> RemRoundingU32Incomplete<'i> | [src] |
fn rem_ceil(self, rhs: &u32) -> RemRoundingU32Incomplete<'i> | [src] |
fn rem_floor(self, rhs: &u32) -> RemRoundingU32Incomplete<'i> | [src] |
fn rem_euc(self, rhs: &u32) -> RemRoundingU32Incomplete<'i> | [src] |
impl RemRounding<Integer> for u32
[src]
impl RemRounding<Integer> for u32
type Output = Integer
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: Integer) -> Integer | [src] |
fn rem_ceil(self, rhs: Integer) -> Integer | [src] |
fn rem_floor(self, rhs: Integer) -> Integer | [src] |
fn rem_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i> RemRounding<&'i Integer> for u32
[src]
impl<'i> RemRounding<&'i Integer> for u32
type Output = RemRoundingFromU32Incomplete<'i>
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU32Incomplete | [src] |
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU32Incomplete | [src] |
fn rem_floor(self, rhs: &Integer) -> RemRoundingFromU32Incomplete | [src] |
fn rem_euc(self, rhs: &Integer) -> RemRoundingFromU32Incomplete | [src] |
impl<'t> RemRounding<Integer> for &'t u32
[src]
impl<'t> RemRounding<Integer> for &'t u32
type Output = Integer
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: Integer) -> Integer | [src] |
fn rem_ceil(self, rhs: Integer) -> Integer | [src] |
fn rem_floor(self, rhs: Integer) -> Integer | [src] |
fn rem_euc(self, rhs: Integer) -> Integer | [src] |
impl<'i, 't> RemRounding<&'i Integer> for &'t u32
[src]
impl<'i, 't> RemRounding<&'i Integer> for &'t u32
type Output = RemRoundingFromU32Incomplete<'i>
The resulting type from the remainder operation.
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i> | [src] |
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i> | [src] |
fn rem_floor(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i> | [src] |
fn rem_euc(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i> | [src] |
impl RemRoundingAssign<Integer> for Integer
[src]
impl RemRoundingAssign<Integer> for Integer
fn rem_trunc_assign(&mut self, rhs: Integer) | [src] |
fn rem_ceil_assign(&mut self, rhs: Integer) | [src] |
fn rem_floor_assign(&mut self, rhs: Integer) | [src] |
fn rem_euc_assign(&mut self, rhs: Integer) | [src] |
impl<'i> RemRoundingAssign<&'i Integer> for Integer
[src]
impl<'i> RemRoundingAssign<&'i Integer> for Integer
fn rem_trunc_assign(&mut self, rhs: &Integer) | [src] |
fn rem_ceil_assign(&mut self, rhs: &Integer) | [src] |
fn rem_floor_assign(&mut self, rhs: &Integer) | [src] |
fn rem_euc_assign(&mut self, rhs: &Integer) | [src] |
impl RemRoundingAssign<i32> for Integer
[src]
impl RemRoundingAssign<i32> for Integer
fn rem_trunc_assign(&mut self, rhs: i32) | [src] |
fn rem_ceil_assign(&mut self, rhs: i32) | [src] |
fn rem_floor_assign(&mut self, rhs: i32) | [src] |
fn rem_euc_assign(&mut self, rhs: i32) | [src] |
impl<'t> RemRoundingAssign<&'t i32> for Integer
[src]
impl<'t> RemRoundingAssign<&'t i32> for Integer
fn rem_trunc_assign(&mut self, rhs: &i32) | [src] |
fn rem_ceil_assign(&mut self, rhs: &i32) | [src] |
fn rem_floor_assign(&mut self, rhs: &i32) | [src] |
fn rem_euc_assign(&mut self, rhs: &i32) | [src] |
impl RemRoundingAssign<u32> for Integer
[src]
impl RemRoundingAssign<u32> for Integer
fn rem_trunc_assign(&mut self, rhs: u32) | [src] |
fn rem_ceil_assign(&mut self, rhs: u32) | [src] |
fn rem_floor_assign(&mut self, rhs: u32) | [src] |
fn rem_euc_assign(&mut self, rhs: u32) | [src] |
impl<'t> RemRoundingAssign<&'t u32> for Integer
[src]
impl<'t> RemRoundingAssign<&'t u32> for Integer
fn rem_trunc_assign(&mut self, rhs: &u32) | [src] |
fn rem_ceil_assign(&mut self, rhs: &u32) | [src] |
fn rem_floor_assign(&mut self, rhs: &u32) | [src] |
fn rem_euc_assign(&mut self, rhs: &u32) | [src] |
impl RemRoundingFrom<Integer> for Integer
[src]
impl RemRoundingFrom<Integer> for Integer
fn rem_trunc_from(&mut self, lhs: Integer) | [src] |
fn rem_ceil_from(&mut self, lhs: Integer) | [src] |
fn rem_floor_from(&mut self, lhs: Integer) | [src] |
fn rem_euc_from(&mut self, lhs: Integer) | [src] |
impl<'i> RemRoundingFrom<&'i Integer> for Integer
[src]
impl<'i> RemRoundingFrom<&'i Integer> for Integer
fn rem_trunc_from(&mut self, lhs: &Integer) | [src] |
fn rem_ceil_from(&mut self, lhs: &Integer) | [src] |
fn rem_floor_from(&mut self, lhs: &Integer) | [src] |
fn rem_euc_from(&mut self, lhs: &Integer) | [src] |
impl RemRoundingFrom<i32> for Integer
[src]
impl RemRoundingFrom<i32> for Integer
fn rem_trunc_from(&mut self, lhs: i32) | [src] |
fn rem_ceil_from(&mut self, lhs: i32) | [src] |
fn rem_floor_from(&mut self, lhs: i32) | [src] |
fn rem_euc_from(&mut self, lhs: i32) | [src] |
impl<'t> RemRoundingFrom<&'t i32> for Integer
[src]
impl<'t> RemRoundingFrom<&'t i32> for Integer
fn rem_trunc_from(&mut self, lhs: &i32) | [src] |
fn rem_ceil_from(&mut self, lhs: &i32) | [src] |
fn rem_floor_from(&mut self, lhs: &i32) | [src] |
fn rem_euc_from(&mut self, lhs: &i32) | [src] |
impl RemRoundingFrom<u32> for Integer
[src]
impl RemRoundingFrom<u32> for Integer
fn rem_trunc_from(&mut self, lhs: u32) | [src] |
fn rem_ceil_from(&mut self, lhs: u32) | [src] |
fn rem_floor_from(&mut self, lhs: u32) | [src] |
fn rem_euc_from(&mut self, lhs: u32) | [src] |
impl<'t> RemRoundingFrom<&'t u32> for Integer
[src]
impl<'t> RemRoundingFrom<&'t u32> for Integer
fn rem_trunc_from(&mut self, lhs: &u32) | [src] |
fn rem_ceil_from(&mut self, lhs: &u32) | [src] |
fn rem_floor_from(&mut self, lhs: &u32) | [src] |
fn rem_euc_from(&mut self, lhs: &u32) | [src] |
impl Assign<Integer> for Integer
[src]
impl Assign<Integer> for Integer
impl<'a> Assign<&'a Integer> for Integer
[src]
impl<'a> Assign<&'a Integer> for Integer
impl Assign<i8> for Integer
[src]
impl Assign<i8> for Integer
impl<'a> Assign<&'a i8> for Integer
[src]
impl<'a> Assign<&'a i8> for Integer
impl Assign<i16> for Integer
[src]
impl Assign<i16> for Integer
impl<'a> Assign<&'a i16> for Integer
[src]
impl<'a> Assign<&'a i16> for Integer
impl Assign<i32> for Integer
[src]
impl Assign<i32> for Integer
impl<'a> Assign<&'a i32> for Integer
[src]
impl<'a> Assign<&'a i32> for Integer
impl Assign<i64> for Integer
[src]
impl Assign<i64> for Integer
impl<'a> Assign<&'a i64> for Integer
[src]
impl<'a> Assign<&'a i64> for Integer
impl Assign<i128> for Integer
[src]
impl Assign<i128> for Integer
impl<'a> Assign<&'a i128> for Integer
[src]
impl<'a> Assign<&'a i128> for Integer
impl Assign<isize> for Integer
[src]
impl Assign<isize> for Integer
impl<'a> Assign<&'a isize> for Integer
[src]
impl<'a> Assign<&'a isize> for Integer
impl Assign<bool> for Integer
[src]
impl Assign<bool> for Integer
impl<'a> Assign<&'a bool> for Integer
[src]
impl<'a> Assign<&'a bool> for Integer
impl Assign<u8> for Integer
[src]
impl Assign<u8> for Integer
impl<'a> Assign<&'a u8> for Integer
[src]
impl<'a> Assign<&'a u8> for Integer
impl Assign<u16> for Integer
[src]
impl Assign<u16> for Integer
impl<'a> Assign<&'a u16> for Integer
[src]
impl<'a> Assign<&'a u16> for Integer
impl Assign<u32> for Integer
[src]
impl Assign<u32> for Integer
impl<'a> Assign<&'a u32> for Integer
[src]
impl<'a> Assign<&'a u32> for Integer
impl Assign<u64> for Integer
[src]
impl Assign<u64> for Integer
impl<'a> Assign<&'a u64> for Integer
[src]
impl<'a> Assign<&'a u64> for Integer
impl Assign<u128> for Integer
[src]
impl Assign<u128> for Integer
impl<'a> Assign<&'a u128> for Integer
[src]
impl<'a> Assign<&'a u128> for Integer
impl Assign<usize> for Integer
[src]
impl Assign<usize> for Integer
impl<'a> Assign<&'a usize> for Integer
[src]
impl<'a> Assign<&'a usize> for Integer
impl<'a> From<&'a Integer> for Integer
[src]
impl<'a> From<&'a Integer> for Integer
impl From<i8> for Integer
[src]
impl From<i8> for Integer
impl From<i16> for Integer
[src]
impl From<i16> for Integer
impl From<i32> for Integer
[src]
impl From<i32> for Integer
impl From<i64> for Integer
[src]
impl From<i64> for Integer
impl From<i128> for Integer
[src]
impl From<i128> for Integer
impl From<isize> for Integer
[src]
impl From<isize> for Integer
impl From<bool> for Integer
[src]
impl From<bool> for Integer
impl From<u8> for Integer
[src]
impl From<u8> for Integer
impl From<u16> for Integer
[src]
impl From<u16> for Integer
impl From<u32> for Integer
[src]
impl From<u32> for Integer
impl From<u64> for Integer
[src]
impl From<u64> for Integer
impl From<u128> for Integer
[src]
impl From<u128> for Integer
impl From<usize> for Integer
[src]
impl From<usize> for Integer
impl Eq for Integer
[src]
impl Eq for Integer
impl Drop for Integer
[src]
impl Drop for Integer
impl Send for Integer
[src]
impl Send for Integer
impl PartialOrd<Integer> for Integer
[src]
impl PartialOrd<Integer> for Integer
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<i8> for Integer
[src]
impl PartialOrd<i8> for Integer
fn partial_cmp(&self, other: &i8) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for i8
[src]
impl PartialOrd<Integer> for i8
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<i16> for Integer
[src]
impl PartialOrd<i16> for Integer
fn partial_cmp(&self, other: &i16) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for i16
[src]
impl PartialOrd<Integer> for i16
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<i32> for Integer
[src]
impl PartialOrd<i32> for Integer
fn partial_cmp(&self, other: &i32) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for i32
[src]
impl PartialOrd<Integer> for i32
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<i64> for Integer
[src]
impl PartialOrd<i64> for Integer
fn partial_cmp(&self, other: &i64) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for i64
[src]
impl PartialOrd<Integer> for i64
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<i128> for Integer
[src]
impl PartialOrd<i128> for Integer
fn partial_cmp(&self, other: &i128) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for i128
[src]
impl PartialOrd<Integer> for i128
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<isize> for Integer
[src]
impl PartialOrd<isize> for Integer
fn partial_cmp(&self, other: &isize) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for isize
[src]
impl PartialOrd<Integer> for isize
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<u8> for Integer
[src]
impl PartialOrd<u8> for Integer
fn partial_cmp(&self, other: &u8) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for u8
[src]
impl PartialOrd<Integer> for u8
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<u16> for Integer
[src]
impl PartialOrd<u16> for Integer
fn partial_cmp(&self, other: &u16) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for u16
[src]
impl PartialOrd<Integer> for u16
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<u32> for Integer
[src]
impl PartialOrd<u32> for Integer
fn partial_cmp(&self, other: &u32) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for u32
[src]
impl PartialOrd<Integer> for u32
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<u64> for Integer
[src]
impl PartialOrd<u64> for Integer
fn partial_cmp(&self, other: &u64) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for u64
[src]
impl PartialOrd<Integer> for u64
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<u128> for Integer
[src]
impl PartialOrd<u128> for Integer
fn partial_cmp(&self, other: &u128) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for u128
[src]
impl PartialOrd<Integer> for u128
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<usize> for Integer
[src]
impl PartialOrd<usize> for Integer
fn partial_cmp(&self, other: &usize) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for usize
[src]
impl PartialOrd<Integer> for usize
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<f32> for Integer
[src]
impl PartialOrd<f32> for Integer
fn partial_cmp(&self, other: &f32) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for f32
[src]
impl PartialOrd<Integer> for f32
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<f64> for Integer
[src]
impl PartialOrd<f64> for Integer
fn partial_cmp(&self, other: &f64) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for f64
[src]
impl PartialOrd<Integer> for f64
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for Rational
[src]
impl PartialOrd<Integer> for Rational
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Rational> for Integer
[src]
impl PartialOrd<Rational> for Integer
fn partial_cmp(&self, other: &Rational) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Float> for Integer
[src]
impl PartialOrd<Float> for Integer
fn partial_cmp(&self, other: &Float) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 PartialOrd<Integer> for Float
[src]
impl PartialOrd<Integer> for Float
fn partial_cmp(&self, other: &Integer) -> Option<Ordering> | [src] |
| 1.0.0 [src] |
This method tests less than (for self
and other
) and is used by the <
operator. Read more
| 1.0.0 [src] |
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
| 1.0.0 [src] |
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
| 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 Sync for Integer
[src]
impl Sync for Integer
impl Default for Integer
[src]
impl Default for Integer
impl PartialEq<Integer> for Integer
[src]
impl PartialEq<Integer> for Integer
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<i8> for Integer
[src]
impl PartialEq<i8> for Integer
fn eq(&self, other: &i8) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for i8
[src]
impl PartialEq<Integer> for i8
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<i16> for Integer
[src]
impl PartialEq<i16> for Integer
fn eq(&self, other: &i16) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for i16
[src]
impl PartialEq<Integer> for i16
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<i32> for Integer
[src]
impl PartialEq<i32> for Integer
fn eq(&self, other: &i32) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for i32
[src]
impl PartialEq<Integer> for i32
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<i64> for Integer
[src]
impl PartialEq<i64> for Integer
fn eq(&self, other: &i64) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for i64
[src]
impl PartialEq<Integer> for i64
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<i128> for Integer
[src]
impl PartialEq<i128> for Integer
fn eq(&self, other: &i128) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for i128
[src]
impl PartialEq<Integer> for i128
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<isize> for Integer
[src]
impl PartialEq<isize> for Integer
fn eq(&self, other: &isize) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for isize
[src]
impl PartialEq<Integer> for isize
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<u8> for Integer
[src]
impl PartialEq<u8> for Integer
fn eq(&self, other: &u8) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for u8
[src]
impl PartialEq<Integer> for u8
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<u16> for Integer
[src]
impl PartialEq<u16> for Integer
fn eq(&self, other: &u16) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for u16
[src]
impl PartialEq<Integer> for u16
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<u32> for Integer
[src]
impl PartialEq<u32> for Integer
fn eq(&self, other: &u32) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for u32
[src]
impl PartialEq<Integer> for u32
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<u64> for Integer
[src]
impl PartialEq<u64> for Integer
fn eq(&self, other: &u64) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for u64
[src]
impl PartialEq<Integer> for u64
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<u128> for Integer
[src]
impl PartialEq<u128> for Integer
fn eq(&self, other: &u128) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for u128
[src]
impl PartialEq<Integer> for u128
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<usize> for Integer
[src]
impl PartialEq<usize> for Integer
fn eq(&self, other: &usize) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for usize
[src]
impl PartialEq<Integer> for usize
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<f32> for Integer
[src]
impl PartialEq<f32> for Integer
fn eq(&self, other: &f32) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for f32
[src]
impl PartialEq<Integer> for f32
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<f64> for Integer
[src]
impl PartialEq<f64> for Integer
fn eq(&self, other: &f64) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for f64
[src]
impl PartialEq<Integer> for f64
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for Rational
[src]
impl PartialEq<Integer> for Rational
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Rational> for Integer
[src]
impl PartialEq<Rational> for Integer
fn eq(&self, other: &Rational) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for Float
[src]
impl PartialEq<Integer> for Float
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Float> for Integer
[src]
impl PartialEq<Float> for Integer
fn eq(&self, other: &Float) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Integer> for Complex
[src]
impl PartialEq<Integer> for Complex
fn eq(&self, other: &Integer) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl PartialEq<Complex> for Integer
[src]
impl PartialEq<Complex> for Integer
fn eq(&self, other: &Complex) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl Clone for Integer
[src]
impl Clone for Integer
impl Ord for Integer
[src]
impl Ord for Integer
fn cmp(&self, other: &Integer) -> Ordering | [src] |
fn max(self, other: Self) -> Self | 1.21.0 [src] |
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self | 1.21.0 [src] |
Compares and returns the minimum of two values. Read more
impl Binary for Integer
[src]
impl Binary for Integer
impl Debug for Integer
[src]
impl Debug for Integer
impl Display for Integer
[src]
impl Display for Integer
impl UpperHex for Integer
[src]
impl UpperHex for Integer
impl LowerHex for Integer
[src]
impl LowerHex for Integer
impl Octal for Integer
[src]
impl Octal for Integer
impl Hash for Integer
[src]
impl Hash for Integer
fn hash<H>(&self, state: &mut H) where | [src] |
fn hash_slice<H>(data: &[Self], state: &mut H) where | 1.3.0 [src] |
Feeds a slice of this type into the given [Hasher
]. Read more
impl Add<Integer> for Integer
[src]
impl Add<Integer> for Integer
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> Integer | [src] |
impl<'a> Add<&'a Integer> for Integer
[src]
impl<'a> Add<&'a Integer> for Integer
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: &Integer) -> Integer | [src] |
impl<'a> Add<Integer> for &'a Integer
[src]
impl<'a> Add<Integer> for &'a Integer
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> Integer | [src] |
impl<'a> Add<&'a Integer> for &'a Integer
[src]
impl<'a> Add<&'a Integer> for &'a Integer
type Output = AddIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Integer) -> AddIncomplete | [src] |
impl Add<i32> for Integer
[src]
impl Add<i32> for Integer
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: i32) -> Integer | [src] |
impl<'t> Add<&'t i32> for Integer
[src]
impl<'t> Add<&'t i32> for Integer
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: &i32) -> Integer | [src] |
impl<'b> Add<i32> for &'b Integer
[src]
impl<'b> Add<i32> for &'b Integer
type Output = AddI32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: i32) -> AddI32Incomplete<'b> | [src] |
impl<'t, 'b> Add<&'t i32> for &'b Integer
[src]
impl<'t, 'b> Add<&'t i32> for &'b Integer
type Output = AddI32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &i32) -> AddI32Incomplete<'b> | [src] |
impl Add<Integer> for i32
[src]
impl Add<Integer> for i32
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> Integer | [src] |
impl<'b> Add<&'b Integer> for i32
[src]
impl<'b> Add<&'b Integer> for i32
type Output = AddI32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &Integer) -> AddI32Incomplete | [src] |
impl<'t> Add<Integer> for &'t i32
[src]
impl<'t> Add<Integer> for &'t i32
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> Add<&'b Integer> for &'t i32
[src]
impl<'b, 't> Add<&'b Integer> for &'t i32
type Output = AddI32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &Integer) -> AddI32Incomplete | [src] |
impl Add<u32> for Integer
[src]
impl Add<u32> for Integer
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: u32) -> Integer | [src] |
impl<'t> Add<&'t u32> for Integer
[src]
impl<'t> Add<&'t u32> for Integer
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: &u32) -> Integer | [src] |
impl<'b> Add<u32> for &'b Integer
[src]
impl<'b> Add<u32> for &'b Integer
type Output = AddU32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: u32) -> AddU32Incomplete<'b> | [src] |
impl<'t, 'b> Add<&'t u32> for &'b Integer
[src]
impl<'t, 'b> Add<&'t u32> for &'b Integer
type Output = AddU32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &u32) -> AddU32Incomplete<'b> | [src] |
impl Add<Integer> for u32
[src]
impl Add<Integer> for u32
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> Integer | [src] |
impl<'b> Add<&'b Integer> for u32
[src]
impl<'b> Add<&'b Integer> for u32
type Output = AddU32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &Integer) -> AddU32Incomplete | [src] |
impl<'t> Add<Integer> for &'t u32
[src]
impl<'t> Add<Integer> for &'t u32
type Output = Integer
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> Add<&'b Integer> for &'t u32
[src]
impl<'b, 't> Add<&'b Integer> for &'t u32
type Output = AddU32Incomplete<'b>
The resulting type after applying the +
operator.
fn add(self, rhs: &Integer) -> AddU32Incomplete | [src] |
impl Add<Integer> for Float
[src]
impl Add<Integer> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> Float | [src] |
impl<'a> Add<&'a Integer> for Float
[src]
impl<'a> Add<&'a Integer> for Float
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: &Integer) -> Float | [src] |
impl<'a> Add<&'a Integer> for &'a Float
[src]
impl<'a> Add<&'a Integer> for &'a Float
type Output = AddIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Integer) -> AddIntegerIncomplete | [src] |
impl<'a> Add<Integer> for &'a Float
[src]
impl<'a> Add<Integer> for &'a Float
type Output = AddOwnedIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> AddOwnedIntegerIncomplete<'a> | [src] |
impl Add<Float> for Integer
[src]
impl Add<Float> for Integer
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float | [src] |
impl<'a> Add<&'a Float> for Integer
[src]
impl<'a> Add<&'a Float> for Integer
type Output = AddOwnedIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &Float) -> AddOwnedIntegerIncomplete | [src] |
impl<'a> Add<Float> for &'a Integer
[src]
impl<'a> Add<Float> for &'a Integer
type Output = Float
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Float | [src] |
impl<'a> Add<&'a Float> for &'a Integer
[src]
impl<'a> Add<&'a Float> for &'a Integer
type Output = AddIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> AddIntegerIncomplete | [src] |
impl Add<Integer> for Complex
[src]
impl Add<Integer> for Complex
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> Complex | [src] |
impl<'a> Add<&'a Integer> for Complex
[src]
impl<'a> Add<&'a Integer> for Complex
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: &Integer) -> Complex | [src] |
impl<'a> Add<&'a Integer> for &'a Complex
[src]
impl<'a> Add<&'a Integer> for &'a Complex
type Output = AddIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Integer) -> AddIntegerIncomplete | [src] |
impl<'a> Add<Integer> for &'a Complex
[src]
impl<'a> Add<Integer> for &'a Complex
type Output = AddOwnedIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: Integer) -> AddOwnedIntegerIncomplete<'a> | [src] |
impl Add<Complex> for Integer
[src]
impl Add<Complex> for Integer
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Complex) -> Complex | [src] |
impl<'a> Add<&'a Complex> for Integer
[src]
impl<'a> Add<&'a Complex> for Integer
type Output = AddOwnedIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &Complex) -> AddOwnedIntegerIncomplete | [src] |
impl<'a> Add<Complex> for &'a Integer
[src]
impl<'a> Add<Complex> for &'a Integer
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Complex) -> Complex | [src] |
impl<'a> Add<&'a Complex> for &'a Integer
[src]
impl<'a> Add<&'a Complex> for &'a Integer
type Output = AddIntegerIncomplete<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Complex) -> AddIntegerIncomplete | [src] |
impl Sub<Integer> for Integer
[src]
impl Sub<Integer> for Integer
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> Integer | [src] |
impl<'a> Sub<&'a Integer> for Integer
[src]
impl<'a> Sub<&'a Integer> for Integer
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: &Integer) -> Integer | [src] |
impl<'a> Sub<Integer> for &'a Integer
[src]
impl<'a> Sub<Integer> for &'a Integer
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> Integer | [src] |
impl<'a> Sub<&'a Integer> for &'a Integer
[src]
impl<'a> Sub<&'a Integer> for &'a Integer
type Output = SubIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Integer) -> SubIncomplete | [src] |
impl Sub<i32> for Integer
[src]
impl Sub<i32> for Integer
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: i32) -> Integer | [src] |
impl<'t> Sub<&'t i32> for Integer
[src]
impl<'t> Sub<&'t i32> for Integer
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: &i32) -> Integer | [src] |
impl<'b> Sub<i32> for &'b Integer
[src]
impl<'b> Sub<i32> for &'b Integer
type Output = SubI32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: i32) -> SubI32Incomplete<'b> | [src] |
impl<'t, 'b> Sub<&'t i32> for &'b Integer
[src]
impl<'t, 'b> Sub<&'t i32> for &'b Integer
type Output = SubI32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &i32) -> SubI32Incomplete<'b> | [src] |
impl Sub<Integer> for i32
[src]
impl Sub<Integer> for i32
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> Integer | [src] |
impl<'b> Sub<&'b Integer> for i32
[src]
impl<'b> Sub<&'b Integer> for i32
type Output = SubFromI32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Integer) -> SubFromI32Incomplete | [src] |
impl<'t> Sub<Integer> for &'t i32
[src]
impl<'t> Sub<Integer> for &'t i32
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> Sub<&'b Integer> for &'t i32
[src]
impl<'b, 't> Sub<&'b Integer> for &'t i32
type Output = SubFromI32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b Integer) -> SubFromI32Incomplete<'b> | [src] |
impl Sub<u32> for Integer
[src]
impl Sub<u32> for Integer
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: u32) -> Integer | [src] |
impl<'t> Sub<&'t u32> for Integer
[src]
impl<'t> Sub<&'t u32> for Integer
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: &u32) -> Integer | [src] |
impl<'b> Sub<u32> for &'b Integer
[src]
impl<'b> Sub<u32> for &'b Integer
type Output = SubU32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: u32) -> SubU32Incomplete<'b> | [src] |
impl<'t, 'b> Sub<&'t u32> for &'b Integer
[src]
impl<'t, 'b> Sub<&'t u32> for &'b Integer
type Output = SubU32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &u32) -> SubU32Incomplete<'b> | [src] |
impl Sub<Integer> for u32
[src]
impl Sub<Integer> for u32
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> Integer | [src] |
impl<'b> Sub<&'b Integer> for u32
[src]
impl<'b> Sub<&'b Integer> for u32
type Output = SubFromU32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Integer) -> SubFromU32Incomplete | [src] |
impl<'t> Sub<Integer> for &'t u32
[src]
impl<'t> Sub<Integer> for &'t u32
type Output = Integer
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> Sub<&'b Integer> for &'t u32
[src]
impl<'b, 't> Sub<&'b Integer> for &'t u32
type Output = SubFromU32Incomplete<'b>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'b Integer) -> SubFromU32Incomplete<'b> | [src] |
impl Sub<Integer> for Float
[src]
impl Sub<Integer> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> Float | [src] |
impl<'a> Sub<&'a Integer> for Float
[src]
impl<'a> Sub<&'a Integer> for Float
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: &Integer) -> Float | [src] |
impl<'a> Sub<&'a Integer> for &'a Float
[src]
impl<'a> Sub<&'a Integer> for &'a Float
type Output = SubIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Integer) -> SubIntegerIncomplete | [src] |
impl<'a> Sub<Integer> for &'a Float
[src]
impl<'a> Sub<Integer> for &'a Float
type Output = SubFromIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> SubFromIntegerIncomplete<'a> | [src] |
impl Sub<Float> for Integer
[src]
impl Sub<Float> for Integer
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float | [src] |
impl<'a> Sub<&'a Float> for Integer
[src]
impl<'a> Sub<&'a Float> for Integer
type Output = SubFromOwnedIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Float) -> SubFromOwnedIntegerIncomplete | [src] |
impl<'a> Sub<Float> for &'a Integer
[src]
impl<'a> Sub<Float> for &'a Integer
type Output = Float
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Float | [src] |
impl<'a> Sub<&'a Float> for &'a Integer
[src]
impl<'a> Sub<&'a Float> for &'a Integer
type Output = SubOwnedIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> SubOwnedIntegerIncomplete | [src] |
impl Sub<Integer> for Complex
[src]
impl Sub<Integer> for Complex
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> Complex | [src] |
impl<'a> Sub<&'a Integer> for Complex
[src]
impl<'a> Sub<&'a Integer> for Complex
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: &Integer) -> Complex | [src] |
impl<'a> Sub<&'a Integer> for &'a Complex
[src]
impl<'a> Sub<&'a Integer> for &'a Complex
type Output = SubIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Integer) -> SubIntegerIncomplete | [src] |
impl<'a> Sub<Integer> for &'a Complex
[src]
impl<'a> Sub<Integer> for &'a Complex
type Output = SubFromIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: Integer) -> SubFromIntegerIncomplete<'a> | [src] |
impl Sub<Complex> for Integer
[src]
impl Sub<Complex> for Integer
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Complex) -> Complex | [src] |
impl<'a> Sub<&'a Complex> for Integer
[src]
impl<'a> Sub<&'a Complex> for Integer
type Output = SubFromOwnedIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &Complex) -> SubFromOwnedIntegerIncomplete | [src] |
impl<'a> Sub<Complex> for &'a Integer
[src]
impl<'a> Sub<Complex> for &'a Integer
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Complex) -> Complex | [src] |
impl<'a> Sub<&'a Complex> for &'a Integer
[src]
impl<'a> Sub<&'a Complex> for &'a Integer
type Output = SubOwnedIntegerIncomplete<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Complex) -> SubOwnedIntegerIncomplete | [src] |
impl Mul<Integer> for Integer
[src]
impl Mul<Integer> for Integer
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> Integer | [src] |
impl<'a> Mul<&'a Integer> for Integer
[src]
impl<'a> Mul<&'a Integer> for Integer
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: &Integer) -> Integer | [src] |
impl<'a> Mul<Integer> for &'a Integer
[src]
impl<'a> Mul<Integer> for &'a Integer
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> Integer | [src] |
impl<'a> Mul<&'a Integer> for &'a Integer
[src]
impl<'a> Mul<&'a Integer> for &'a Integer
type Output = MulIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Integer) -> MulIncomplete | [src] |
impl Mul<i32> for Integer
[src]
impl Mul<i32> for Integer
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: i32) -> Integer | [src] |
impl<'t> Mul<&'t i32> for Integer
[src]
impl<'t> Mul<&'t i32> for Integer
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: &i32) -> Integer | [src] |
impl<'b> Mul<i32> for &'b Integer
[src]
impl<'b> Mul<i32> for &'b Integer
type Output = MulI32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: i32) -> MulI32Incomplete<'b> | [src] |
impl<'t, 'b> Mul<&'t i32> for &'b Integer
[src]
impl<'t, 'b> Mul<&'t i32> for &'b Integer
type Output = MulI32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &i32) -> MulI32Incomplete<'b> | [src] |
impl Mul<Integer> for i32
[src]
impl Mul<Integer> for i32
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> Integer | [src] |
impl<'b> Mul<&'b Integer> for i32
[src]
impl<'b> Mul<&'b Integer> for i32
type Output = MulI32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Integer) -> MulI32Incomplete | [src] |
impl<'t> Mul<Integer> for &'t i32
[src]
impl<'t> Mul<Integer> for &'t i32
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> Mul<&'b Integer> for &'t i32
[src]
impl<'b, 't> Mul<&'b Integer> for &'t i32
type Output = MulI32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Integer) -> MulI32Incomplete | [src] |
impl Mul<u32> for Integer
[src]
impl Mul<u32> for Integer
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: u32) -> Integer | [src] |
impl<'t> Mul<&'t u32> for Integer
[src]
impl<'t> Mul<&'t u32> for Integer
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: &u32) -> Integer | [src] |
impl<'b> Mul<u32> for &'b Integer
[src]
impl<'b> Mul<u32> for &'b Integer
type Output = MulU32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: u32) -> MulU32Incomplete<'b> | [src] |
impl<'t, 'b> Mul<&'t u32> for &'b Integer
[src]
impl<'t, 'b> Mul<&'t u32> for &'b Integer
type Output = MulU32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &u32) -> MulU32Incomplete<'b> | [src] |
impl Mul<Integer> for u32
[src]
impl Mul<Integer> for u32
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> Integer | [src] |
impl<'b> Mul<&'b Integer> for u32
[src]
impl<'b> Mul<&'b Integer> for u32
type Output = MulU32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Integer) -> MulU32Incomplete | [src] |
impl<'t> Mul<Integer> for &'t u32
[src]
impl<'t> Mul<Integer> for &'t u32
type Output = Integer
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> Mul<&'b Integer> for &'t u32
[src]
impl<'b, 't> Mul<&'b Integer> for &'t u32
type Output = MulU32Incomplete<'b>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Integer) -> MulU32Incomplete | [src] |
impl Mul<Integer> for Float
[src]
impl Mul<Integer> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> Float | [src] |
impl<'a> Mul<&'a Integer> for Float
[src]
impl<'a> Mul<&'a Integer> for Float
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: &Integer) -> Float | [src] |
impl<'a> Mul<&'a Integer> for &'a Float
[src]
impl<'a> Mul<&'a Integer> for &'a Float
type Output = MulIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Integer) -> MulIntegerIncomplete | [src] |
impl<'a> Mul<Integer> for &'a Float
[src]
impl<'a> Mul<Integer> for &'a Float
type Output = MulOwnedIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> MulOwnedIntegerIncomplete<'a> | [src] |
impl Mul<Float> for Integer
[src]
impl Mul<Float> for Integer
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float | [src] |
impl<'a> Mul<&'a Float> for Integer
[src]
impl<'a> Mul<&'a Float> for Integer
type Output = MulOwnedIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Float) -> MulOwnedIntegerIncomplete | [src] |
impl<'a> Mul<Float> for &'a Integer
[src]
impl<'a> Mul<Float> for &'a Integer
type Output = Float
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Float | [src] |
impl<'a> Mul<&'a Float> for &'a Integer
[src]
impl<'a> Mul<&'a Float> for &'a Integer
type Output = MulIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> MulIntegerIncomplete | [src] |
impl Mul<Integer> for Complex
[src]
impl Mul<Integer> for Complex
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> Complex | [src] |
impl<'a> Mul<&'a Integer> for Complex
[src]
impl<'a> Mul<&'a Integer> for Complex
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: &Integer) -> Complex | [src] |
impl<'a> Mul<&'a Integer> for &'a Complex
[src]
impl<'a> Mul<&'a Integer> for &'a Complex
type Output = MulIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Integer) -> MulIntegerIncomplete | [src] |
impl<'a> Mul<Integer> for &'a Complex
[src]
impl<'a> Mul<Integer> for &'a Complex
type Output = MulOwnedIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: Integer) -> MulOwnedIntegerIncomplete<'a> | [src] |
impl Mul<Complex> for Integer
[src]
impl Mul<Complex> for Integer
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Complex) -> Complex | [src] |
impl<'a> Mul<&'a Complex> for Integer
[src]
impl<'a> Mul<&'a Complex> for Integer
type Output = MulOwnedIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &Complex) -> MulOwnedIntegerIncomplete | [src] |
impl<'a> Mul<Complex> for &'a Integer
[src]
impl<'a> Mul<Complex> for &'a Integer
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Complex) -> Complex | [src] |
impl<'a> Mul<&'a Complex> for &'a Integer
[src]
impl<'a> Mul<&'a Complex> for &'a Integer
type Output = MulIntegerIncomplete<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Complex) -> MulIntegerIncomplete | [src] |
impl Div<Integer> for Integer
[src]
impl Div<Integer> for Integer
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> Integer | [src] |
impl<'a> Div<&'a Integer> for Integer
[src]
impl<'a> Div<&'a Integer> for Integer
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: &Integer) -> Integer | [src] |
impl<'a> Div<Integer> for &'a Integer
[src]
impl<'a> Div<Integer> for &'a Integer
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> Integer | [src] |
impl<'a> Div<&'a Integer> for &'a Integer
[src]
impl<'a> Div<&'a Integer> for &'a Integer
type Output = DivIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Integer) -> DivIncomplete | [src] |
impl Div<i32> for Integer
[src]
impl Div<i32> for Integer
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: i32) -> Integer | [src] |
impl<'t> Div<&'t i32> for Integer
[src]
impl<'t> Div<&'t i32> for Integer
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: &i32) -> Integer | [src] |
impl<'b> Div<i32> for &'b Integer
[src]
impl<'b> Div<i32> for &'b Integer
type Output = DivI32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: i32) -> DivI32Incomplete<'b> | [src] |
impl<'t, 'b> Div<&'t i32> for &'b Integer
[src]
impl<'t, 'b> Div<&'t i32> for &'b Integer
type Output = DivI32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &i32) -> DivI32Incomplete<'b> | [src] |
impl Div<Integer> for i32
[src]
impl Div<Integer> for i32
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> Integer | [src] |
impl<'b> Div<&'b Integer> for i32
[src]
impl<'b> Div<&'b Integer> for i32
type Output = DivFromI32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &Integer) -> DivFromI32Incomplete | [src] |
impl<'t> Div<Integer> for &'t i32
[src]
impl<'t> Div<Integer> for &'t i32
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> Div<&'b Integer> for &'t i32
[src]
impl<'b, 't> Div<&'b Integer> for &'t i32
type Output = DivFromI32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &'b Integer) -> DivFromI32Incomplete<'b> | [src] |
impl Div<u32> for Integer
[src]
impl Div<u32> for Integer
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: u32) -> Integer | [src] |
impl<'t> Div<&'t u32> for Integer
[src]
impl<'t> Div<&'t u32> for Integer
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: &u32) -> Integer | [src] |
impl<'b> Div<u32> for &'b Integer
[src]
impl<'b> Div<u32> for &'b Integer
type Output = DivU32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: u32) -> DivU32Incomplete<'b> | [src] |
impl<'t, 'b> Div<&'t u32> for &'b Integer
[src]
impl<'t, 'b> Div<&'t u32> for &'b Integer
type Output = DivU32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &u32) -> DivU32Incomplete<'b> | [src] |
impl Div<Integer> for u32
[src]
impl Div<Integer> for u32
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> Integer | [src] |
impl<'b> Div<&'b Integer> for u32
[src]
impl<'b> Div<&'b Integer> for u32
type Output = DivFromU32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &Integer) -> DivFromU32Incomplete | [src] |
impl<'t> Div<Integer> for &'t u32
[src]
impl<'t> Div<Integer> for &'t u32
type Output = Integer
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> Div<&'b Integer> for &'t u32
[src]
impl<'b, 't> Div<&'b Integer> for &'t u32
type Output = DivFromU32Incomplete<'b>
The resulting type after applying the /
operator.
fn div(self, rhs: &'b Integer) -> DivFromU32Incomplete<'b> | [src] |
impl Div<Integer> for Float
[src]
impl Div<Integer> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> Float | [src] |
impl<'a> Div<&'a Integer> for Float
[src]
impl<'a> Div<&'a Integer> for Float
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: &Integer) -> Float | [src] |
impl<'a> Div<&'a Integer> for &'a Float
[src]
impl<'a> Div<&'a Integer> for &'a Float
type Output = DivIntegerIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Integer) -> DivIntegerIncomplete | [src] |
impl<'a> Div<Integer> for &'a Float
[src]
impl<'a> Div<Integer> for &'a Float
type Output = DivFromIntegerIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> DivFromIntegerIncomplete<'a> | [src] |
impl Div<Float> for Integer
[src]
impl Div<Float> for Integer
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float | [src] |
impl<'a> Div<&'a Float> for Integer
[src]
impl<'a> Div<&'a Float> for Integer
type Output = DivFromOwnedIntegerIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &Float) -> DivFromOwnedIntegerIncomplete | [src] |
impl<'a> Div<Float> for &'a Integer
[src]
impl<'a> Div<Float> for &'a Integer
type Output = Float
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Float | [src] |
impl<'a> Div<&'a Float> for &'a Integer
[src]
impl<'a> Div<&'a Float> for &'a Integer
type Output = DivOwnedIntegerIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> DivOwnedIntegerIncomplete | [src] |
impl Div<Integer> for Complex
[src]
impl Div<Integer> for Complex
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> Complex | [src] |
impl<'a> Div<&'a Integer> for Complex
[src]
impl<'a> Div<&'a Integer> for Complex
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: &Integer) -> Complex | [src] |
impl<'a> Div<&'a Integer> for &'a Complex
[src]
impl<'a> Div<&'a Integer> for &'a Complex
type Output = DivIntegerIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Integer) -> DivIntegerIncomplete | [src] |
impl<'a> Div<Integer> for &'a Complex
[src]
impl<'a> Div<Integer> for &'a Complex
type Output = DivOwnedIntegerIncomplete<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: Integer) -> DivOwnedIntegerIncomplete<'a> | [src] |
impl Rem<Integer> for Integer
[src]
impl Rem<Integer> for Integer
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: Integer) -> Integer | [src] |
impl<'a> Rem<&'a Integer> for Integer
[src]
impl<'a> Rem<&'a Integer> for Integer
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: &Integer) -> Integer | [src] |
impl<'a> Rem<Integer> for &'a Integer
[src]
impl<'a> Rem<Integer> for &'a Integer
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: Integer) -> Integer | [src] |
impl<'a> Rem<&'a Integer> for &'a Integer
[src]
impl<'a> Rem<&'a Integer> for &'a Integer
type Output = RemIncomplete<'a>
The resulting type after applying the %
operator.
fn rem(self, rhs: &'a Integer) -> RemIncomplete | [src] |
impl Rem<i32> for Integer
[src]
impl Rem<i32> for Integer
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: i32) -> Integer | [src] |
impl<'t> Rem<&'t i32> for Integer
[src]
impl<'t> Rem<&'t i32> for Integer
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: &i32) -> Integer | [src] |
impl<'b> Rem<i32> for &'b Integer
[src]
impl<'b> Rem<i32> for &'b Integer
type Output = RemI32Incomplete<'b>
The resulting type after applying the %
operator.
fn rem(self, rhs: i32) -> RemI32Incomplete<'b> | [src] |
impl<'t, 'b> Rem<&'t i32> for &'b Integer
[src]
impl<'t, 'b> Rem<&'t i32> for &'b Integer
type Output = RemI32Incomplete<'b>
The resulting type after applying the %
operator.
fn rem(self, rhs: &i32) -> RemI32Incomplete<'b> | [src] |
impl Rem<Integer> for i32
[src]
impl Rem<Integer> for i32
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: Integer) -> Integer | [src] |
impl<'b> Rem<&'b Integer> for i32
[src]
impl<'b> Rem<&'b Integer> for i32
type Output = RemFromI32Incomplete<'b>
The resulting type after applying the %
operator.
fn rem(self, rhs: &Integer) -> RemFromI32Incomplete | [src] |
impl<'t> Rem<Integer> for &'t i32
[src]
impl<'t> Rem<Integer> for &'t i32
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> Rem<&'b Integer> for &'t i32
[src]
impl<'b, 't> Rem<&'b Integer> for &'t i32
type Output = RemFromI32Incomplete<'b>
The resulting type after applying the %
operator.
fn rem(self, rhs: &'b Integer) -> RemFromI32Incomplete<'b> | [src] |
impl Rem<u32> for Integer
[src]
impl Rem<u32> for Integer
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: u32) -> Integer | [src] |
impl<'t> Rem<&'t u32> for Integer
[src]
impl<'t> Rem<&'t u32> for Integer
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: &u32) -> Integer | [src] |
impl<'b> Rem<u32> for &'b Integer
[src]
impl<'b> Rem<u32> for &'b Integer
type Output = RemU32Incomplete<'b>
The resulting type after applying the %
operator.
fn rem(self, rhs: u32) -> RemU32Incomplete<'b> | [src] |
impl<'t, 'b> Rem<&'t u32> for &'b Integer
[src]
impl<'t, 'b> Rem<&'t u32> for &'b Integer
type Output = RemU32Incomplete<'b>
The resulting type after applying the %
operator.
fn rem(self, rhs: &u32) -> RemU32Incomplete<'b> | [src] |
impl Rem<Integer> for u32
[src]
impl Rem<Integer> for u32
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: Integer) -> Integer | [src] |
impl<'b> Rem<&'b Integer> for u32
[src]
impl<'b> Rem<&'b Integer> for u32
type Output = RemFromU32Incomplete<'b>
The resulting type after applying the %
operator.
fn rem(self, rhs: &Integer) -> RemFromU32Incomplete | [src] |
impl<'t> Rem<Integer> for &'t u32
[src]
impl<'t> Rem<Integer> for &'t u32
type Output = Integer
The resulting type after applying the %
operator.
fn rem(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> Rem<&'b Integer> for &'t u32
[src]
impl<'b, 't> Rem<&'b Integer> for &'t u32
type Output = RemFromU32Incomplete<'b>
The resulting type after applying the %
operator.
fn rem(self, rhs: &'b Integer) -> RemFromU32Incomplete<'b> | [src] |
impl Neg for Integer
[src]
impl Neg for Integer
impl<'a> Neg for &'a Integer
[src]
impl<'a> Neg for &'a Integer
type Output = NegIncomplete<'a>
The resulting type after applying the -
operator.
fn neg(self) -> NegIncomplete<'a> | [src] |
impl AddAssign<Integer> for Integer
[src]
impl AddAssign<Integer> for Integer
fn add_assign(&mut self, rhs: Integer) | [src] |
impl<'a> AddAssign<&'a Integer> for Integer
[src]
impl<'a> AddAssign<&'a Integer> for Integer
fn add_assign(&mut self, rhs: &Integer) | [src] |
impl AddAssign<i32> for Integer
[src]
impl AddAssign<i32> for Integer
fn add_assign(&mut self, rhs: i32) | [src] |
impl<'t> AddAssign<&'t i32> for Integer
[src]
impl<'t> AddAssign<&'t i32> for Integer
fn add_assign(&mut self, rhs: &i32) | [src] |
impl AddAssign<u32> for Integer
[src]
impl AddAssign<u32> for Integer
fn add_assign(&mut self, rhs: u32) | [src] |
impl<'t> AddAssign<&'t u32> for Integer
[src]
impl<'t> AddAssign<&'t u32> for Integer
fn add_assign(&mut self, rhs: &u32) | [src] |
impl AddAssign<Integer> for Float
[src]
impl AddAssign<Integer> for Float
fn add_assign(&mut self, rhs: Integer) | [src] |
impl<'a> AddAssign<&'a Integer> for Float
[src]
impl<'a> AddAssign<&'a Integer> for Float
fn add_assign(&mut self, rhs: &Integer) | [src] |
impl AddAssign<Integer> for Complex
[src]
impl AddAssign<Integer> for Complex
fn add_assign(&mut self, rhs: Integer) | [src] |
impl<'a> AddAssign<&'a Integer> for Complex
[src]
impl<'a> AddAssign<&'a Integer> for Complex
fn add_assign(&mut self, rhs: &Integer) | [src] |
impl SubAssign<Integer> for Integer
[src]
impl SubAssign<Integer> for Integer
fn sub_assign(&mut self, rhs: Integer) | [src] |
impl<'a> SubAssign<&'a Integer> for Integer
[src]
impl<'a> SubAssign<&'a Integer> for Integer
fn sub_assign(&mut self, rhs: &Integer) | [src] |
impl SubAssign<i32> for Integer
[src]
impl SubAssign<i32> for Integer
fn sub_assign(&mut self, rhs: i32) | [src] |
impl<'t> SubAssign<&'t i32> for Integer
[src]
impl<'t> SubAssign<&'t i32> for Integer
fn sub_assign(&mut self, rhs: &i32) | [src] |
impl SubAssign<u32> for Integer
[src]
impl SubAssign<u32> for Integer
fn sub_assign(&mut self, rhs: u32) | [src] |
impl<'t> SubAssign<&'t u32> for Integer
[src]
impl<'t> SubAssign<&'t u32> for Integer
fn sub_assign(&mut self, rhs: &u32) | [src] |
impl SubAssign<Integer> for Float
[src]
impl SubAssign<Integer> for Float
fn sub_assign(&mut self, rhs: Integer) | [src] |
impl<'a> SubAssign<&'a Integer> for Float
[src]
impl<'a> SubAssign<&'a Integer> for Float
fn sub_assign(&mut self, rhs: &Integer) | [src] |
impl SubAssign<Integer> for Complex
[src]
impl SubAssign<Integer> for Complex
fn sub_assign(&mut self, rhs: Integer) | [src] |
impl<'a> SubAssign<&'a Integer> for Complex
[src]
impl<'a> SubAssign<&'a Integer> for Complex
fn sub_assign(&mut self, rhs: &Integer) | [src] |
impl MulAssign<Integer> for Integer
[src]
impl MulAssign<Integer> for Integer
fn mul_assign(&mut self, rhs: Integer) | [src] |
impl<'a> MulAssign<&'a Integer> for Integer
[src]
impl<'a> MulAssign<&'a Integer> for Integer
fn mul_assign(&mut self, rhs: &Integer) | [src] |
impl MulAssign<i32> for Integer
[src]
impl MulAssign<i32> for Integer
fn mul_assign(&mut self, rhs: i32) | [src] |
impl<'t> MulAssign<&'t i32> for Integer
[src]
impl<'t> MulAssign<&'t i32> for Integer
fn mul_assign(&mut self, rhs: &i32) | [src] |
impl MulAssign<u32> for Integer
[src]
impl MulAssign<u32> for Integer
fn mul_assign(&mut self, rhs: u32) | [src] |
impl<'t> MulAssign<&'t u32> for Integer
[src]
impl<'t> MulAssign<&'t u32> for Integer
fn mul_assign(&mut self, rhs: &u32) | [src] |
impl MulAssign<Integer> for Float
[src]
impl MulAssign<Integer> for Float
fn mul_assign(&mut self, rhs: Integer) | [src] |
impl<'a> MulAssign<&'a Integer> for Float
[src]
impl<'a> MulAssign<&'a Integer> for Float
fn mul_assign(&mut self, rhs: &Integer) | [src] |
impl MulAssign<Integer> for Complex
[src]
impl MulAssign<Integer> for Complex
fn mul_assign(&mut self, rhs: Integer) | [src] |
impl<'a> MulAssign<&'a Integer> for Complex
[src]
impl<'a> MulAssign<&'a Integer> for Complex
fn mul_assign(&mut self, rhs: &Integer) | [src] |
impl DivAssign<Integer> for Integer
[src]
impl DivAssign<Integer> for Integer
fn div_assign(&mut self, rhs: Integer) | [src] |
impl<'a> DivAssign<&'a Integer> for Integer
[src]
impl<'a> DivAssign<&'a Integer> for Integer
fn div_assign(&mut self, rhs: &Integer) | [src] |
impl DivAssign<i32> for Integer
[src]
impl DivAssign<i32> for Integer
fn div_assign(&mut self, rhs: i32) | [src] |
impl<'t> DivAssign<&'t i32> for Integer
[src]
impl<'t> DivAssign<&'t i32> for Integer
fn div_assign(&mut self, rhs: &i32) | [src] |
impl DivAssign<u32> for Integer
[src]
impl DivAssign<u32> for Integer
fn div_assign(&mut self, rhs: u32) | [src] |
impl<'t> DivAssign<&'t u32> for Integer
[src]
impl<'t> DivAssign<&'t u32> for Integer
fn div_assign(&mut self, rhs: &u32) | [src] |
impl DivAssign<Integer> for Float
[src]
impl DivAssign<Integer> for Float
fn div_assign(&mut self, rhs: Integer) | [src] |
impl<'a> DivAssign<&'a Integer> for Float
[src]
impl<'a> DivAssign<&'a Integer> for Float
fn div_assign(&mut self, rhs: &Integer) | [src] |
impl DivAssign<Integer> for Complex
[src]
impl DivAssign<Integer> for Complex
fn div_assign(&mut self, rhs: Integer) | [src] |
impl<'a> DivAssign<&'a Integer> for Complex
[src]
impl<'a> DivAssign<&'a Integer> for Complex
fn div_assign(&mut self, rhs: &Integer) | [src] |
impl RemAssign<Integer> for Integer
[src]
impl RemAssign<Integer> for Integer
fn rem_assign(&mut self, rhs: Integer) | [src] |
impl<'a> RemAssign<&'a Integer> for Integer
[src]
impl<'a> RemAssign<&'a Integer> for Integer
fn rem_assign(&mut self, rhs: &Integer) | [src] |
impl RemAssign<i32> for Integer
[src]
impl RemAssign<i32> for Integer
fn rem_assign(&mut self, rhs: i32) | [src] |
impl<'t> RemAssign<&'t i32> for Integer
[src]
impl<'t> RemAssign<&'t i32> for Integer
fn rem_assign(&mut self, rhs: &i32) | [src] |
impl RemAssign<u32> for Integer
[src]
impl RemAssign<u32> for Integer
fn rem_assign(&mut self, rhs: u32) | [src] |
impl<'t> RemAssign<&'t u32> for Integer
[src]
impl<'t> RemAssign<&'t u32> for Integer
fn rem_assign(&mut self, rhs: &u32) | [src] |
impl Not for Integer
[src]
impl Not for Integer
impl<'a> Not for &'a Integer
[src]
impl<'a> Not for &'a Integer
type Output = NotIncomplete<'a>
The resulting type after applying the !
operator.
fn not(self) -> NotIncomplete<'a> | [src] |
impl BitAnd<Integer> for Integer
[src]
impl BitAnd<Integer> for Integer
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: Integer) -> Integer | [src] |
impl<'a> BitAnd<&'a Integer> for Integer
[src]
impl<'a> BitAnd<&'a Integer> for Integer
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: &Integer) -> Integer | [src] |
impl<'a> BitAnd<Integer> for &'a Integer
[src]
impl<'a> BitAnd<Integer> for &'a Integer
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: Integer) -> Integer | [src] |
impl<'a> BitAnd<&'a Integer> for &'a Integer
[src]
impl<'a> BitAnd<&'a Integer> for &'a Integer
type Output = BitAndIncomplete<'a>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &'a Integer) -> BitAndIncomplete | [src] |
impl BitAnd<i32> for Integer
[src]
impl BitAnd<i32> for Integer
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: i32) -> Integer | [src] |
impl<'t> BitAnd<&'t i32> for Integer
[src]
impl<'t> BitAnd<&'t i32> for Integer
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: &i32) -> Integer | [src] |
impl<'b> BitAnd<i32> for &'b Integer
[src]
impl<'b> BitAnd<i32> for &'b Integer
type Output = BitAndI32Incomplete<'b>
The resulting type after applying the &
operator.
fn bitand(self, rhs: i32) -> BitAndI32Incomplete<'b> | [src] |
impl<'t, 'b> BitAnd<&'t i32> for &'b Integer
[src]
impl<'t, 'b> BitAnd<&'t i32> for &'b Integer
type Output = BitAndI32Incomplete<'b>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &i32) -> BitAndI32Incomplete<'b> | [src] |
impl BitAnd<Integer> for i32
[src]
impl BitAnd<Integer> for i32
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: Integer) -> Integer | [src] |
impl<'b> BitAnd<&'b Integer> for i32
[src]
impl<'b> BitAnd<&'b Integer> for i32
type Output = BitAndI32Incomplete<'b>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &Integer) -> BitAndI32Incomplete | [src] |
impl<'t> BitAnd<Integer> for &'t i32
[src]
impl<'t> BitAnd<Integer> for &'t i32
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> BitAnd<&'b Integer> for &'t i32
[src]
impl<'b, 't> BitAnd<&'b Integer> for &'t i32
type Output = BitAndI32Incomplete<'b>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &Integer) -> BitAndI32Incomplete | [src] |
impl BitAnd<u32> for Integer
[src]
impl BitAnd<u32> for Integer
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: u32) -> Integer | [src] |
impl<'t> BitAnd<&'t u32> for Integer
[src]
impl<'t> BitAnd<&'t u32> for Integer
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: &u32) -> Integer | [src] |
impl<'b> BitAnd<u32> for &'b Integer
[src]
impl<'b> BitAnd<u32> for &'b Integer
type Output = BitAndU32Incomplete<'b>
The resulting type after applying the &
operator.
fn bitand(self, rhs: u32) -> BitAndU32Incomplete<'b> | [src] |
impl<'t, 'b> BitAnd<&'t u32> for &'b Integer
[src]
impl<'t, 'b> BitAnd<&'t u32> for &'b Integer
type Output = BitAndU32Incomplete<'b>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &u32) -> BitAndU32Incomplete<'b> | [src] |
impl BitAnd<Integer> for u32
[src]
impl BitAnd<Integer> for u32
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: Integer) -> Integer | [src] |
impl<'b> BitAnd<&'b Integer> for u32
[src]
impl<'b> BitAnd<&'b Integer> for u32
type Output = BitAndU32Incomplete<'b>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &Integer) -> BitAndU32Incomplete | [src] |
impl<'t> BitAnd<Integer> for &'t u32
[src]
impl<'t> BitAnd<Integer> for &'t u32
type Output = Integer
The resulting type after applying the &
operator.
fn bitand(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> BitAnd<&'b Integer> for &'t u32
[src]
impl<'b, 't> BitAnd<&'b Integer> for &'t u32
type Output = BitAndU32Incomplete<'b>
The resulting type after applying the &
operator.
fn bitand(self, rhs: &Integer) -> BitAndU32Incomplete | [src] |
impl BitOr<Integer> for Integer
[src]
impl BitOr<Integer> for Integer
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: Integer) -> Integer | [src] |
impl<'a> BitOr<&'a Integer> for Integer
[src]
impl<'a> BitOr<&'a Integer> for Integer
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: &Integer) -> Integer | [src] |
impl<'a> BitOr<Integer> for &'a Integer
[src]
impl<'a> BitOr<Integer> for &'a Integer
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: Integer) -> Integer | [src] |
impl<'a> BitOr<&'a Integer> for &'a Integer
[src]
impl<'a> BitOr<&'a Integer> for &'a Integer
type Output = BitOrIncomplete<'a>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &'a Integer) -> BitOrIncomplete | [src] |
impl BitOr<i32> for Integer
[src]
impl BitOr<i32> for Integer
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: i32) -> Integer | [src] |
impl<'t> BitOr<&'t i32> for Integer
[src]
impl<'t> BitOr<&'t i32> for Integer
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: &i32) -> Integer | [src] |
impl<'b> BitOr<i32> for &'b Integer
[src]
impl<'b> BitOr<i32> for &'b Integer
type Output = BitOrI32Incomplete<'b>
The resulting type after applying the |
operator.
fn bitor(self, rhs: i32) -> BitOrI32Incomplete<'b> | [src] |
impl<'t, 'b> BitOr<&'t i32> for &'b Integer
[src]
impl<'t, 'b> BitOr<&'t i32> for &'b Integer
type Output = BitOrI32Incomplete<'b>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &i32) -> BitOrI32Incomplete<'b> | [src] |
impl BitOr<Integer> for i32
[src]
impl BitOr<Integer> for i32
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: Integer) -> Integer | [src] |
impl<'b> BitOr<&'b Integer> for i32
[src]
impl<'b> BitOr<&'b Integer> for i32
type Output = BitOrI32Incomplete<'b>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &Integer) -> BitOrI32Incomplete | [src] |
impl<'t> BitOr<Integer> for &'t i32
[src]
impl<'t> BitOr<Integer> for &'t i32
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> BitOr<&'b Integer> for &'t i32
[src]
impl<'b, 't> BitOr<&'b Integer> for &'t i32
type Output = BitOrI32Incomplete<'b>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &Integer) -> BitOrI32Incomplete | [src] |
impl BitOr<u32> for Integer
[src]
impl BitOr<u32> for Integer
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: u32) -> Integer | [src] |
impl<'t> BitOr<&'t u32> for Integer
[src]
impl<'t> BitOr<&'t u32> for Integer
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: &u32) -> Integer | [src] |
impl<'b> BitOr<u32> for &'b Integer
[src]
impl<'b> BitOr<u32> for &'b Integer
type Output = BitOrU32Incomplete<'b>
The resulting type after applying the |
operator.
fn bitor(self, rhs: u32) -> BitOrU32Incomplete<'b> | [src] |
impl<'t, 'b> BitOr<&'t u32> for &'b Integer
[src]
impl<'t, 'b> BitOr<&'t u32> for &'b Integer
type Output = BitOrU32Incomplete<'b>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &u32) -> BitOrU32Incomplete<'b> | [src] |
impl BitOr<Integer> for u32
[src]
impl BitOr<Integer> for u32
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: Integer) -> Integer | [src] |
impl<'b> BitOr<&'b Integer> for u32
[src]
impl<'b> BitOr<&'b Integer> for u32
type Output = BitOrU32Incomplete<'b>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &Integer) -> BitOrU32Incomplete | [src] |
impl<'t> BitOr<Integer> for &'t u32
[src]
impl<'t> BitOr<Integer> for &'t u32
type Output = Integer
The resulting type after applying the |
operator.
fn bitor(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> BitOr<&'b Integer> for &'t u32
[src]
impl<'b, 't> BitOr<&'b Integer> for &'t u32
type Output = BitOrU32Incomplete<'b>
The resulting type after applying the |
operator.
fn bitor(self, rhs: &Integer) -> BitOrU32Incomplete | [src] |
impl BitXor<Integer> for Integer
[src]
impl BitXor<Integer> for Integer
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: Integer) -> Integer | [src] |
impl<'a> BitXor<&'a Integer> for Integer
[src]
impl<'a> BitXor<&'a Integer> for Integer
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &Integer) -> Integer | [src] |
impl<'a> BitXor<Integer> for &'a Integer
[src]
impl<'a> BitXor<Integer> for &'a Integer
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: Integer) -> Integer | [src] |
impl<'a> BitXor<&'a Integer> for &'a Integer
[src]
impl<'a> BitXor<&'a Integer> for &'a Integer
type Output = BitXorIncomplete<'a>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &'a Integer) -> BitXorIncomplete | [src] |
impl BitXor<i32> for Integer
[src]
impl BitXor<i32> for Integer
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: i32) -> Integer | [src] |
impl<'t> BitXor<&'t i32> for Integer
[src]
impl<'t> BitXor<&'t i32> for Integer
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &i32) -> Integer | [src] |
impl<'b> BitXor<i32> for &'b Integer
[src]
impl<'b> BitXor<i32> for &'b Integer
type Output = BitXorI32Incomplete<'b>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: i32) -> BitXorI32Incomplete<'b> | [src] |
impl<'t, 'b> BitXor<&'t i32> for &'b Integer
[src]
impl<'t, 'b> BitXor<&'t i32> for &'b Integer
type Output = BitXorI32Incomplete<'b>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &i32) -> BitXorI32Incomplete<'b> | [src] |
impl BitXor<Integer> for i32
[src]
impl BitXor<Integer> for i32
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: Integer) -> Integer | [src] |
impl<'b> BitXor<&'b Integer> for i32
[src]
impl<'b> BitXor<&'b Integer> for i32
type Output = BitXorI32Incomplete<'b>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &Integer) -> BitXorI32Incomplete | [src] |
impl<'t> BitXor<Integer> for &'t i32
[src]
impl<'t> BitXor<Integer> for &'t i32
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> BitXor<&'b Integer> for &'t i32
[src]
impl<'b, 't> BitXor<&'b Integer> for &'t i32
type Output = BitXorI32Incomplete<'b>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &Integer) -> BitXorI32Incomplete | [src] |
impl BitXor<u32> for Integer
[src]
impl BitXor<u32> for Integer
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: u32) -> Integer | [src] |
impl<'t> BitXor<&'t u32> for Integer
[src]
impl<'t> BitXor<&'t u32> for Integer
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &u32) -> Integer | [src] |
impl<'b> BitXor<u32> for &'b Integer
[src]
impl<'b> BitXor<u32> for &'b Integer
type Output = BitXorU32Incomplete<'b>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: u32) -> BitXorU32Incomplete<'b> | [src] |
impl<'t, 'b> BitXor<&'t u32> for &'b Integer
[src]
impl<'t, 'b> BitXor<&'t u32> for &'b Integer
type Output = BitXorU32Incomplete<'b>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &u32) -> BitXorU32Incomplete<'b> | [src] |
impl BitXor<Integer> for u32
[src]
impl BitXor<Integer> for u32
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: Integer) -> Integer | [src] |
impl<'b> BitXor<&'b Integer> for u32
[src]
impl<'b> BitXor<&'b Integer> for u32
type Output = BitXorU32Incomplete<'b>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &Integer) -> BitXorU32Incomplete | [src] |
impl<'t> BitXor<Integer> for &'t u32
[src]
impl<'t> BitXor<Integer> for &'t u32
type Output = Integer
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: Integer) -> Integer | [src] |
impl<'b, 't> BitXor<&'b Integer> for &'t u32
[src]
impl<'b, 't> BitXor<&'b Integer> for &'t u32
type Output = BitXorU32Incomplete<'b>
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &Integer) -> BitXorU32Incomplete | [src] |
impl Shl<i32> for Integer
[src]
impl Shl<i32> for Integer
type Output = Integer
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> Integer | [src] |
impl<'t> Shl<&'t i32> for Integer
[src]
impl<'t> Shl<&'t i32> for Integer
type Output = Integer
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i32) -> Integer | [src] |
impl<'b> Shl<i32> for &'b Integer
[src]
impl<'b> Shl<i32> for &'b Integer
type Output = ShlI32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> ShlI32Incomplete<'b> | [src] |
impl<'t, 'b> Shl<&'t i32> for &'b Integer
[src]
impl<'t, 'b> Shl<&'t i32> for &'b Integer
type Output = ShlI32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &i32) -> ShlI32Incomplete<'b> | [src] |
impl Shl<u32> for Integer
[src]
impl Shl<u32> for Integer
type Output = Integer
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> Integer | [src] |
impl<'t> Shl<&'t u32> for Integer
[src]
impl<'t> Shl<&'t u32> for Integer
type Output = Integer
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u32) -> Integer | [src] |
impl<'b> Shl<u32> for &'b Integer
[src]
impl<'b> Shl<u32> for &'b Integer
type Output = ShlU32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> ShlU32Incomplete<'b> | [src] |
impl<'t, 'b> Shl<&'t u32> for &'b Integer
[src]
impl<'t, 'b> Shl<&'t u32> for &'b Integer
type Output = ShlU32Incomplete<'b>
The resulting type after applying the <<
operator.
fn shl(self, rhs: &u32) -> ShlU32Incomplete<'b> | [src] |
impl Shr<i32> for Integer
[src]
impl Shr<i32> for Integer
type Output = Integer
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> Integer | [src] |
impl<'t> Shr<&'t i32> for Integer
[src]
impl<'t> Shr<&'t i32> for Integer
type Output = Integer
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i32) -> Integer | [src] |
impl<'b> Shr<i32> for &'b Integer
[src]
impl<'b> Shr<i32> for &'b Integer
type Output = ShrI32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> ShrI32Incomplete<'b> | [src] |
impl<'t, 'b> Shr<&'t i32> for &'b Integer
[src]
impl<'t, 'b> Shr<&'t i32> for &'b Integer
type Output = ShrI32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &i32) -> ShrI32Incomplete<'b> | [src] |
impl Shr<u32> for Integer
[src]
impl Shr<u32> for Integer
type Output = Integer
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> Integer | [src] |
impl<'t> Shr<&'t u32> for Integer
[src]
impl<'t> Shr<&'t u32> for Integer
type Output = Integer
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u32) -> Integer | [src] |
impl<'b> Shr<u32> for &'b Integer
[src]
impl<'b> Shr<u32> for &'b Integer
type Output = ShrU32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> ShrU32Incomplete<'b> | [src] |
impl<'t, 'b> Shr<&'t u32> for &'b Integer
[src]
impl<'t, 'b> Shr<&'t u32> for &'b Integer
type Output = ShrU32Incomplete<'b>
The resulting type after applying the >>
operator.
fn shr(self, rhs: &u32) -> ShrU32Incomplete<'b> | [src] |
impl BitAndAssign<Integer> for Integer
[src]
impl BitAndAssign<Integer> for Integer
fn bitand_assign(&mut self, rhs: Integer) | [src] |
impl<'a> BitAndAssign<&'a Integer> for Integer
[src]
impl<'a> BitAndAssign<&'a Integer> for Integer
fn bitand_assign(&mut self, rhs: &Integer) | [src] |
impl BitAndAssign<i32> for Integer
[src]
impl BitAndAssign<i32> for Integer
fn bitand_assign(&mut self, rhs: i32) | [src] |
impl<'t> BitAndAssign<&'t i32> for Integer
[src]
impl<'t> BitAndAssign<&'t i32> for Integer
fn bitand_assign(&mut self, rhs: &i32) | [src] |
impl BitAndAssign<u32> for Integer
[src]
impl BitAndAssign<u32> for Integer
fn bitand_assign(&mut self, rhs: u32) | [src] |
impl<'t> BitAndAssign<&'t u32> for Integer
[src]
impl<'t> BitAndAssign<&'t u32> for Integer
fn bitand_assign(&mut self, rhs: &u32) | [src] |
impl BitOrAssign<Integer> for Integer
[src]
impl BitOrAssign<Integer> for Integer
fn bitor_assign(&mut self, rhs: Integer) | [src] |
impl<'a> BitOrAssign<&'a Integer> for Integer
[src]
impl<'a> BitOrAssign<&'a Integer> for Integer
fn bitor_assign(&mut self, rhs: &Integer) | [src] |
impl BitOrAssign<i32> for Integer
[src]
impl BitOrAssign<i32> for Integer
fn bitor_assign(&mut self, rhs: i32) | [src] |
impl<'t> BitOrAssign<&'t i32> for Integer
[src]
impl<'t> BitOrAssign<&'t i32> for Integer
fn bitor_assign(&mut self, rhs: &i32) | [src] |
impl BitOrAssign<u32> for Integer
[src]
impl BitOrAssign<u32> for Integer
fn bitor_assign(&mut self, rhs: u32) | [src] |
impl<'t> BitOrAssign<&'t u32> for Integer
[src]
impl<'t> BitOrAssign<&'t u32> for Integer
fn bitor_assign(&mut self, rhs: &u32) | [src] |
impl BitXorAssign<Integer> for Integer
[src]
impl BitXorAssign<Integer> for Integer
fn bitxor_assign(&mut self, rhs: Integer) | [src] |
impl<'a> BitXorAssign<&'a Integer> for Integer
[src]
impl<'a> BitXorAssign<&'a Integer> for Integer
fn bitxor_assign(&mut self, rhs: &Integer) | [src] |
impl BitXorAssign<i32> for Integer
[src]
impl BitXorAssign<i32> for Integer
fn bitxor_assign(&mut self, rhs: i32) | [src] |
impl<'t> BitXorAssign<&'t i32> for Integer
[src]
impl<'t> BitXorAssign<&'t i32> for Integer
fn bitxor_assign(&mut self, rhs: &i32) | [src] |
impl BitXorAssign<u32> for Integer
[src]
impl BitXorAssign<u32> for Integer
fn bitxor_assign(&mut self, rhs: u32) | [src] |
impl<'t> BitXorAssign<&'t u32> for Integer
[src]
impl<'t> BitXorAssign<&'t u32> for Integer
fn bitxor_assign(&mut self, rhs: &u32) | [src] |
impl ShlAssign<i32> for Integer
[src]
impl ShlAssign<i32> for Integer
fn shl_assign(&mut self, rhs: i32) | [src] |
impl<'t> ShlAssign<&'t i32> for Integer
[src]
impl<'t> ShlAssign<&'t i32> for Integer
fn shl_assign(&mut self, rhs: &i32) | [src] |
impl ShlAssign<u32> for Integer
[src]
impl ShlAssign<u32> for Integer
fn shl_assign(&mut self, rhs: u32) | [src] |
impl<'t> ShlAssign<&'t u32> for Integer
[src]
impl<'t> ShlAssign<&'t u32> for Integer
fn shl_assign(&mut self, rhs: &u32) | [src] |
impl ShrAssign<i32> for Integer
[src]
impl ShrAssign<i32> for Integer
fn shr_assign(&mut self, rhs: i32) | [src] |
impl<'t> ShrAssign<&'t i32> for Integer
[src]
impl<'t> ShrAssign<&'t i32> for Integer
fn shr_assign(&mut self, rhs: &i32) | [src] |
impl ShrAssign<u32> for Integer
[src]
impl ShrAssign<u32> for Integer
fn shr_assign(&mut self, rhs: u32) | [src] |
impl<'t> ShrAssign<&'t u32> for Integer
[src]
impl<'t> ShrAssign<&'t u32> for Integer
fn shr_assign(&mut self, rhs: &u32) | [src] |
impl<T> Product<T> for Integer where
Integer: MulAssign<T>,
[src]
impl<T> Product<T> for Integer where
Integer: MulAssign<T>,
impl<T> Sum<T> for Integer where
Integer: AddAssign<T>,
[src]
impl<T> Sum<T> for Integer where
Integer: AddAssign<T>,
impl FromStr for Integer
[src]
impl FromStr for Integer
type Err = ParseIntegerError
The associated error which can be returned from parsing.
fn from_str(src: &str) -> Result<Integer, ParseIntegerError> | [src] |
impl TryFrom<Integer> for i8
[src]
impl TryFrom<Integer> for i8
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for i8
[src]
impl<'a> TryFrom<&'a Integer> for i8
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl TryFrom<Integer> for i16
[src]
impl TryFrom<Integer> for i16
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for i16
[src]
impl<'a> TryFrom<&'a Integer> for i16
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl TryFrom<Integer> for i32
[src]
impl TryFrom<Integer> for i32
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for i32
[src]
impl<'a> TryFrom<&'a Integer> for i32
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl TryFrom<Integer> for i64
[src]
impl TryFrom<Integer> for i64
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for i64
[src]
impl<'a> TryFrom<&'a Integer> for i64
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl TryFrom<Integer> for i128
[src]
impl TryFrom<Integer> for i128
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for i128
[src]
impl<'a> TryFrom<&'a Integer> for i128
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl TryFrom<Integer> for isize
[src]
impl TryFrom<Integer> for isize
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for isize
[src]
impl<'a> TryFrom<&'a Integer> for isize
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl TryFrom<Integer> for u8
[src]
impl TryFrom<Integer> for u8
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for u8
[src]
impl<'a> TryFrom<&'a Integer> for u8
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl TryFrom<Integer> for u16
[src]
impl TryFrom<Integer> for u16
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for u16
[src]
impl<'a> TryFrom<&'a Integer> for u16
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl TryFrom<Integer> for u32
[src]
impl TryFrom<Integer> for u32
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for u32
[src]
impl<'a> TryFrom<&'a Integer> for u32
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl TryFrom<Integer> for u64
[src]
impl TryFrom<Integer> for u64
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for u64
[src]
impl<'a> TryFrom<&'a Integer> for u64
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl TryFrom<Integer> for u128
[src]
impl TryFrom<Integer> for u128
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for u128
[src]
impl<'a> TryFrom<&'a Integer> for u128
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl TryFrom<Integer> for usize
[src]
impl TryFrom<Integer> for usize
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl<'a> TryFrom<&'a Integer> for usize
[src]
impl<'a> TryFrom<&'a Integer> for usize
type Error = TryFromIntegerError
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError> | [src] |
impl Serialize for Integer
[src]
impl Serialize for Integer
impl<'de> Deserialize<'de> for Integer
[src]
impl<'de> Deserialize<'de> for Integer
fn deserialize<D>(deserializer: D) -> Result<Integer, D::Error> where | [src] |
fn deserialize_in_place<D>( | [src] |
Blanket Implementations
impl<T> From for T
[src]
impl<T> From for T
impl<T, U> Into for T where
U: From<T>,
[src]
impl<T, U> Into for T where
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
impl<T> ToString for T where
T: Display + ?Sized,
[src]
impl<T> ToString for T where
T: Display + ?Sized,
impl<T, U> TryFrom for T where
T: From<U>,
[src]
impl<T, U> TryFrom for T where
T: From<U>,
type Error = !
try_from
)The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error> | [src] |
impl<T> Borrow for T where
T: ?Sized,
[src]
impl<T> Borrow for T where
T: ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
impl<T> BorrowMut for T where
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T | [src] |
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
try_from
)The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error> | [src] |
impl<T> Any for T where
T: 'static + ?Sized,
[src]
impl<T> Any for T where
T: 'static + ?Sized,
fn get_type_id(&self) -> TypeId | [src] |
impl<T> DeserializeOwned for T where
T: Deserialize<'de>,
[src]
impl<T> DeserializeOwned for T where
T: Deserialize<'de>,