#[repr(transparent)]pub struct Integer { /* private fields */ }
Expand description
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);
Implementations
sourceimpl Integer
impl Integer
sourcepub fn with_capacity(bits: usize) -> Self
pub fn with_capacity(bits: usize) -> Self
sourcepub fn capacity(&self) -> usize
pub fn capacity(&self) -> usize
Returns the capacity in bits that can be stored without reallocating.
Examples
use rug::Integer;
let i = Integer::with_capacity(137);
assert!(i.capacity() >= 137);
sourcepub fn reserve(&mut self, additional: usize)
pub fn reserve(&mut self, additional: usize)
Reserves capacity for at least additional
more bits in the
Integer
.
If the integer already has enough excess capacity, this function does nothing.
Examples
use rug::Integer;
// 0x2000_0000 needs 30 bits.
let mut i = Integer::from(0x2000_0000);
assert_eq!(i.significant_bits(), 30);
i.reserve(290);
let capacity = i.capacity();
assert!(capacity >= 320);
i.reserve(0);
assert_eq!(i.capacity(), capacity);
i.reserve(291);
assert!(i.capacity() >= 321);
sourcepub fn shrink_to_fit(&mut self)
pub fn shrink_to_fit(&mut self)
Shrinks the capacity of the Integer
as much as possible.
The capacity can still be larger than the number of significant bits.
Examples
use rug::Integer;
// let i be 100 bits wide
let mut i = Integer::from_str_radix("fffff12345678901234567890", 16)
.unwrap();
assert_eq!(i.significant_bits(), 100);
assert!(i.capacity() >= 100);
i >>= 80;
i.shrink_to_fit();
assert!(i.capacity() >= 20);
sourcepub fn shrink_to(&mut self, min_capacity: usize)
pub fn shrink_to(&mut self, min_capacity: usize)
Shrinks the capacity of the Integer
with a lower bound in bits.
The capacity will remain at least as large as both the current number of siginificant bits and the supplied value.
If the current capacity is less than the lower limit, this method has no effect.
Examples
use rug::Integer;
// let i be 100 bits wide
let mut i = Integer::from_str_radix("fffff12345678901234567890", 16)
.unwrap();
assert_eq!(i.significant_bits(), 100);
assert!(i.capacity() >= 100);
i >>= 80;
i.shrink_to(50);
assert!(i.capacity() >= 50);
i.shrink_to(0);
assert!(i.capacity() >= 20);
sourcepub const unsafe fn from_raw(raw: mpz_t) -> Self
pub const unsafe fn from_raw(raw: mpz_t) -> Self
Creates an Integer
from an initialized GMP integer.
Safety
- The function must not be used to create a constant
Integer
, though it can be used to create a staticInteger
. This is because constant values are copied on use, leading to undefined behavior when they are dropped. - The value must be initialized.
- The
mpz_t
type can be considered as a kind of pointer, so there can be multiple copies of it. Since this function takes over ownership, no other copies of the passed value should exist.
Examples
use core::mem::MaybeUninit;
use gmp_mpfr_sys::gmp;
use rug::Integer;
let i = unsafe {
let mut z = MaybeUninit::uninit();
gmp::mpz_init_set_ui(z.as_mut_ptr(), 15);
let z = z.assume_init();
// z is initialized and unique
Integer::from_raw(z)
};
assert_eq!(i, 15);
// since i is an Integer now, deallocation is automatic
This can be used to create a static Integer
using
MPZ_ROINIT_N
to initialize the raw value. See the
GMP documentation for details.
use gmp_mpfr_sys::gmp::{self, limb_t, mpz_t};
use rug::Integer;
const LIMBS: [limb_t; 2] = [123, 456];
const MPZ: mpz_t =
unsafe { gmp::MPZ_ROINIT_N(LIMBS.as_ptr() as *mut limb_t, -2) };
// Must *not* be const, otherwise it would lead to undefined
// behavior on use, as it would create a copy that is dropped.
static I: Integer = unsafe { Integer::from_raw(MPZ) };
let check = -((Integer::from(LIMBS[1]) << gmp::NUMB_BITS) + LIMBS[0]);
assert_eq!(I, check);
sourcepub const fn into_raw(self) -> mpz_t
pub const fn into_raw(self) -> mpz_t
Converts an Integer
into a GMP integer.
The returned object should be freed to avoid memory leaks.
Examples
use gmp_mpfr_sys::gmp;
use rug::Integer;
let i = Integer::from(15);
let mut z = i.into_raw();
unsafe {
let u = gmp::mpz_get_ui(&z);
assert_eq!(u, 15);
// free object to prevent memory leak
gmp::mpz_clear(&mut z);
}
sourcepub const fn as_raw(&self) -> *const mpz_t
pub const fn as_raw(&self) -> *const mpz_t
Returns a pointer to the inner GMP integer.
The returned pointer will be valid for as long as self
is valid.
Examples
use gmp_mpfr_sys::gmp;
use rug::Integer;
let i = Integer::from(15);
let z_ptr = i.as_raw();
unsafe {
let u = gmp::mpz_get_ui(z_ptr);
assert_eq!(u, 15);
}
// i is still valid
assert_eq!(i, 15);
sourcepub fn as_raw_mut(&mut self) -> *mut mpz_t
pub fn as_raw_mut(&mut self) -> *mut mpz_t
Returns an unsafe mutable pointer to the inner GMP integer.
The returned pointer will be valid for as long as self
is valid.
Examples
use gmp_mpfr_sys::gmp;
use rug::Integer;
let mut i = Integer::from(15);
let z_ptr = i.as_raw_mut();
unsafe {
gmp::mpz_add_ui(z_ptr, z_ptr, 20);
}
assert_eq!(i, 35);
sourcepub fn from_digits<T: UnsignedPrimitive>(digits: &[T], order: Order) -> Self
pub fn from_digits<T: UnsignedPrimitive>(digits: &[T], order: Order) -> Self
Creates an Integer
from a slice of digits of type T
, where T
can be any unsigned integer primitive type.
The resulting value cannot be negative.
Examples
use rug::{integer::Order, Integer};
let digits = [0x5678u16, 0x1234u16];
let i = Integer::from_digits(&digits, Order::Lsf);
assert_eq!(i, 0x1234_5678);
sourcepub fn assign_digits<T: UnsignedPrimitive>(&mut self, digits: &[T], order: Order)
pub fn assign_digits<T: UnsignedPrimitive>(&mut self, digits: &[T], order: Order)
Assigns from a slice of digits of type T
, where T
can be any
unsigned integer primitive type.
The resulting value cannot be negative.
Examples
use rug::{integer::Order, Integer};
let digits = [0x5678u16, 0x1234u16];
let mut i = Integer::new();
i.assign_digits(&digits, Order::Lsf);
assert_eq!(i, 0x1234_5678);
sourcepub unsafe fn assign_digits_unaligned<T: UnsignedPrimitive>(
&mut self,
src: *const T,
len: usize,
order: Order
)
pub unsafe fn assign_digits_unaligned<T: UnsignedPrimitive>(
&mut self,
src: *const T,
len: usize,
order: Order
)
Assigns from digits of type T
in a memory area, where T
can be any
unsigned integer primitive type.
The memory area is addressed using a pointer and a length. The len
parameter is the number of digits, not the number of bytes.
There are no data alignment restrictions on src
, any address is
allowed.
The resulting value cannot be negative.
Safety
To avoid undefined behavior, src
must be valid for reading len
digits, that is len
× size_of::<T>()
bytes.
Examples
use rug::{integer::Order, Integer};
// hex bytes: [ fe dc ba 98 87 87 87 87 76 54 32 10 ]
let digits = [
0xfedc_ba98u32.to_be(),
0x8787_8787u32.to_be(),
0x7654_3210u32.to_be(),
];
let ptr = digits.as_ptr();
let mut i = Integer::new();
unsafe {
let unaligned = (ptr as *const u8).offset(2) as *const u32;
i.assign_digits_unaligned(unaligned, 2, Order::MsfBe);
}
assert_eq!(i, 0xba98_8787_8787_7654u64);
sourcepub fn significant_digits<T: UnsignedPrimitive>(&self) -> usize
pub fn significant_digits<T: UnsignedPrimitive>(&self) -> usize
Returns the number of digits of type T
required to represent the
absolute value.
T
can be any unsigned integer primitive type.
Examples
use rug::Integer;
let i: Integer = Integer::from(1) << 256;
assert_eq!(i.significant_digits::<bool>(), 257);
assert_eq!(i.significant_digits::<u8>(), 33);
assert_eq!(i.significant_digits::<u16>(), 17);
assert_eq!(i.significant_digits::<u32>(), 9);
assert_eq!(i.significant_digits::<u64>(), 5);
sourcepub fn to_digits<T: UnsignedPrimitive>(&self, order: Order) -> Vec<T>
pub fn to_digits<T: UnsignedPrimitive>(&self, order: Order) -> Vec<T>
Converts the absolute value to a Vec
of digits of type T
, where
T
can be any unsigned integer primitive type.
The Integer
type also has the as_limbs
method, which can be used to borrow the digits without copying them.
This does come with some more constraints compared to to_digits
:
- The digit width is not optional and depends on the implementation:
limb_t
is typicallyu64
on 64-bit systems andu32
on 32-bit systems. - The order is not optional and is least significant digit first, with
each digit in the target’s endianness, equivalent to
Order::Lsf
.
Examples
use rug::{integer::Order, 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());
sourcepub fn write_digits<T: UnsignedPrimitive>(&self, digits: &mut [T], order: Order)
pub fn write_digits<T: UnsignedPrimitive>(&self, digits: &mut [T], order: Order)
Writes the absolute value into a slice of digits of type T
, where
T
can be any unsigned integer primitive type.
The slice must be large enough to hold the digits; the minimum size can
be obtained using the significant_digits
method.
Panics
Panics if the slice does not have sufficient capacity.
Examples
use rug::{integer::Order, 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()]);
sourcepub unsafe fn write_digits_unaligned<T: UnsignedPrimitive>(
&self,
dst: *mut T,
len: usize,
order: Order
)
pub unsafe fn write_digits_unaligned<T: UnsignedPrimitive>(
&self,
dst: *mut T,
len: usize,
order: Order
)
Writes the absolute value into a memory area of digits of type T
,
where T
can be any unsigned integer primitive
type.
The memory area is addressed using a pointer and a length. The len
parameter is the number of digits, not the number of bytes.
The length must be large enough to hold the digits; the minimum length
can be obtained using the significant_digits
method.
There are no data alignment restrictions on dst
, any address is
allowed.
The memory locations can be uninitialized before this method is called;
this method sets all len
elements, padding with zeros if the length is
larger than required.
Safety
To avoid undefined behavior, dst
must be valid for writing len
digits, that is len
× size_of::<T>()
bytes.
Panics
Panics if the length is less than the number of digits.
Examples
use rug::{integer::Order, Integer};
let i = Integer::from(0xfedc_ba98_7654_3210u64);
let mut digits = [0xffff_ffffu32; 4];
let ptr = digits.as_mut_ptr();
unsafe {
let unaligned = (ptr as *mut u8).offset(2) as *mut u32;
i.write_digits_unaligned(unaligned, 3, Order::MsfBe);
}
assert_eq!(
digits,
[
0xffff_0000u32.to_be(),
0x0000_fedcu32.to_be(),
0xba98_7654u32.to_be(),
0x3210_ffffu32.to_be(),
]
);
The following example shows how to write into uninitialized memory. In
practice, the following code could be replaced by a call to the safe
method to_digits
.
use rug::{integer::Order, Integer};
let i = Integer::from(0x1234_5678_9abc_def0u64);
let len = i.significant_digits::<u32>();
assert_eq!(len, 2);
// The following code is equivalent to:
// let digits = i.to_digits::<u32>(Order::MsfBe);
let mut digits = Vec::<u32>::with_capacity(len);
let ptr = digits.as_mut_ptr();
unsafe {
i.write_digits_unaligned(ptr, len, Order::MsfBe);
digits.set_len(len);
}
assert_eq!(digits, [0x1234_5678u32.to_be(), 0x9abc_def0u32.to_be()]);
sourcepub fn as_limbs(&self) -> &[limb_t]
pub fn as_limbs(&self) -> &[limb_t]
Extracts a slice of limbs used to store the value.
The slice contains the absolute value of self
, with the least
significant limb first.
The Integer
type also implements
AsRef<[limb_t]>
, which is
equivalent to this method.
Examples
use rug::Integer;
assert!(Integer::new().as_limbs().is_empty());
assert_eq!(Integer::from(13).as_limbs(), &[13]);
assert_eq!(Integer::from(-23).as_limbs(), &[23]);
int.as_limbs()
is like a borrowing non-copy version of
int.to_digits::<[limb_t]>(Order::Lsf)
.
use gmp_mpfr_sys::gmp::limb_t;
use rug::{integer::Order, Integer};
let int = Integer::from(0x1234_5678_9abc_def0u64);
// no copying for int_slice, which is borrowing int
let int_slice = int.as_limbs();
// digits is a copy and does not borrow int
let digits = int.to_digits::<limb_t>(Order::Lsf);
// no copying for digits_slice, which is borrowing digits
let digits_slice = &digits[..];
assert_eq!(int_slice, digits_slice);
sourcepub fn from_f32(value: f32) -> Option<Self>
pub fn from_f32(value: f32) -> Option<Self>
Creates an Integer
from an f32
if it is
finite, rounding towards zero.
This conversion can also be performed using
value.checked_as::<Integer>()
.
Examples
use core::f32;
use rug::Integer;
let i = Integer::from_f32(-5.6).unwrap();
assert_eq!(i, -5);
let neg_inf = Integer::from_f32(f32::NEG_INFINITY);
assert!(neg_inf.is_none());
sourcepub fn from_f64(value: f64) -> Option<Self>
pub fn from_f64(value: f64) -> Option<Self>
Creates an Integer
from an f64
if it is
finite, rounding towards zero.
This conversion can also be performed using
value.checked_as::<Integer>()
.
Examples
use core::f64;
use rug::Integer;
let i = Integer::from_f64(1e20).unwrap();
assert_eq!(i, "100000000000000000000".parse::<Integer>().unwrap());
let inf = Integer::from_f64(f64::INFINITY);
assert!(inf.is_none());
sourcepub fn from_str_radix(src: &str, radix: i32) -> Result<Self, ParseIntegerError>
pub fn from_str_radix(src: &str, radix: i32) -> Result<Self, ParseIntegerError>
sourcepub fn parse<S: AsRef<[u8]>>(
src: S
) -> Result<ParseIncomplete, ParseIntegerError>
pub fn parse<S: AsRef<[u8]>>(
src: S
) -> Result<ParseIncomplete, ParseIntegerError>
Parses a decimal string slice (&str
) or byte slice
(&[u8]
) into an Integer
.
The following are implemented with the unwrapped returned
incomplete-computation value as Src
:
The string can start with an optional minus or plus sign. ASCII whitespace is ignored everywhere in the string. Underscores anywhere except before the first digit are ignored as well.
Examples
use rug::{Complete, Integer};
assert_eq!(Integer::parse("1223").unwrap().complete(), 1223);
assert_eq!(Integer::parse("123 456 789").unwrap().complete(), 123_456_789);
let invalid = Integer::parse("789a");
assert!(invalid.is_err());
sourcepub fn parse_radix<S: AsRef<[u8]>>(
src: S,
radix: i32
) -> Result<ParseIncomplete, ParseIntegerError>
pub fn parse_radix<S: AsRef<[u8]>>(
src: S,
radix: i32
) -> Result<ParseIncomplete, ParseIntegerError>
Parses a string slice (&str
) or byte slice
(&[u8]
) into an
Integer
.
The following are implemented with the unwrapped returned
incomplete-computation value as Src
:
The string can start with an optional minus or plus sign. ASCII whitespace is ignored everywhere in the string. Underscores anywhere except before the first digit are ignored as well.
See also assign_bytes_radix_unchecked
, which is an unsafe low-level
method that can be used if parsing is already done by an external
function.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::{Complete, Integer};
let valid1 = Integer::parse_radix("1223", 4);
assert_eq!(valid1.unwrap().complete(), 3 + 4 * (2 + 4 * (2 + 4 * 1)));
let valid2 = Integer::parse_radix("1234 abcd", 16);
assert_eq!(valid2.unwrap().complete(), 0x1234_abcd);
let invalid = Integer::parse_radix("123", 3);
assert!(invalid.is_err());
sourcepub unsafe fn assign_bytes_radix_unchecked(
&mut self,
bytes: &[u8],
radix: i32,
is_negative: bool
)
pub unsafe fn assign_bytes_radix_unchecked(
&mut self,
bytes: &[u8],
radix: i32,
is_negative: bool
)
Assigns from bytes in the given radix.
The radix must be between 2 and 256 inclusive.
Each byte must be a value from 0 to radix - 1
, not an ASCII character.
The bytes must be ordered most-significant byte first.
If is_negative
is true
, the returned value is negative (unless it is 0).
Safety
The caller must ensure that
- 2 ≤
radix
≤ 256 - all bytes are in the range 0 ≤ x <
radix
Examples
use rug::Integer;
let bytes = &[0, 3, 9, 2];
let radix = 10;
let neg = true;
let mut i = Integer::new();
// SAFETY: radix and bytes are in the required ranges
unsafe {
i.assign_bytes_radix_unchecked(bytes, radix, neg);
}
assert_eq!(i, -392);
sourcepub fn to_i8(&self) -> Option<i8>
pub fn to_i8(&self) -> Option<i8>
Converts to an i8
if the value fits.
This conversion can also be performed using
i8::try_from(&integer)
i8::try_from(integer)
(&integer).checked_as::<i8>()
integer.borrow().checked_as::<i8>()
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);
sourcepub fn to_i16(&self) -> Option<i16>
pub fn to_i16(&self) -> Option<i16>
Converts to an i16
if the value fits.
This conversion can also be performed using
i16::try_from(&integer)
i16::try_from(integer)
(&integer).checked_as::<i16>()
integer.borrow().checked_as::<i16>()
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);
sourcepub fn to_i32(&self) -> Option<i32>
pub fn to_i32(&self) -> Option<i32>
Converts to an i32
if the value fits.
This conversion can also be performed using
i32::try_from(&integer)
i32::try_from(integer)
(&integer).checked_as::<i32>()
integer.borrow().checked_as::<i32>()
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);
sourcepub fn to_i64(&self) -> Option<i64>
pub fn to_i64(&self) -> Option<i64>
Converts to an i64
if the value fits.
This conversion can also be performed using
i64::try_from(&integer)
i64::try_from(integer)
(&integer).checked_as::<i64>()
integer.borrow().checked_as::<i64>()
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);
sourcepub fn to_i128(&self) -> Option<i128>
pub fn to_i128(&self) -> Option<i128>
Converts to an i128
if the value fits.
This conversion can also be performed using
i128::try_from(&integer)
i128::try_from(integer)
(&integer).checked_as::<i128>()
integer.borrow().checked_as::<i128>()
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);
sourcepub fn to_isize(&self) -> Option<isize>
pub fn to_isize(&self) -> Option<isize>
Converts to an isize
if the value fits.
This conversion can also be performed using
isize::try_from(&integer)
isize::try_from(integer)
(&integer).checked_as::<isize>()
integer.borrow().checked_as::<isize>()
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);
sourcepub fn to_u8(&self) -> Option<u8>
pub fn to_u8(&self) -> Option<u8>
Converts to an u8
if the value fits.
This conversion can also be performed using
u8::try_from(&integer)
u8::try_from(integer)
(&integer).checked_as::<u8>()
integer.borrow().checked_as::<u8>()
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);
sourcepub fn to_u16(&self) -> Option<u16>
pub fn to_u16(&self) -> Option<u16>
Converts to an u16
if the value fits.
This conversion can also be performed using
u16::try_from(&integer)
u16::try_from(integer)
(&integer).checked_as::<u16>()
integer.borrow().checked_as::<u16>()
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);
sourcepub fn to_u32(&self) -> Option<u32>
pub fn to_u32(&self) -> Option<u32>
Converts to an u32
if the value fits.
This conversion can also be performed using
u32::try_from(&integer)
u32::try_from(integer)
(&integer).checked_as::<u32>()
integer.borrow().checked_as::<u32>()
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);
sourcepub fn to_u64(&self) -> Option<u64>
pub fn to_u64(&self) -> Option<u64>
Converts to an u64
if the value fits.
This conversion can also be performed using
u64::try_from(&integer)
u64::try_from(integer)
(&integer).checked_as::<u64>()
integer.borrow().checked_as::<u64>()
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);
sourcepub fn to_u128(&self) -> Option<u128>
pub fn to_u128(&self) -> Option<u128>
Converts to an u128
if the value fits.
This conversion can also be performed using
u128::try_from(&integer)
u128::try_from(integer)
(&integer).checked_as::<u128>()
integer.borrow().checked_as::<u128>()
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);
sourcepub fn to_usize(&self) -> Option<usize>
pub fn to_usize(&self) -> Option<usize>
Converts to an usize
if the value fits.
This conversion can also be performed using
usize::try_from(&integer)
usize::try_from(integer)
(&integer).checked_as::<usize>()
integer.borrow().checked_as::<usize>()
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);
sourcepub fn to_i8_wrapping(&self) -> i8
pub fn to_i8_wrapping(&self) -> i8
Converts to an i8
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<i8>()
integer.borrow().wrapping_as::<i8>()
Examples
use rug::Integer;
let large = Integer::from(0x1234);
assert_eq!(large.to_i8_wrapping(), 0x34);
sourcepub fn to_i16_wrapping(&self) -> i16
pub fn to_i16_wrapping(&self) -> i16
Converts to an i16
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<i16>()
integer.borrow().wrapping_as::<i16>()
Examples
use rug::Integer;
let large = Integer::from(0x1234_5678);
assert_eq!(large.to_i16_wrapping(), 0x5678);
sourcepub fn to_i32_wrapping(&self) -> i32
pub fn to_i32_wrapping(&self) -> i32
Converts to an i32
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<i32>()
integer.borrow().wrapping_as::<i32>()
Examples
use rug::Integer;
let large = Integer::from(0x1234_5678_9abc_def0_u64);
assert_eq!(large.to_i32_wrapping(), 0x9abc_def0_u32 as i32);
sourcepub fn to_i64_wrapping(&self) -> i64
pub fn to_i64_wrapping(&self) -> i64
Converts to an i64
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<i64>()
integer.borrow().wrapping_as::<i64>()
Examples
use rug::Integer;
let large = Integer::from_str_radix("f123456789abcdef0", 16).unwrap();
assert_eq!(large.to_i64_wrapping(), 0x1234_5678_9abc_def0);
sourcepub fn to_i128_wrapping(&self) -> i128
pub fn to_i128_wrapping(&self) -> i128
Converts to an i128
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<i128>()
integer.borrow().wrapping_as::<i128>()
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
);
sourcepub fn to_isize_wrapping(&self) -> isize
pub fn to_isize_wrapping(&self) -> isize
Converts to an isize
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<isize>()
integer.borrow().wrapping_as::<isize>()
Examples
use rug::Integer;
let large: Integer = (Integer::from(0x1000) << 128) | 0x1234;
assert_eq!(large.to_isize_wrapping(), 0x1234);
sourcepub fn to_u8_wrapping(&self) -> u8
pub fn to_u8_wrapping(&self) -> u8
Converts to a u8
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<u8>()
integer.borrow().wrapping_as::<u8>()
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);
sourcepub fn to_u16_wrapping(&self) -> u16
pub fn to_u16_wrapping(&self) -> u16
Converts to a u16
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<u16>()
integer.borrow().wrapping_as::<u16>()
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);
sourcepub fn to_u32_wrapping(&self) -> u32
pub fn to_u32_wrapping(&self) -> u32
Converts to a u32
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<u32>()
integer.borrow().wrapping_as::<u32>()
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);
sourcepub fn to_u64_wrapping(&self) -> u64
pub fn to_u64_wrapping(&self) -> u64
Converts to a u64
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<u64>()
integer.borrow().wrapping_as::<u64>()
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);
sourcepub fn to_u128_wrapping(&self) -> u128
pub fn to_u128_wrapping(&self) -> u128
Converts to a u128
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<u128>()
integer.borrow().wrapping_as::<u128>()
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
);
sourcepub fn to_usize_wrapping(&self) -> usize
pub fn to_usize_wrapping(&self) -> usize
Converts to a usize
, wrapping if the value does not fit.
This conversion can also be performed using
(&integer).wrapping_as::<usize>()
integer.borrow().wrapping_as::<usize>()
Examples
use rug::Integer;
let large: Integer = (Integer::from(0x1000) << 128) | 0x1234;
assert_eq!(large.to_usize_wrapping(), 0x1234);
sourcepub fn to_f32(&self) -> f32
pub fn to_f32(&self) -> f32
Converts to an f32
, rounding towards zero.
This conversion can also be performed using
Examples
use core::f32;
use rug::Integer;
let min = Integer::from_f32(f32::MIN).unwrap();
let min_minus_one = min - 1u32;
// min_minus_one is truncated to f32::MIN
assert_eq!(min_minus_one.to_f32(), f32::MIN);
let times_two = min_minus_one * 2u32;
// times_two is too small
assert_eq!(times_two.to_f32(), f32::NEG_INFINITY);
sourcepub fn to_f64(&self) -> f64
pub fn to_f64(&self) -> f64
Converts to an f64
, rounding towards zero.
This conversion can also be performed using
Examples
use core::f64;
use rug::Integer;
// An `f64` has 53 bits of precision.
let exact = 0x1f_ffff_ffff_ffff_u64;
let i = Integer::from(exact);
assert_eq!(i.to_f64(), exact as f64);
// large has 56 ones
let large = 0xff_ffff_ffff_ffff_u64;
// trunc has 53 ones followed by 3 zeros
let trunc = 0xff_ffff_ffff_fff8_u64;
let j = Integer::from(large);
assert_eq!(j.to_f64() as u64, trunc);
let max = Integer::from_f64(f64::MAX).unwrap();
let max_plus_one = max + 1u32;
// max_plus_one is truncated to f64::MAX
assert_eq!(max_plus_one.to_f64(), f64::MAX);
let times_two = max_plus_one * 2u32;
// times_two is too large
assert_eq!(times_two.to_f64(), f64::INFINITY);
sourcepub fn to_f32_exp(&self) -> (f32, u32)
pub fn to_f32_exp(&self) -> (f32, u32)
Converts to an f32
and an exponent, rounding towards zero.
The returned f32
is in the range
0.5 ≤ x < 1. If the value is zero, (0.0, 0)
is returned.
Examples
use rug::Integer;
let zero = Integer::new();
let (d0, exp0) = zero.to_f32_exp();
assert_eq!((d0, exp0), (0.0, 0));
let fifteen = Integer::from(15);
let (d15, exp15) = fifteen.to_f32_exp();
assert_eq!((d15, exp15), (15.0 / 16.0, 4));
sourcepub fn to_f64_exp(&self) -> (f64, u32)
pub fn to_f64_exp(&self) -> (f64, u32)
Converts to an f64
and an exponent, rounding towards zero.
The returned f64
is in the range
0.5 ≤ x < 1. If the value is zero, (0.0, 0)
is returned.
Examples
use rug::Integer;
let zero = Integer::new();
let (d0, exp0) = zero.to_f64_exp();
assert_eq!((d0, exp0), (0.0, 0));
let fifteen = Integer::from(15);
let (d15, exp15) = fifteen.to_f64_exp();
assert_eq!((d15, exp15), (15.0 / 16.0, 4));
sourcepub fn to_string_radix(&self, radix: i32) -> String
pub fn to_string_radix(&self, radix: i32) -> String
Returns a string representation of the number for the specified radix
.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::{Assign, Integer};
let mut i = Integer::new();
assert_eq!(i.to_string_radix(10), "0");
i.assign(-10);
assert_eq!(i.to_string_radix(16), "-a");
i.assign(0x1234cdef);
assert_eq!(i.to_string_radix(4), "102031030313233");
i.assign(Integer::parse_radix("123456789aAbBcCdDeEfF", 16).unwrap());
assert_eq!(i.to_string_radix(16), "123456789aabbccddeeff");
sourcepub fn as_neg(&self) -> BorrowInteger<'_>
pub fn as_neg(&self) -> BorrowInteger<'_>
Borrows a negated copy of the Integer
.
The returned object implements Deref<Target = Integer>
.
This method performs a shallow copy and negates it, and negation does not change the allocated data.
Examples
use rug::Integer;
let i = Integer::from(42);
let neg_i = i.as_neg();
assert_eq!(*neg_i, -42);
// methods taking &self can be used on the returned object
let reneg_i = neg_i.as_neg();
assert_eq!(*reneg_i, 42);
assert_eq!(*reneg_i, i);
sourcepub fn as_abs(&self) -> BorrowInteger<'_>
pub fn as_abs(&self) -> BorrowInteger<'_>
Borrows an absolute copy of the Integer
.
The returned object implements Deref<Target = Integer>
.
This method performs a shallow copy and possibly negates it, and negation does not change the allocated data.
Examples
use rug::Integer;
let i = Integer::from(-42);
let abs_i = i.as_abs();
assert_eq!(*abs_i, 42);
// methods taking &self can be used on the returned object
let reabs_i = abs_i.as_abs();
assert_eq!(*reabs_i, 42);
assert_eq!(*reabs_i, *abs_i);
sourcepub const fn as_rational(&self) -> BorrowRational<'_>
pub const fn as_rational(&self) -> BorrowRational<'_>
Borrows a copy of the Integer
as a Rational
number.
The returned object implements
Deref<Target = Rational>
.
Examples
use rug::Integer;
let i = Integer::from(42);
let r = i.as_rational();
assert_eq!(*r, (42, 1));
// methods taking &self can be used on the returned object
let recip_r = r.as_recip();
assert_eq!(*recip_r, (1, 42));
sourcepub fn is_divisible(&self, divisor: &Self) -> bool
pub fn is_divisible(&self, divisor: &Self) -> bool
sourcepub fn is_divisible_u(&self, divisor: u32) -> bool
pub fn is_divisible_u(&self, divisor: u32) -> bool
sourcepub fn is_divisible_2pow(&self, b: u32) -> bool
pub fn is_divisible_2pow(&self, b: u32) -> bool
sourcepub fn is_congruent(&self, c: &Self, divisor: &Self) -> bool
pub fn is_congruent(&self, c: &Self, divisor: &Self) -> bool
Returns true
if the number is congruent to c mod
divisor, that is, if there exists a q such that self
=
c + q × divisor. Unlike other division functions,
divisor
can be zero.
Examples
use rug::Integer;
let n = Integer::from(105);
let divisor = Integer::from(10);
assert!(n.is_congruent(&Integer::from(5), &divisor));
assert!(n.is_congruent(&Integer::from(25), &divisor));
assert!(!n.is_congruent(&Integer::from(7), &divisor));
// n is congruent to itself if divisor is 0
assert!(n.is_congruent(&n, &Integer::from(0)));
sourcepub fn is_congruent_u(&self, c: u32, divisor: u32) -> bool
pub fn is_congruent_u(&self, c: u32, divisor: u32) -> bool
Returns true
if the number is congruent to c mod
divisor, that is, if there exists a q such that self
=
c + q × divisor. Unlike other division functions,
divisor
can be zero.
Examples
use rug::Integer;
let n = Integer::from(105);
assert!(n.is_congruent_u(3335, 10));
assert!(!n.is_congruent_u(107, 10));
// n is congruent to itself if divisor is 0
assert!(n.is_congruent_u(105, 0));
sourcepub fn is_congruent_2pow(&self, c: &Self, b: u32) -> bool
pub fn is_congruent_2pow(&self, c: &Self, b: u32) -> bool
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));
sourcepub fn is_perfect_power(&self) -> bool
pub fn is_perfect_power(&self) -> bool
Returns true
if the number is a perfect power.
Examples
use rug::Integer;
// 0 is 0 to the power of anything
assert!(Integer::from(0).is_perfect_power());
// 25 is 5 to the power of 2
assert!(Integer::from(25).is_perfect_power());
// -243 is -3 to the power of 5
assert!(Integer::from(243).is_perfect_power());
assert!(!Integer::from(24).is_perfect_power());
assert!(!Integer::from(-100).is_perfect_power());
sourcepub fn is_perfect_square(&self) -> bool
pub fn is_perfect_square(&self) -> bool
Returns true
if the number is a perfect square.
Examples
use rug::Integer;
assert!(Integer::from(0).is_perfect_square());
assert!(Integer::from(1).is_perfect_square());
assert!(Integer::from(4).is_perfect_square());
assert!(Integer::from(9).is_perfect_square());
assert!(!Integer::from(15).is_perfect_square());
assert!(!Integer::from(-9).is_perfect_square());
sourcepub fn is_power_of_two(&self) -> bool
pub fn is_power_of_two(&self) -> bool
Returns true
if the number is a power of two.
Examples
use rug::Integer;
assert!(Integer::from(1).is_power_of_two());
assert!(Integer::from(4).is_power_of_two());
assert!(Integer::from(1 << 30).is_power_of_two());
assert!(!Integer::from(7).is_power_of_two());
assert!(!Integer::from(0).is_power_of_two());
assert!(!Integer::from(-1).is_power_of_two());
sourcepub fn cmp_abs(&self, other: &Self) -> Ordering
pub fn cmp_abs(&self, other: &Self) -> Ordering
Compares the absolute values.
Examples
use core::cmp::Ordering;
use rug::Integer;
let a = Integer::from(-10);
let b = Integer::from(4);
assert_eq!(a.cmp(&b), Ordering::Less);
assert_eq!(a.cmp_abs(&b), Ordering::Greater);
sourcepub fn significant_bits(&self) -> u32
pub fn significant_bits(&self) -> u32
Returns the number of bits required to represent the absolute value.
Examples
use rug::Integer;
assert_eq!(Integer::from(0).significant_bits(), 0); // “”
assert_eq!(Integer::from(1).significant_bits(), 1); // “1”
assert_eq!(Integer::from(4).significant_bits(), 3); // “100”
assert_eq!(Integer::from(7).significant_bits(), 3); // “111”
assert_eq!(Integer::from(-1).significant_bits(), 1); // “1”
assert_eq!(Integer::from(-4).significant_bits(), 3); // “100”
assert_eq!(Integer::from(-7).significant_bits(), 3); // “111”
sourcepub fn signed_bits(&self) -> u32
pub fn signed_bits(&self) -> u32
Returns the number of bits required to represent the value using a two’s-complement representation.
For non-negative numbers, this method returns one more than
the significant_bits
method, since an extra zero is needed
before the most significant bit.
Examples
use rug::Integer;
assert_eq!(Integer::from(-5).signed_bits(), 4); // “1011”
assert_eq!(Integer::from(-4).signed_bits(), 3); // “100”
assert_eq!(Integer::from(-3).signed_bits(), 3); // “101”
assert_eq!(Integer::from(-2).signed_bits(), 2); // “10”
assert_eq!(Integer::from(-1).signed_bits(), 1); // “1”
assert_eq!(Integer::from(0).signed_bits(), 1); // “0”
assert_eq!(Integer::from(1).signed_bits(), 2); // “01”
assert_eq!(Integer::from(2).signed_bits(), 3); // “010”
assert_eq!(Integer::from(3).signed_bits(), 3); // “011”
assert_eq!(Integer::from(4).signed_bits(), 4); // “0100”
sourcepub fn count_ones(&self) -> Option<u32>
pub fn count_ones(&self) -> Option<u32>
Returns the number of one bits if the value ≥ 0.
Examples
use rug::Integer;
assert_eq!(Integer::from(0).count_ones(), Some(0));
assert_eq!(Integer::from(15).count_ones(), Some(4));
assert_eq!(Integer::from(-1).count_ones(), None);
sourcepub fn count_zeros(&self) -> Option<u32>
pub fn count_zeros(&self) -> Option<u32>
Returns the number of zero bits if the value < 0.
Examples
use rug::Integer;
assert_eq!(Integer::from(0).count_zeros(), None);
assert_eq!(Integer::from(1).count_zeros(), None);
assert_eq!(Integer::from(-1).count_zeros(), Some(0));
assert_eq!(Integer::from(-2).count_zeros(), Some(1));
assert_eq!(Integer::from(-7).count_zeros(), Some(2));
assert_eq!(Integer::from(-8).count_zeros(), Some(3));
sourcepub fn find_zero(&self, start: u32) -> Option<u32>
pub fn find_zero(&self, start: u32) -> Option<u32>
Returns the location of the first zero, starting at start
. If the bit
at location start
is zero, returns start
.
use rug::Integer;
// -2 is ...11111110
assert_eq!(Integer::from(-2).find_zero(0), Some(0));
assert_eq!(Integer::from(-2).find_zero(1), None);
// 15 is ...00001111
assert_eq!(Integer::from(15).find_zero(0), Some(4));
assert_eq!(Integer::from(15).find_zero(20), Some(20));
sourcepub fn find_one(&self, start: u32) -> Option<u32>
pub fn find_one(&self, start: u32) -> Option<u32>
Returns the location of the first one, starting at start
. If the bit
at location start
is one, returns start
.
use rug::Integer;
// 1 is ...00000001
assert_eq!(Integer::from(1).find_one(0), Some(0));
assert_eq!(Integer::from(1).find_one(1), None);
// -16 is ...11110000
assert_eq!(Integer::from(-16).find_one(0), Some(4));
assert_eq!(Integer::from(-16).find_one(20), Some(20));
sourcepub fn toggle_bit(&mut self, index: u32) -> &mut Self
pub fn toggle_bit(&mut self, index: u32) -> &mut Self
Toggles the bit at location index
.
Examples
use rug::Integer;
let mut i = Integer::from(0b100101);
i.toggle_bit(5);
assert_eq!(i, 0b101);
sourcepub fn hamming_dist(&self, other: &Self) -> Option<u32>
pub fn hamming_dist(&self, other: &Self) -> Option<u32>
Retuns the Hamming distance if the two numbers have the same sign.
The Hamming distance is the number of different bits.
Examples
use rug::Integer;
let i = Integer::from(-1);
assert_eq!(Integer::from(0).hamming_dist(&i), None);
assert_eq!(Integer::from(-1).hamming_dist(&i), Some(0));
// -1 is ...11111111 and -13 is ...11110011
assert_eq!(Integer::from(-13).hamming_dist(&i), Some(2));
sourcepub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
pub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
Adds a list of Integer
values.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Integer
From<Src> for Integer
Complete<Completed = Integer> for Src
AddAssign<Src> for Integer
Add<Src> for Integer
,Add<Integer> for Src
SubAssign<Src> for Integer
,SubFrom<Src> for Integer
Sub<Src> for Integer
,Sub<Integer> for Src
Examples
use rug::{Complete, Integer};
let values = [
Integer::from(5),
Integer::from(1024),
Integer::from(-100_000),
Integer::from(-4),
];
let sum = Integer::sum(values.iter()).complete();
let expected = 5 + 1024 - 100_000 - 4;
assert_eq!(sum, expected);
sourcepub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I> where
I: Iterator<Item = (&'a Self, &'a Self)>,
pub fn dot<'a, I>(values: I) -> DotIncomplete<'a, I> where
I: Iterator<Item = (&'a Self, &'a Self)>,
Finds the dot product of a list of Integer
value pairs.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Integer
From<Src> for Integer
Complete<Completed = Integer> for Src
AddAssign<Src> for Integer
Add<Src> for Integer
,Add<Integer> for Src
SubAssign<Src> for Integer
,SubFrom<Src> for Integer
Sub<Src> for Integer
,Sub<Integer> for Src
Examples
use rug::{Complete, Integer};
let a = [Integer::from(270), Integer::from(-11)];
let b = [Integer::from(100), Integer::from(5)];
let dot = Integer::dot(a.iter().zip(b.iter())).complete();
let expected = 270 * 100 - 11 * 5;
assert_eq!(dot, expected);
sourcepub fn product<'a, I>(values: I) -> ProductIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
pub fn product<'a, I>(values: I) -> ProductIncomplete<'a, I> where
I: Iterator<Item = &'a Self>,
Multiplies a list of Integer
values.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Integer
From<Src> for Integer
Complete<Completed = Integer> for Src
MulAssign<Src> for Integer
Mul<Src> for Integer
,Mul<Integer> for Src
Examples
use rug::{Complete, Integer};
let values = [
Integer::from(5),
Integer::from(1024),
Integer::from(-100_000),
Integer::from(-4),
];
let product = Integer::product(values.iter()).complete();
let expected = 5 * 1024 * -100_000 * -4;
assert_eq!(product, expected);
sourcepub fn abs(self) -> Self
pub fn abs(self) -> Self
Computes the absolute value.
Examples
use rug::Integer;
let i = Integer::from(-100);
let abs = i.abs();
assert_eq!(abs, 100);
sourcepub fn abs_mut(&mut self)
pub fn abs_mut(&mut self)
Computes the absolute value.
Examples
use rug::Integer;
let mut i = Integer::from(-100);
i.abs_mut();
assert_eq!(i, 100);
sourcepub fn abs_ref(&self) -> AbsIncomplete<'_>
pub fn abs_ref(&self) -> AbsIncomplete<'_>
Computes the absolute value.
The following 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);
sourcepub fn signum(self) -> Self
pub fn signum(self) -> Self
Computes the signum.
- 0 if the value is zero
- 1 if the value is positive
- −1 if the value is negative
Examples
use rug::Integer;
assert_eq!(Integer::from(-100).signum(), -1);
assert_eq!(Integer::from(0).signum(), 0);
assert_eq!(Integer::from(100).signum(), 1);
sourcepub fn signum_mut(&mut self)
pub fn signum_mut(&mut self)
Computes the signum.
- 0 if the value is zero
- 1 if the value is positive
- −1 if the value is negative
Examples
use rug::Integer;
let mut i = Integer::from(-100);
i.signum_mut();
assert_eq!(i, -1);
sourcepub fn signum_ref(&self) -> SignumIncomplete<'_>
pub fn signum_ref(&self) -> SignumIncomplete<'_>
Computes the signum.
- 0 if the value is zero
- 1 if the value is positive
- −1 if the value is negative
The following are implemented with the returned incomplete-computation
value as Src
:
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);
sourcepub fn clamp<Min, Max>(self, min: &Min, max: &Max) -> Self where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,
pub fn clamp<Min, Max>(self, min: &Min, max: &Max) -> Self where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,
Clamps the value within the specified bounds.
Panics
Panics if the maximum value is less than the minimum value.
Examples
use rug::Integer;
let min = -10;
let max = 10;
let too_small = Integer::from(-100);
let clamped1 = too_small.clamp(&min, &max);
assert_eq!(clamped1, -10);
let in_range = Integer::from(3);
let clamped2 = in_range.clamp(&min, &max);
assert_eq!(clamped2, 3);
sourcepub fn clamp_mut<Min, Max>(&mut self, min: &Min, max: &Max) where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,
pub fn clamp_mut<Min, Max>(&mut self, min: &Min, max: &Max) where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,
Clamps the value within the specified bounds.
Panics
Panics if the maximum value is less than the minimum value.
Examples
use rug::Integer;
let min = -10;
let max = 10;
let mut too_small = Integer::from(-100);
too_small.clamp_mut(&min, &max);
assert_eq!(too_small, -10);
let mut in_range = Integer::from(3);
in_range.clamp_mut(&min, &max);
assert_eq!(in_range, 3);
sourcepub fn clamp_ref<'min, 'max, Min, Max>(
&self,
min: &'min Min,
max: &'max Max
) -> ClampIncomplete<'_, 'min, 'max, Min, Max> where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,
pub fn clamp_ref<'min, 'max, Min, Max>(
&self,
min: &'min Min,
max: &'max Max
) -> ClampIncomplete<'_, 'min, 'max, Min, Max> where
Self: PartialOrd<Min> + PartialOrd<Max> + for<'a> Assign<&'a Min> + for<'a> Assign<&'a Max>,
Clamps the value within the specified bounds.
The following are implemented with the returned incomplete-computation
value as Src
:
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);
sourcepub fn keep_bits(self, n: u32) -> Self
pub fn keep_bits(self, n: u32) -> Self
Keeps the n least significant bits only, producing a result that is greater or equal to 0.
Examples
use rug::Integer;
let i = Integer::from(-1);
let keep_8 = i.keep_bits(8);
assert_eq!(keep_8, 0xff);
sourcepub fn keep_bits_mut(&mut self, n: u32)
pub fn keep_bits_mut(&mut self, n: u32)
Keeps the n least significant bits only, producing a result that is greater or equal to 0.
Examples
use rug::Integer;
let mut i = Integer::from(-1);
i.keep_bits_mut(8);
assert_eq!(i, 0xff);
sourcepub fn keep_bits_ref(&self, n: u32) -> KeepBitsIncomplete<'_>
pub fn keep_bits_ref(&self, n: u32) -> KeepBitsIncomplete<'_>
Keeps the n least significant bits only, producing a result that is greater or equal to 0.
The following are implemented with the returned incomplete-computation
value as Src
:
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);
sourcepub fn keep_signed_bits(self, n: u32) -> Self
pub fn keep_signed_bits(self, n: u32) -> Self
Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.
Examples
use rug::Integer;
let i = Integer::from(-1);
let i_keep_8 = i.keep_signed_bits(8);
assert_eq!(i_keep_8, -1);
let j = Integer::from(15 << 8 | 15);
let j_keep_8 = j.keep_signed_bits(8);
assert_eq!(j_keep_8, 15);
sourcepub fn keep_signed_bits_mut(&mut self, n: u32)
pub fn keep_signed_bits_mut(&mut self, n: u32)
Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.
Examples
use rug::Integer;
let mut i = Integer::from(-1);
i.keep_signed_bits_mut(8);
assert_eq!(i, -1);
let mut j = Integer::from(15 << 8 | 15);
j.keep_signed_bits_mut(8);
assert_eq!(j, 15);
sourcepub fn keep_signed_bits_ref(&self, n: u32) -> KeepSignedBitsIncomplete<'_>
pub fn keep_signed_bits_ref(&self, n: u32) -> KeepSignedBitsIncomplete<'_>
Keeps the n least significant bits only, producing a negative result if the nth least significant bit is one.
The following are implemented with the returned
incomplete-computation value as Src
:
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);
sourcepub fn next_power_of_two(self) -> Self
pub fn next_power_of_two(self) -> Self
Finds the next power of two, or 1 if the number ≤ 0.
Examples
use rug::Integer;
let i = Integer::from(-3).next_power_of_two();
assert_eq!(i, 1);
let i = Integer::from(4).next_power_of_two();
assert_eq!(i, 4);
let i = Integer::from(7).next_power_of_two();
assert_eq!(i, 8);
sourcepub fn next_power_of_two_mut(&mut self)
pub fn next_power_of_two_mut(&mut self)
Finds the next power of two, or 1 if the number ≤ 0.
Examples
use rug::Integer;
let mut i = Integer::from(53);
i.next_power_of_two_mut();
assert_eq!(i, 64);
sourcepub fn next_power_of_two_ref(&self) -> NextPowerOfTwoIncomplete<'_>
pub fn next_power_of_two_ref(&self) -> NextPowerOfTwoIncomplete<'_>
Finds the next power of two, or 1 if the number ≤ 0.
The following are implemented with the returned incomplete-computation
value as Src
:
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);
sourcepub fn div_rem(self, divisor: Self) -> (Self, Self)
pub fn div_rem(self, divisor: Self) -> (Self, Self)
Performs a division producing both the quotient and remainder.
The remainder has the same sign as the dividend.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer;
let dividend = Integer::from(23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem(divisor);
assert_eq!(quotient, -2);
assert_eq!(rem, 3);
sourcepub fn div_rem_mut(&mut self, divisor: &mut Self)
pub fn div_rem_mut(&mut self, divisor: &mut Self)
Performs a division producing both the quotient and remainder.
The remainder has the same sign as the dividend.
The quotient is stored in self
and the remainder is stored in
divisor
.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer;
let mut dividend_quotient = Integer::from(-23);
let mut divisor_rem = Integer::from(10);
dividend_quotient.div_rem_mut(&mut divisor_rem);
assert_eq!(dividend_quotient, -2);
assert_eq!(divisor_rem, -3);
sourcepub fn div_rem_ref<'a>(&'a self, divisor: &'a Self) -> DivRemIncomplete<'_>
pub fn div_rem_ref<'a>(&'a self, divisor: &'a Self) -> DivRemIncomplete<'_>
Performs a division producing both the quotient and remainder.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
The remainder has the same sign as the dividend.
Examples
use rug::{Complete, Integer};
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_ref(&divisor).complete();
assert_eq!(quotient, 2);
assert_eq!(rem, -3);
sourcepub fn div_rem_ceil(self, divisor: Self) -> (Self, Self)
pub fn div_rem_ceil(self, divisor: Self) -> (Self, Self)
Performs a division producing both the quotient and remainder, with the quotient rounded up.
The sign of the remainder is the opposite of the divisor’s sign.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer;
let dividend = Integer::from(23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_ceil(divisor);
assert_eq!(quotient, -2);
assert_eq!(rem, 3);
sourcepub fn div_rem_ceil_mut(&mut self, divisor: &mut Self)
pub fn div_rem_ceil_mut(&mut self, divisor: &mut Self)
Performs a division producing both the quotient and remainder, with the quotient rounded up.
The sign of the remainder is the opposite of the divisor’s sign.
The quotient is stored in self
and the remainder is stored in
divisor
.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer;
let mut dividend_quotient = Integer::from(-23);
let mut divisor_rem = Integer::from(10);
dividend_quotient.div_rem_ceil_mut(&mut divisor_rem);
assert_eq!(dividend_quotient, -2);
assert_eq!(divisor_rem, -3);
sourcepub fn div_rem_ceil_ref<'a>(
&'a self,
divisor: &'a Self
) -> DivRemCeilIncomplete<'_>
pub fn div_rem_ceil_ref<'a>(
&'a self,
divisor: &'a Self
) -> DivRemCeilIncomplete<'_>
Performs a division producing both the quotient and remainder, with the quotient rounded up.
The sign of the remainder is the opposite of the divisor’s sign.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
Examples
use rug::{Complete, Integer};
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_ceil_ref(&divisor).complete();
assert_eq!(quotient, 3);
assert_eq!(rem, 7);
sourcepub fn div_rem_floor(self, divisor: Self) -> (Self, Self)
pub fn div_rem_floor(self, divisor: Self) -> (Self, Self)
Performs a division producing both the quotient and remainder, with the quotient rounded down.
The remainder has the same sign as the divisor.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer;
let dividend = Integer::from(23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_floor(divisor);
assert_eq!(quotient, -3);
assert_eq!(rem, -7);
sourcepub fn div_rem_floor_mut(&mut self, divisor: &mut Self)
pub fn div_rem_floor_mut(&mut self, divisor: &mut Self)
Performs a division producing both the quotient and remainder, with the quotient rounded down.
The remainder has the same sign as the divisor.
The quotient is stored in self
and the remainder is stored in
divisor
.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer;
let mut dividend_quotient = Integer::from(-23);
let mut divisor_rem = Integer::from(10);
dividend_quotient.div_rem_floor_mut(&mut divisor_rem);
assert_eq!(dividend_quotient, -3);
assert_eq!(divisor_rem, 7);
sourcepub fn div_rem_floor_ref<'a>(
&'a self,
divisor: &'a Self
) -> DivRemFloorIncomplete<'_>
pub fn div_rem_floor_ref<'a>(
&'a self,
divisor: &'a Self
) -> DivRemFloorIncomplete<'_>
Performs a division producing both the quotient and remainder, with the quotient rounded down.
The remainder has the same sign as the divisor.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
Examples
use rug::{Complete, Integer};
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_floor_ref(&divisor).complete();
assert_eq!(quotient, 2);
assert_eq!(rem, -3);
sourcepub fn div_rem_round(self, divisor: Self) -> (Self, Self)
pub fn div_rem_round(self, divisor: Self) -> (Self, Self)
Performs a division producing both the quotient and remainder, with the quotient rounded to the nearest integer.
When the quotient before rounding lies exactly between two integers, it is rounded away from zero.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer;
// 23 / -10 → -2 rem 3
let (q, rem) = Integer::from(23).div_rem_round((-10).into());
assert!(q == -2 && rem == 3);
// 25 / 10 → 3 rem -5
let (q, rem) = Integer::from(25).div_rem_round(10.into());
assert!(q == 3 && rem == -5);
// -27 / 10 → -3 rem 3
let (q, rem) = Integer::from(-27).div_rem_round(10.into());
assert!(q == -3 && rem == 3);
sourcepub fn div_rem_round_mut(&mut self, divisor: &mut Self)
pub fn div_rem_round_mut(&mut self, divisor: &mut Self)
Performs a division producing both the quotient and remainder, with the quotient rounded to the nearest integer.
When the quotient before rounding lies exactly between two integers, it is rounded away from zero.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer;
// -25 / -10 → 3 rem 5
let mut dividend_quotient = Integer::from(-25);
let mut divisor_rem = Integer::from(-10);
dividend_quotient.div_rem_round_mut(&mut divisor_rem);
assert_eq!(dividend_quotient, 3);
assert_eq!(divisor_rem, 5);
sourcepub fn div_rem_round_ref<'a>(
&'a self,
divisor: &'a Self
) -> DivRemRoundIncomplete<'_>
pub fn div_rem_round_ref<'a>(
&'a self,
divisor: &'a Self
) -> DivRemRoundIncomplete<'_>
Performs a division producing both the quotient and remainder, with the quotient rounded to the nearest integer.
When the quotient before rounding lies exactly between two integers, it is rounded away from zero.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
Examples
use rug::{Complete, Integer};
// -28 / -10 → 3 rem 2
let dividend = Integer::from(-28);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_round_ref(&divisor).complete();
assert_eq!(quotient, 3);
assert_eq!(rem, 2);
sourcepub fn div_rem_euc(self, divisor: Self) -> (Self, Self)
pub fn div_rem_euc(self, divisor: Self) -> (Self, Self)
Performs Euclidean division producing both the quotient and remainder, with a positive remainder.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer;
let dividend = Integer::from(23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_euc(divisor);
assert_eq!(quotient, -2);
assert_eq!(rem, 3);
sourcepub fn div_rem_euc_mut(&mut self, divisor: &mut Self)
pub fn div_rem_euc_mut(&mut self, divisor: &mut Self)
Performs Euclidean division producing both the quotient and remainder, with a positive remainder.
The quotient is stored in self
and the remainder is stored in
divisor
.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer;
let mut dividend_quotient = Integer::from(-23);
let mut divisor_rem = Integer::from(10);
dividend_quotient.div_rem_euc_mut(&mut divisor_rem);
assert_eq!(dividend_quotient, -3);
assert_eq!(divisor_rem, 7);
sourcepub fn div_rem_euc_ref<'a>(
&'a self,
divisor: &'a Self
) -> DivRemEucIncomplete<'_>
pub fn div_rem_euc_ref<'a>(
&'a self,
divisor: &'a Self
) -> DivRemEucIncomplete<'_>
Performs Euclidan division producing both the quotient and remainder, with a positive remainder.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
Examples
use rug::{Complete, Integer};
let dividend = Integer::from(-23);
let divisor = Integer::from(-10);
let (quotient, rem) = dividend.div_rem_euc_ref(&divisor).complete();
assert_eq!(quotient, 3);
assert_eq!(rem, 7);
sourcepub fn mod_u(&self, modulo: u32) -> u32
pub fn mod_u(&self, modulo: u32) -> u32
Returns the modulo, or the remainder of Euclidean division by a u32
.
The result is always zero or positive.
Panics
Panics if modulo
is zero.
Examples
use rug::Integer;
let pos = Integer::from(23);
assert_eq!(pos.mod_u(1), 0);
assert_eq!(pos.mod_u(10), 3);
assert_eq!(pos.mod_u(100), 23);
let neg = Integer::from(-23);
assert_eq!(neg.mod_u(1), 0);
assert_eq!(neg.mod_u(10), 7);
assert_eq!(neg.mod_u(100), 77);
sourcepub fn div_exact(self, divisor: &Self) -> Self
pub fn div_exact(self, divisor: &Self) -> Self
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
Panics
Panics if divisor
is zero.
Examples
use rug::Integer;
let i = Integer::from(12345 * 54321);
let quotient = i.div_exact(&Integer::from(12345));
assert_eq!(quotient, 54321);
sourcepub fn div_exact_mut(&mut self, divisor: &Self)
pub fn div_exact_mut(&mut self, divisor: &Self)
sourcepub fn div_exact_from(&mut self, dividend: &Integer)
pub fn div_exact_from(&mut self, dividend: &Integer)
Performs an exact division dividend
/ self
.
This is much faster than normal division, but produces correct results only when the division is exact.
Panics
Panics if self
is zero.
Examples
use rug::Integer;
let mut i = Integer::from(12345);
i.div_exact_from(&Integer::from(12345 * 54321));
assert_eq!(i, 54321);
sourcepub fn div_exact_ref<'a>(&'a self, divisor: &'a Self) -> DivExactIncomplete<'_>
pub fn div_exact_ref<'a>(&'a self, divisor: &'a Self) -> DivExactIncomplete<'_>
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
The following are implemented with the returned incomplete-computation
value as Src
:
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);
sourcepub fn div_exact_u(self, divisor: u32) -> Self
pub fn div_exact_u(self, divisor: u32) -> Self
sourcepub fn div_exact_u_mut(&mut self, divisor: u32)
pub fn div_exact_u_mut(&mut self, divisor: u32)
sourcepub fn div_exact_u_ref(&self, divisor: u32) -> DivExactUIncomplete<'_>
pub fn div_exact_u_ref(&self, divisor: u32) -> DivExactUIncomplete<'_>
Performs an exact division.
This is much faster than normal division, but produces correct results only when the division is exact.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::Integer;
let i = Integer::from(12345 * 54321);
let r = i.div_exact_u_ref(12345);
assert_eq!(Integer::from(r), 54321);
sourcepub fn invert(self, modulo: &Self) -> Result<Self, Self>
pub fn invert(self, modulo: &Self) -> Result<Self, Self>
Finds the inverse modulo modulo
and returns Ok(inverse)
if it
exists, or Err(unchanged)
if the inverse does not exist.
The inverse exists if the modulo is not zero, and self
and the modulo
are co-prime, that is their GCD is 1.
Examples
use rug::Integer;
let n = Integer::from(2);
// Modulo 4, 2 has no inverse: there is no i such that 2 × i = 1.
let inv_mod_4 = match n.invert(&Integer::from(4)) {
Ok(_) => unreachable!(),
Err(unchanged) => unchanged,
};
// no inverse exists, so value is unchanged
assert_eq!(inv_mod_4, 2);
let n = inv_mod_4;
// Modulo 5, the inverse of 2 is 3, as 2 × 3 = 1.
let inv_mod_5 = match n.invert(&Integer::from(5)) {
Ok(inverse) => inverse,
Err(_) => unreachable!(),
};
assert_eq!(inv_mod_5, 3);
sourcepub fn invert_mut(&mut self, modulo: &Self) -> Result<(), ()>
pub fn invert_mut(&mut self, modulo: &Self) -> Result<(), ()>
Finds the inverse modulo modulo
if an inverse exists.
The inverse exists if the modulo is not zero, and self
and the modulo
are co-prime, that is their GCD is 1.
Examples
use rug::Integer;
let mut n = Integer::from(2);
// Modulo 4, 2 has no inverse: there is no i such that 2 × i = 1.
match n.invert_mut(&Integer::from(4)) {
Ok(()) => unreachable!(),
Err(()) => assert_eq!(n, 2),
}
// Modulo 5, the inverse of 2 is 3, as 2 × 3 = 1.
match n.invert_mut(&Integer::from(5)) {
Ok(()) => assert_eq!(n, 3),
Err(()) => unreachable!(),
}
sourcepub fn invert_ref<'a>(&'a self, modulo: &'a Self) -> Option<InvertIncomplete<'a>>
pub fn invert_ref<'a>(&'a self, modulo: &'a Self) -> Option<InvertIncomplete<'a>>
Finds the inverse modulo modulo
if an inverse exists.
The inverse exists if the modulo is not zero, and self
and the modulo
are co-prime, that is their GCD is 1.
The following are implemented with the unwrapped returned
incomplete-computation value as Src
:
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);
sourcepub fn pow_mod(self, exponent: &Self, modulo: &Self) -> Result<Self, Self>
pub fn pow_mod(self, exponent: &Self, modulo: &Self) -> Result<Self, Self>
Raises a number to the power of exponent
modulo modulo
and returns
Ok(power)
if an answer exists, or Err(unchanged)
if it
does not.
If the exponent is negative, then the number must have an inverse for an answer to exist.
When the exponent is positive and the modulo is not zero, an answer always exists.
Examples
use rug::Integer;
// 7 ^ 5 = 16807
let n = Integer::from(7);
let e = Integer::from(5);
let m = Integer::from(1000);
let power = match n.pow_mod(&e, &m) {
Ok(power) => power,
Err(_) => unreachable!(),
};
assert_eq!(power, 807);
When the exponent is negative, an answer exists if an inverse exists.
use rug::Integer;
// 7 × 143 modulo 1000 = 1, so 7 has an inverse 143.
// 7 ^ -5 modulo 1000 = 143 ^ 5 modulo 1000 = 943.
let n = Integer::from(7);
let e = Integer::from(-5);
let m = Integer::from(1000);
let power = match n.pow_mod(&e, &m) {
Ok(power) => power,
Err(_) => unreachable!(),
};
assert_eq!(power, 943);
sourcepub fn pow_mod_mut(&mut self, exponent: &Self, modulo: &Self) -> Result<(), ()>
pub fn pow_mod_mut(&mut self, exponent: &Self, modulo: &Self) -> Result<(), ()>
Raises a number to the power of exponent
modulo modulo
if an answer
exists.
If the exponent is negative, then the number must have an inverse for an answer to exist.
Examples
use rug::{Assign, Integer};
// Modulo 1000, 2 has no inverse: there is no i such that 2 × i = 1.
let mut n = Integer::from(2);
let e = Integer::from(-5);
let m = Integer::from(1000);
match n.pow_mod_mut(&e, &m) {
Ok(()) => unreachable!(),
Err(()) => assert_eq!(n, 2),
}
// 7 × 143 modulo 1000 = 1, so 7 has an inverse 143.
// 7 ^ -5 modulo 1000 = 143 ^ 5 modulo 1000 = 943.
n.assign(7);
match n.pow_mod_mut(&e, &m) {
Ok(()) => assert_eq!(n, 943),
Err(()) => unreachable!(),
}
sourcepub fn pow_mod_ref<'a>(
&'a self,
exponent: &'a Self,
modulo: &'a Self
) -> Option<PowModIncomplete<'a>>
pub fn pow_mod_ref<'a>(
&'a self,
exponent: &'a Self,
modulo: &'a Self
) -> Option<PowModIncomplete<'a>>
Raises a number to the power of exponent
modulo modulo
if an answer
exists.
If the exponent is negative, then the number must have an inverse for an answer to exist.
The following are implemented with the unwrapped returned
incomplete-computation value as Src
:
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);
sourcepub fn secure_pow_mod(self, exponent: &Self, modulo: &Self) -> Self
pub fn secure_pow_mod(self, exponent: &Self, modulo: &Self) -> Self
Raises a number to the power of exponent
modulo modulo
, with
resilience to side-channel attacks.
The exponent must be greater than zero, and the modulo must be odd.
This method is intended for cryptographic purposes where resilience to side-channel attacks is desired. The function is designed to take the same time and use the same cache access patterns for same-sized arguments, assuming that the arguments are placed at the same position and the machine state is identical when starting.
Panics
Panics if exponent
≤ 0 or if modulo
is even.
Examples
use rug::Integer;
// 7 ^ 4 mod 13 = 9
let n = Integer::from(7);
let e = Integer::from(4);
let m = Integer::from(13);
let power = n.secure_pow_mod(&e, &m);
assert_eq!(power, 9);
sourcepub fn secure_pow_mod_mut(&mut self, exponent: &Self, modulo: &Self)
pub fn secure_pow_mod_mut(&mut self, exponent: &Self, modulo: &Self)
Raises a number to the power of exponent
modulo modulo
, with
resilience to side-channel attacks.
The exponent must be greater than zero, and the modulo must be odd.
This method is intended for cryptographic purposes where resilience to side-channel attacks is desired. The function is designed to take the same time and use the same cache access patterns for same-sized arguments, assuming that the arguments are placed at the same position and the machine state is identical when starting.
Panics
Panics if exponent
≤ 0 or if modulo
is even.
Examples
use rug::Integer;
// 7 ^ 4 mod 13 = 9
let mut n = Integer::from(7);
let e = Integer::from(4);
let m = Integer::from(13);
n.secure_pow_mod_mut(&e, &m);
assert_eq!(n, 9);
sourcepub fn secure_pow_mod_ref<'a>(
&'a self,
exponent: &'a Self,
modulo: &'a Self
) -> SecurePowModIncomplete<'a>
pub fn secure_pow_mod_ref<'a>(
&'a self,
exponent: &'a Self,
modulo: &'a Self
) -> SecurePowModIncomplete<'a>
Raises a number to the power of exponent
modulo modulo
, with
resilience to side-channel attacks.
The exponent must be greater than zero, and the modulo must be odd.
This method is intended for cryptographic purposes where resilience to side-channel attacks is desired. The function is designed to take the same time and use the same cache access patterns for same-sized arguments, assuming that the arguments are placed at the same position and the machine state is identical when starting.
The following are implemented with the returned incomplete-computation
value as Src
:
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);
sourcepub fn u_pow_u(base: u32, exponent: u32) -> UPowUIncomplete
pub fn u_pow_u(base: u32, exponent: u32) -> UPowUIncomplete
Raises base
to the power of exponent
.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Complete, Integer};
assert_eq!(Integer::u_pow_u(13, 12).complete(), 13_u64.pow(12));
sourcepub fn i_pow_u(base: i32, exponent: u32) -> IPowUIncomplete
pub fn i_pow_u(base: i32, exponent: u32) -> IPowUIncomplete
Raises base
to the power of exponent
.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Assign, Integer};
let mut ans = Integer::new();
ans.assign(Integer::i_pow_u(-13, 13));
assert_eq!(ans, (-13_i64).pow(13));
ans.assign(Integer::i_pow_u(13, 13));
assert_eq!(ans, (13_i64).pow(13));
sourcepub fn root_ref(&self, n: u32) -> RootIncomplete<'_>
pub fn root_ref(&self, n: u32) -> RootIncomplete<'_>
Computes the nth root and truncates the result.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::Integer;
let i = Integer::from(1004);
assert_eq!(Integer::from(i.root_ref(3)), 10);
sourcepub fn root_rem(self, remainder: Self, n: u32) -> (Self, Self)
pub fn root_rem(self, remainder: Self, n: u32) -> (Self, Self)
Computes the nth root and returns the truncated root and the remainder.
The remainder is the original number minus the truncated root raised to the power of n.
The initial value of remainder
is ignored.
Panics
Panics if n is zero or if n is even and the value is negative.
Examples
use rug::Integer;
let i = Integer::from(1004);
let (root, rem) = i.root_rem(Integer::new(), 3);
assert_eq!(root, 10);
assert_eq!(rem, 4);
sourcepub fn root_rem_mut(&mut self, remainder: &mut Self, n: u32)
pub fn root_rem_mut(&mut self, remainder: &mut Self, n: u32)
Computes the nth root and returns the truncated root and the remainder.
The remainder is the original number minus the truncated root raised to the power of n.
The initial value of remainder
is ignored.
Panics
Panics if n is zero or if n is even and the value is negative.
Examples
use rug::Integer;
let mut i = Integer::from(1004);
let mut rem = Integer::new();
i.root_rem_mut(&mut rem, 3);
assert_eq!(i, 10);
assert_eq!(rem, 4);
sourcepub fn root_rem_ref(&self, n: u32) -> RootRemIncomplete<'_>
pub fn root_rem_ref(&self, n: u32) -> RootRemIncomplete<'_>
Computes the nth root and returns the truncated root and the remainder.
The remainder is the original number minus the truncated root raised to the power of n.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
Examples
use rug::{Assign, Complete, Integer};
let i = Integer::from(1004);
let mut root = Integer::new();
let mut rem = Integer::new();
// 1004 = 10^3 + 5
(&mut root, &mut rem).assign(i.root_rem_ref(3));
assert_eq!(root, 10);
assert_eq!(rem, 4);
// 1004 = 3^6 + 275
let (other_root, other_rem) = i.root_rem_ref(6).complete();
assert_eq!(other_root, 3);
assert_eq!(other_rem, 275);
sourcepub fn square(self) -> Self
pub fn square(self) -> Self
Computes the square.
This method cannot be replaced by a multiplication using the *
operator: i * i
and i * &i
are both errors.
Examples
use rug::Integer;
let i = Integer::from(13);
let square = i.square();
assert_eq!(square, 169);
sourcepub fn square_mut(&mut self)
pub fn square_mut(&mut self)
Computes the square.
This method cannot be replaced by a compound multiplication and
assignment using the *=
operataor: i *= i;
and i *= &i;
are both
errors.
Examples
use rug::Integer;
let mut i = Integer::from(13);
i.square_mut();
assert_eq!(i, 169);
sourcepub fn square_ref(&self) -> MulIncomplete<'_>
pub fn square_ref(&self) -> MulIncomplete<'_>
Computes the square.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Integer
From<Src> for Integer
Complete<Completed = Integer> for Src
AddAssign<Src> for Integer
Add<Src> for Integer
,Add<Integer> for Src
SubAssign<Src> for Integer
,SubFrom<Src> for Integer
Sub<Src> for Integer
,Sub<Integer> for Src
i.square_ref()
produces the exact same result as &i * &i
.
Examples
use rug::Integer;
let i = Integer::from(13);
assert_eq!(Integer::from(i.square_ref()), 169);
sourcepub fn sqrt_ref(&self) -> SqrtIncomplete<'_>
pub fn sqrt_ref(&self) -> SqrtIncomplete<'_>
Computes the square root and truncates the result.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::Integer;
let i = Integer::from(104);
assert_eq!(Integer::from(i.sqrt_ref()), 10);
sourcepub fn sqrt_rem(self, remainder: Self) -> (Self, Self)
pub fn sqrt_rem(self, remainder: Self) -> (Self, Self)
Computes the square root and the remainder.
The remainder is the original number minus the truncated root squared.
The initial value of remainder
is ignored.
Panics
Panics if the value is negative.
Examples
use rug::Integer;
let i = Integer::from(104);
let (sqrt, rem) = i.sqrt_rem(Integer::new());
assert_eq!(sqrt, 10);
assert_eq!(rem, 4);
sourcepub fn sqrt_rem_mut(&mut self, remainder: &mut Self)
pub fn sqrt_rem_mut(&mut self, remainder: &mut Self)
Computes the square root and the remainder.
The remainder is the original number minus the truncated root squared.
The initial value of remainder
is ignored.
Panics
Panics if the value is negative.
Examples
use rug::Integer;
let mut i = Integer::from(104);
let mut rem = Integer::new();
i.sqrt_rem_mut(&mut rem);
assert_eq!(i, 10);
assert_eq!(rem, 4);
sourcepub fn sqrt_rem_ref(&self) -> SqrtRemIncomplete<'_>
pub fn sqrt_rem_ref(&self) -> SqrtRemIncomplete<'_>
Computes the square root and the remainder.
The remainder is the original number minus the truncated root squared.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
Examples
use rug::{Assign, Integer};
let i = Integer::from(104);
let mut sqrt = Integer::new();
let mut rem = Integer::new();
let r = i.sqrt_rem_ref();
(&mut sqrt, &mut rem).assign(r);
assert_eq!(sqrt, 10);
assert_eq!(rem, 4);
let r = i.sqrt_rem_ref();
let (other_sqrt, other_rem) = <(Integer, Integer)>::from(r);
assert_eq!(other_sqrt, 10);
assert_eq!(other_rem, 4);
sourcepub fn is_probably_prime(&self, reps: u32) -> IsPrime
pub fn is_probably_prime(&self, reps: u32) -> IsPrime
Determines wheter a number is prime.
This function uses some trial divisions, a Baille-PSW probable prime
test, then reps
− 24 Miller-Rabin probabilistic
primality tests.
Examples
use rug::{integer::IsPrime, Integer};
let no = Integer::from(163 * 4003);
assert_eq!(no.is_probably_prime(30), IsPrime::No);
let yes = Integer::from(817_504_243);
assert_eq!(yes.is_probably_prime(30), IsPrime::Yes);
// 16_412_292_043_871_650_369 is actually a prime.
let probably = Integer::from(16_412_292_043_871_650_369_u64);
assert_eq!(probably.is_probably_prime(30), IsPrime::Probably);
sourcepub fn next_prime(self) -> Self
pub fn next_prime(self) -> Self
Identifies primes using a probabilistic algorithm; the chance of a composite passing will be extremely small.
Examples
use rug::Integer;
let i = Integer::from(800_000_000);
let prime = i.next_prime();
assert_eq!(prime, 800_000_011);
sourcepub fn next_prime_mut(&mut self)
pub fn next_prime_mut(&mut self)
Identifies primes using a probabilistic algorithm; the chance of a composite passing will be extremely small.
Examples
use rug::Integer;
let mut i = Integer::from(800_000_000);
i.next_prime_mut();
assert_eq!(i, 800_000_011);
sourcepub fn next_prime_ref(&self) -> NextPrimeIncomplete<'_>
pub fn next_prime_ref(&self) -> NextPrimeIncomplete<'_>
Identifies primes using a probabilistic algorithm; the chance of a composite passing will be extremely small.
The following are implemented with the returned incomplete-computation
value as Src
:
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);
sourcepub fn gcd(self, other: &Self) -> Self
pub fn gcd(self, other: &Self) -> Self
Finds the greatest common divisor.
The result is always positive except when both inputs are zero.
Examples
use rug::{Assign, Integer};
let a = Integer::new();
let mut b = Integer::new();
// gcd of 0, 0 is 0
let gcd1 = a.gcd(&b);
assert_eq!(gcd1, 0);
b.assign(10);
// gcd of 0, 10 is 10
let gcd2 = gcd1.gcd(&b);
assert_eq!(gcd2, 10);
b.assign(25);
// gcd of 10, 25 is 5
let gcd3 = gcd2.gcd(&b);
assert_eq!(gcd3, 5);
sourcepub fn gcd_mut(&mut self, other: &Self)
pub fn gcd_mut(&mut self, other: &Self)
Finds the greatest common divisor.
The result is always positive except when both inputs are zero.
Examples
use rug::{Assign, Integer};
let mut a = Integer::new();
let mut b = Integer::new();
// gcd of 0, 0 is 0
a.gcd_mut(&b);
assert_eq!(a, 0);
b.assign(10);
// gcd of 0, 10 is 10
a.gcd_mut(&b);
assert_eq!(a, 10);
b.assign(25);
// gcd of 10, 25 is 5
a.gcd_mut(&b);
assert_eq!(a, 5);
sourcepub fn gcd_ref<'a>(&'a self, other: &'a Self) -> GcdIncomplete<'_>
pub fn gcd_ref<'a>(&'a self, other: &'a Self) -> GcdIncomplete<'_>
Finds the greatest common divisor.
The result is always positive except when both inputs are zero.
The following are implemented with the returned incomplete-computation
value as Src
:
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);
sourcepub fn gcd_u(self, other: u32) -> Self
pub fn gcd_u(self, other: u32) -> Self
Finds the greatest common divisor.
The result is always positive except when both inputs are zero.
Examples
use rug::Integer;
let i = Integer::new();
// gcd of 0, 0 is 0
let gcd1 = i.gcd_u(0);
assert_eq!(gcd1, 0);
// gcd of 0, 10 is 10
let gcd2 = gcd1.gcd_u(10);
assert_eq!(gcd2, 10);
// gcd of 10, 25 is 5
let gcd3 = gcd2.gcd_u(25);
assert_eq!(gcd3, 5);
sourcepub fn gcd_u_mut(&mut self, other: u32)
pub fn gcd_u_mut(&mut self, other: u32)
Finds the greatest common divisor.
The result is always positive except when both inputs are zero.
Examples
use rug::Integer;
let mut i = Integer::new();
// gcd of 0, 0 is 0
i.gcd_u_mut(0);
assert_eq!(i, 0);
// gcd of 0, 10 is 10
i.gcd_u_mut(10);
assert_eq!(i, 10);
// gcd of 10, 25 is 5
i.gcd_u_mut(25);
assert_eq!(i, 5);
sourcepub fn gcd_u_ref(&self, other: u32) -> GcdUIncomplete<'_>
pub fn gcd_u_ref(&self, other: u32) -> GcdUIncomplete<'_>
Finds the greatest common divisor.
The result is always positive except when both inputs are zero.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Integer
From<Src> for Integer
From<Src> for Option<u32>
Complete<Completed = Integer> for Src
The last item above is useful to obtain the result as a u32
if it
fits. If other
> 0 , the result always fits. If the result
does not fit, it is equal to the absolute value of self
.
Examples
use rug::Integer;
let i = Integer::from(100);
let r = i.gcd_u_ref(125);
// gcd of 100, 125 is 25
assert_eq!(Integer::from(r), 25);
let r = i.gcd_u_ref(125);
assert_eq!(Option::<u32>::from(r), Some(25));
sourcepub fn gcd_cofactors(self, other: Self, rop: Self) -> (Self, Self, Self)
pub fn gcd_cofactors(self, other: Self, rop: Self) -> (Self, Self, Self)
Finds the greatest common divisor (GCD) of the two inputs (self
and
other
), and two cofactors to obtain the GCD from the two inputs.
The GCD is always positive except when both inputs are zero. If the inputs are a and b, then the GCD is g and the cofactors are s and t such that
a × s + b × t = g
The values s and t are chosen such that normally, |s| < |b| / (2g) and |t| < |a| / (2g), and these relations define s and t uniquely. There are a few exceptional cases:
- If |a| = |b|, then s = 0, t = sgn(b).
- Otherwise, if b = 0 or |b| = 2g, then s = sgn(a), and if a = 0 or |a| = 2g, then t = sgn(b).
The initial value of rop
is ignored.
Examples
use rug::Integer;
let a = Integer::from(4);
let b = Integer::from(6);
let (g, s, t) = a.gcd_cofactors(b, Integer::new());
assert_eq!(g, 2);
assert_eq!(s, -1);
assert_eq!(t, 1);
sourcepub fn gcd_cofactors_mut(&mut self, other: &mut Self, rop: &mut Self)
pub fn gcd_cofactors_mut(&mut self, other: &mut Self, rop: &mut Self)
Finds the greatest common divisor (GCD) of the two inputs (self
and
other
), and two cofactors to obtain the GCD from the two inputs.
The GCD is stored in self
, and the two cofactors are stored in other
and rop
.
The GCD is always positive except when both inputs are zero. If the inputs are a and b, then the GCD is g and the cofactors are s and t such that
a × s + b × t = g
The values s and t are chosen such that normally, |s| < |b| / (2g) and |t| < |a| / (2g), and these relations define s and t uniquely. There are a few exceptional cases:
- If |a| = |b|, then s = 0, t = sgn(b).
- Otherwise, if b = 0 or |b| = 2g, then s = sgn(a), and if a = 0 or |a| = 2g, then t = sgn(b).
The initial value of rop
is ignored.
Examples
use rug::Integer;
let mut a_g = Integer::from(4);
let mut b_s = Integer::from(6);
let mut t = Integer::new();
a_g.gcd_cofactors_mut(&mut b_s, &mut t);
assert_eq!(a_g, 2);
assert_eq!(b_s, -1);
assert_eq!(t, 1);
sourcepub fn gcd_cofactors_ref<'a>(
&'a self,
other: &'a Self
) -> GcdCofactorsIncomplete<'_>
pub fn gcd_cofactors_ref<'a>(
&'a self,
other: &'a Self
) -> GcdCofactorsIncomplete<'_>
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 following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer, &mut Integer)
From<Src> for (Integer, Integer, Integer)
Complete<Completed = (Integer, Integer, Integer)> for Src
In the case that only one of the two cofactors is required, the following are also implemented:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
The GCD is always positive except when both inputs are zero. If the inputs are a and b, then the GCD is g and the 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);
sourcepub fn lcm(self, other: &Self) -> Self
pub fn lcm(self, other: &Self) -> Self
Finds the least common multiple.
The result is always positive except when one or both inputs are zero.
Examples
use rug::{Assign, Integer};
let a = Integer::from(10);
let mut b = Integer::from(25);
// lcm of 10, 25 is 50
let lcm1 = a.lcm(&b);
assert_eq!(lcm1, 50);
b.assign(0);
// lcm of 50, 0 is 0
let lcm2 = lcm1.lcm(&b);
assert_eq!(lcm2, 0);
sourcepub fn lcm_mut(&mut self, other: &Self)
pub fn lcm_mut(&mut self, other: &Self)
Finds the least common multiple.
The result is always positive except when one or both inputs are zero.
Examples
use rug::{Assign, Integer};
let mut a = Integer::from(10);
let mut b = Integer::from(25);
// lcm of 10, 25 is 50
a.lcm_mut(&b);
assert_eq!(a, 50);
b.assign(0);
// lcm of 50, 0 is 0
a.lcm_mut(&b);
assert_eq!(a, 0);
sourcepub fn lcm_ref<'a>(&'a self, other: &'a Self) -> LcmIncomplete<'_>
pub fn lcm_ref<'a>(&'a self, other: &'a Self) -> LcmIncomplete<'_>
Finds the least common multiple.
The result is always positive except when one or both inputs are zero.
The following are implemented with the returned incomplete-computation
value as Src
:
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);
sourcepub fn lcm_u(self, other: u32) -> Self
pub fn lcm_u(self, other: u32) -> Self
Finds the least common multiple.
The result is always positive except when one or both inputs are zero.
Examples
use rug::Integer;
let i = Integer::from(10);
// lcm of 10, 25 is 50
let lcm1 = i.lcm_u(25);
assert_eq!(lcm1, 50);
// lcm of 50, 0 is 0
let lcm2 = lcm1.lcm_u(0);
assert_eq!(lcm2, 0);
sourcepub fn lcm_u_mut(&mut self, other: u32)
pub fn lcm_u_mut(&mut self, other: u32)
Finds the least common multiple.
The result is always positive except when one or both inputs are zero.
Examples
use rug::Integer;
let mut i = Integer::from(10);
// lcm of 10, 25 is 50
i.lcm_u_mut(25);
assert_eq!(i, 50);
// lcm of 50, 0 is 0
i.lcm_u_mut(0);
assert_eq!(i, 0);
sourcepub fn lcm_u_ref(&self, other: u32) -> LcmUIncomplete<'_>
pub fn lcm_u_ref(&self, other: u32) -> LcmUIncomplete<'_>
Finds the least common multiple.
The result is always positive except when one or both inputs are zero.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::Integer;
let i = Integer::from(100);
let r = i.lcm_u_ref(125);
// lcm of 100, 125 is 500
assert_eq!(Integer::from(r), 500);
sourcepub fn jacobi(&self, n: &Self) -> i32
pub fn jacobi(&self, n: &Self) -> i32
Calculates the Jacobi symbol (self
/n).
Examples
use rug::{Assign, Integer};
let m = Integer::from(10);
let mut n = Integer::from(13);
assert_eq!(m.jacobi(&n), 1);
n.assign(15);
assert_eq!(m.jacobi(&n), 0);
n.assign(17);
assert_eq!(m.jacobi(&n), -1);
sourcepub fn legendre(&self, p: &Self) -> i32
pub fn legendre(&self, p: &Self) -> i32
Calculates the Legendre symbol (self
/p).
Examples
use rug::{Assign, Integer};
let a = Integer::from(5);
let mut p = Integer::from(7);
assert_eq!(a.legendre(&p), -1);
p.assign(11);
assert_eq!(a.legendre(&p), 1);
sourcepub fn kronecker(&self, n: &Self) -> i32
pub fn kronecker(&self, n: &Self) -> i32
Calculates the Jacobi symbol (self
/n) with the Kronecker
extension.
Examples
use rug::{Assign, Integer};
let k = Integer::from(3);
let mut n = Integer::from(16);
assert_eq!(k.kronecker(&n), 1);
n.assign(17);
assert_eq!(k.kronecker(&n), -1);
n.assign(18);
assert_eq!(k.kronecker(&n), 0);
sourcepub fn remove_factor(self, factor: &Self) -> (Self, u32)
pub fn remove_factor(self, factor: &Self) -> (Self, u32)
Removes all occurrences of factor
, and returns the number of
occurrences removed.
Examples
use rug::Integer;
let mut i = Integer::from(Integer::u_pow_u(13, 50));
i *= 1000;
let (remove, count) = i.remove_factor(&Integer::from(13));
assert_eq!(remove, 1000);
assert_eq!(count, 50);
sourcepub fn remove_factor_mut(&mut self, factor: &Self) -> u32
pub fn remove_factor_mut(&mut self, factor: &Self) -> u32
Removes all occurrences of factor
, and returns the number of
occurrences removed.
Examples
use rug::Integer;
let mut i = Integer::from(Integer::u_pow_u(13, 50));
i *= 1000;
let count = i.remove_factor_mut(&Integer::from(13));
assert_eq!(i, 1000);
assert_eq!(count, 50);
sourcepub fn remove_factor_ref<'a>(
&'a self,
factor: &'a Self
) -> RemoveFactorIncomplete<'a>
pub fn remove_factor_ref<'a>(
&'a self,
factor: &'a Self
) -> RemoveFactorIncomplete<'a>
Removes all occurrences of factor
, and counts the number of
occurrences removed.
Examples
use rug::{Assign, Integer};
let mut i = Integer::from(Integer::u_pow_u(13, 50));
i *= 1000;
let factor = Integer::from(13);
let r = i.remove_factor_ref(&factor);
let (mut j, mut count) = (Integer::new(), 0);
(&mut j, &mut count).assign(r);
assert_eq!(count, 50);
assert_eq!(j, 1000);
sourcepub fn factorial(n: u32) -> FactorialIncomplete
pub fn factorial(n: u32) -> FactorialIncomplete
Computes the factorial of n.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Complete, Integer};
// 10 × 9 × 8 × 7 × 6 × 5 × 4 × 3 × 2 × 1
assert_eq!(Integer::factorial(10).complete(), 3628800);
sourcepub fn factorial_2(n: u32) -> Factorial2Incomplete
pub fn factorial_2(n: u32) -> Factorial2Incomplete
Computes the double factorial of n.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Complete, Integer};
// 10 × 8 × 6 × 4 × 2
assert_eq!(Integer::factorial_2(10).complete(), 3840);
sourcepub fn factorial_m(n: u32, m: u32) -> FactorialMIncomplete
pub fn factorial_m(n: u32, m: u32) -> FactorialMIncomplete
Computes the m-multi factorial of n.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Complete, Integer};
// 10 × 7 × 4 × 1
assert_eq!(Integer::factorial_m(10, 3).complete(), 280);
sourcepub fn primorial(n: u32) -> PrimorialIncomplete
pub fn primorial(n: u32) -> PrimorialIncomplete
Computes the primorial of n.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Complete, Integer};
// 7 × 5 × 3 × 2
assert_eq!(Integer::primorial(10).complete(), 210);
sourcepub fn binomial(self, k: u32) -> Self
pub fn binomial(self, k: u32) -> Self
Computes the binomial coefficient over k.
Examples
use rug::Integer;
// 7 choose 2 is 21
let i = Integer::from(7);
let bin = i.binomial(2);
assert_eq!(bin, 21);
sourcepub fn binomial_mut(&mut self, k: u32)
pub fn binomial_mut(&mut self, k: u32)
Computes the binomial coefficient over k.
Examples
use rug::Integer;
// 7 choose 2 is 21
let mut i = Integer::from(7);
i.binomial_mut(2);
assert_eq!(i, 21);
sourcepub fn binomial_ref(&self, k: u32) -> BinomialIncomplete<'_>
pub fn binomial_ref(&self, k: u32) -> BinomialIncomplete<'_>
Computes the binomial coefficient over k.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{Complete, Integer};
// 7 choose 2 is 21
let i = Integer::from(7);
assert_eq!(i.binomial_ref(2).complete(), 21);
sourcepub fn binomial_u(n: u32, k: u32) -> BinomialUIncomplete
pub fn binomial_u(n: u32, k: u32) -> BinomialUIncomplete
Computes the binomial coefficient n over k.
The following are implemented with the returned incomplete-computation
value as Src
:
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);
sourcepub fn fibonacci(n: u32) -> FibonacciIncomplete
pub fn fibonacci(n: u32) -> FibonacciIncomplete
Computes the Fibonacci number.
The following 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::{Complete, Integer};
assert_eq!(Integer::fibonacci(12).complete(), 144);
sourcepub fn fibonacci_2(n: u32) -> Fibonacci2Incomplete
pub fn fibonacci_2(n: u32) -> Fibonacci2Incomplete
Computes a Fibonacci number, and the previous Fibonacci number.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
This function is meant to calculate isolated numbers. If a sequence of Fibonacci numbers is required, the first two values of the sequence should be computed with this function, then iterations should be used.
Examples
use rug::{Assign, Integer};
let f = Integer::fibonacci_2(12);
let mut pair = <(Integer, Integer)>::from(f);
assert_eq!(pair.0, 144);
assert_eq!(pair.1, 89);
// Fibonacci number F[-1] is 1
pair.assign(Integer::fibonacci_2(0));
assert_eq!(pair.0, 0);
assert_eq!(pair.1, 1);
sourcepub fn lucas(n: u32) -> LucasIncomplete
pub fn lucas(n: u32) -> LucasIncomplete
Computes the Lucas number.
The following 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::{Complete, Integer};
assert_eq!(Integer::lucas(12).complete(), 322);
sourcepub fn lucas_2(n: u32) -> Lucas2Incomplete
pub fn lucas_2(n: u32) -> Lucas2Incomplete
Computes a Lucas number, and the previous Lucas number.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Integer, Integer)
Assign<Src> for (&mut Integer, &mut Integer)
From<Src> for (Integer, Integer)
Complete<Completed = (Integer, Integer)> for Src
This function is meant to calculate isolated numbers. If a sequence of Lucas numbers is required, the first two values of the sequence should be computed with this function, then iterations should be used.
Examples
use rug::{Assign, Integer};
let l = Integer::lucas_2(12);
let mut pair = <(Integer, Integer)>::from(l);
assert_eq!(pair.0, 322);
assert_eq!(pair.1, 199);
pair.assign(Integer::lucas_2(0));
assert_eq!(pair.0, 2);
assert_eq!(pair.1, -1);
sourcepub fn random_bits(
bits: u32,
rng: &mut dyn MutRandState
) -> RandomBitsIncomplete<'_>
pub fn random_bits(
bits: u32,
rng: &mut dyn MutRandState
) -> RandomBitsIncomplete<'_>
Generates a random number with a specified maximum number of bits.
The following are implemented with the returned incomplete-computation
value as Src
:
Examples
use rug::{rand::RandState, 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);
sourcepub fn random_below(self, rng: &mut dyn MutRandState) -> Self
pub fn random_below(self, rng: &mut dyn MutRandState) -> Self
Generates a non-negative random number below the given boundary value.
Panics
Panics if the boundary value is less than or equal to zero.
Examples
use rug::{rand::RandState, 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);
sourcepub fn random_below_mut(&mut self, rng: &mut dyn MutRandState)
pub fn random_below_mut(&mut self, rng: &mut dyn MutRandState)
Generates a non-negative random number below the given boundary value.
Panics
Panics if the boundary value is less than or equal to zero.
Examples
use rug::{rand::RandState, 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);
sourcepub fn random_below_ref<'a>(
&'a self,
rng: &'a mut dyn MutRandState
) -> RandomBelowIncomplete<'a>
pub fn random_below_ref<'a>(
&'a self,
rng: &'a mut dyn MutRandState
) -> RandomBelowIncomplete<'a>
Generates a non-negative random number below the given boundary value.
The following are implemented with the returned incomplete-computation
value as Src
:
Panics
Panics if the boundary value is less than or equal to zero.
Examples
use rug::{rand::RandState, 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
sourceimpl AddAssign<&Integer> for Complex
impl AddAssign<&Integer> for Complex
sourcefn add_assign(&mut self, rhs: &Integer)
fn add_assign(&mut self, rhs: &Integer)
Performs the +=
operation. Read more
sourceimpl AddAssign<&Integer> for Float
impl AddAssign<&Integer> for Float
sourcefn add_assign(&mut self, rhs: &Integer)
fn add_assign(&mut self, rhs: &Integer)
Performs the +=
operation. Read more
sourceimpl AddAssign<&Integer> for Integer
impl AddAssign<&Integer> for Integer
sourcefn add_assign(&mut self, rhs: &Integer)
fn add_assign(&mut self, rhs: &Integer)
Performs the +=
operation. Read more
sourceimpl AddAssign<&Integer> for Rational
impl AddAssign<&Integer> for Rational
sourcefn add_assign(&mut self, rhs: &Integer)
fn add_assign(&mut self, rhs: &Integer)
Performs the +=
operation. Read more
sourceimpl AddAssign<&i128> for Integer
impl AddAssign<&i128> for Integer
sourcefn add_assign(&mut self, rhs: &i128)
fn add_assign(&mut self, rhs: &i128)
Performs the +=
operation. Read more
sourceimpl AddAssign<&i16> for Integer
impl AddAssign<&i16> for Integer
sourcefn add_assign(&mut self, rhs: &i16)
fn add_assign(&mut self, rhs: &i16)
Performs the +=
operation. Read more
sourceimpl AddAssign<&i32> for Integer
impl AddAssign<&i32> for Integer
sourcefn add_assign(&mut self, rhs: &i32)
fn add_assign(&mut self, rhs: &i32)
Performs the +=
operation. Read more
sourceimpl AddAssign<&i64> for Integer
impl AddAssign<&i64> for Integer
sourcefn add_assign(&mut self, rhs: &i64)
fn add_assign(&mut self, rhs: &i64)
Performs the +=
operation. Read more
sourceimpl AddAssign<&i8> for Integer
impl AddAssign<&i8> for Integer
sourcefn add_assign(&mut self, rhs: &i8)
fn add_assign(&mut self, rhs: &i8)
Performs the +=
operation. Read more
sourceimpl AddAssign<&isize> for Integer
impl AddAssign<&isize> for Integer
sourcefn add_assign(&mut self, rhs: &isize)
fn add_assign(&mut self, rhs: &isize)
Performs the +=
operation. Read more
sourceimpl AddAssign<&u128> for Integer
impl AddAssign<&u128> for Integer
sourcefn add_assign(&mut self, rhs: &u128)
fn add_assign(&mut self, rhs: &u128)
Performs the +=
operation. Read more
sourceimpl AddAssign<&u16> for Integer
impl AddAssign<&u16> for Integer
sourcefn add_assign(&mut self, rhs: &u16)
fn add_assign(&mut self, rhs: &u16)
Performs the +=
operation. Read more
sourceimpl AddAssign<&u32> for Integer
impl AddAssign<&u32> for Integer
sourcefn add_assign(&mut self, rhs: &u32)
fn add_assign(&mut self, rhs: &u32)
Performs the +=
operation. Read more
sourceimpl AddAssign<&u64> for Integer
impl AddAssign<&u64> for Integer
sourcefn add_assign(&mut self, rhs: &u64)
fn add_assign(&mut self, rhs: &u64)
Performs the +=
operation. Read more
sourceimpl AddAssign<&u8> for Integer
impl AddAssign<&u8> for Integer
sourcefn add_assign(&mut self, rhs: &u8)
fn add_assign(&mut self, rhs: &u8)
Performs the +=
operation. Read more
sourceimpl AddAssign<&usize> for Integer
impl AddAssign<&usize> for Integer
sourcefn add_assign(&mut self, rhs: &usize)
fn add_assign(&mut self, rhs: &usize)
Performs the +=
operation. Read more
sourceimpl AddAssign<Integer> for Complex
impl AddAssign<Integer> for Complex
sourcefn add_assign(&mut self, rhs: Integer)
fn add_assign(&mut self, rhs: Integer)
Performs the +=
operation. Read more
sourceimpl AddAssign<Integer> for Float
impl AddAssign<Integer> for Float
sourcefn add_assign(&mut self, rhs: Integer)
fn add_assign(&mut self, rhs: Integer)
Performs the +=
operation. Read more
sourceimpl AddAssign<Integer> for Integer
impl AddAssign<Integer> for Integer
sourcefn add_assign(&mut self, rhs: Integer)
fn add_assign(&mut self, rhs: Integer)
Performs the +=
operation. Read more
sourceimpl AddAssign<Integer> for Rational
impl AddAssign<Integer> for Rational
sourcefn add_assign(&mut self, rhs: Integer)
fn add_assign(&mut self, rhs: Integer)
Performs the +=
operation. Read more
sourceimpl AddAssign<i128> for Integer
impl AddAssign<i128> for Integer
sourcefn add_assign(&mut self, rhs: i128)
fn add_assign(&mut self, rhs: i128)
Performs the +=
operation. Read more
sourceimpl AddAssign<i16> for Integer
impl AddAssign<i16> for Integer
sourcefn add_assign(&mut self, rhs: i16)
fn add_assign(&mut self, rhs: i16)
Performs the +=
operation. Read more
sourceimpl AddAssign<i32> for Integer
impl AddAssign<i32> for Integer
sourcefn add_assign(&mut self, rhs: i32)
fn add_assign(&mut self, rhs: i32)
Performs the +=
operation. Read more
sourceimpl AddAssign<i64> for Integer
impl AddAssign<i64> for Integer
sourcefn add_assign(&mut self, rhs: i64)
fn add_assign(&mut self, rhs: i64)
Performs the +=
operation. Read more
sourceimpl AddAssign<i8> for Integer
impl AddAssign<i8> for Integer
sourcefn add_assign(&mut self, rhs: i8)
fn add_assign(&mut self, rhs: i8)
Performs the +=
operation. Read more
sourceimpl AddAssign<isize> for Integer
impl AddAssign<isize> for Integer
sourcefn add_assign(&mut self, rhs: isize)
fn add_assign(&mut self, rhs: isize)
Performs the +=
operation. Read more
sourceimpl AddAssign<u128> for Integer
impl AddAssign<u128> for Integer
sourcefn add_assign(&mut self, rhs: u128)
fn add_assign(&mut self, rhs: u128)
Performs the +=
operation. Read more
sourceimpl AddAssign<u16> for Integer
impl AddAssign<u16> for Integer
sourcefn add_assign(&mut self, rhs: u16)
fn add_assign(&mut self, rhs: u16)
Performs the +=
operation. Read more
sourceimpl AddAssign<u32> for Integer
impl AddAssign<u32> for Integer
sourcefn add_assign(&mut self, rhs: u32)
fn add_assign(&mut self, rhs: u32)
Performs the +=
operation. Read more
sourceimpl AddAssign<u64> for Integer
impl AddAssign<u64> for Integer
sourcefn add_assign(&mut self, rhs: u64)
fn add_assign(&mut self, rhs: u64)
Performs the +=
operation. Read more
sourceimpl AddAssign<u8> for Integer
impl AddAssign<u8> for Integer
sourcefn add_assign(&mut self, rhs: u8)
fn add_assign(&mut self, rhs: u8)
Performs the +=
operation. Read more
sourceimpl AddAssign<usize> for Integer
impl AddAssign<usize> for Integer
sourcefn add_assign(&mut self, rhs: usize)
fn add_assign(&mut self, rhs: usize)
Performs the +=
operation. Read more
sourceimpl AddAssignRound<&Integer> for Complex
impl AddAssignRound<&Integer> for Complex
sourceimpl AddAssignRound<&Integer> for Float
impl AddAssignRound<&Integer> for Float
sourceimpl AddAssignRound<Integer> for Complex
impl AddAssignRound<Integer> for Complex
sourceimpl AddAssignRound<Integer> for Float
impl AddAssignRound<Integer> for Float
sourceimpl AddFromRound<&Integer> for Complex
impl AddFromRound<&Integer> for Complex
sourceimpl AddFromRound<&Integer> for Float
impl AddFromRound<&Integer> for Float
sourceimpl AddFromRound<Integer> for Complex
impl AddFromRound<Integer> for Complex
sourceimpl AddFromRound<Integer> for Float
impl AddFromRound<Integer> for Float
sourceimpl AssignRound<&Integer> for Float
impl AssignRound<&Integer> for Float
sourceimpl AssignRound<Integer> for Float
impl AssignRound<Integer> for Float
sourceimpl BitAndAssign<&Integer> for Integer
impl BitAndAssign<&Integer> for Integer
sourcefn bitand_assign(&mut self, rhs: &Integer)
fn bitand_assign(&mut self, rhs: &Integer)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&i128> for Integer
impl BitAndAssign<&i128> for Integer
sourcefn bitand_assign(&mut self, rhs: &i128)
fn bitand_assign(&mut self, rhs: &i128)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&i16> for Integer
impl BitAndAssign<&i16> for Integer
sourcefn bitand_assign(&mut self, rhs: &i16)
fn bitand_assign(&mut self, rhs: &i16)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&i32> for Integer
impl BitAndAssign<&i32> for Integer
sourcefn bitand_assign(&mut self, rhs: &i32)
fn bitand_assign(&mut self, rhs: &i32)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&i64> for Integer
impl BitAndAssign<&i64> for Integer
sourcefn bitand_assign(&mut self, rhs: &i64)
fn bitand_assign(&mut self, rhs: &i64)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&i8> for Integer
impl BitAndAssign<&i8> for Integer
sourcefn bitand_assign(&mut self, rhs: &i8)
fn bitand_assign(&mut self, rhs: &i8)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&isize> for Integer
impl BitAndAssign<&isize> for Integer
sourcefn bitand_assign(&mut self, rhs: &isize)
fn bitand_assign(&mut self, rhs: &isize)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&u128> for Integer
impl BitAndAssign<&u128> for Integer
sourcefn bitand_assign(&mut self, rhs: &u128)
fn bitand_assign(&mut self, rhs: &u128)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&u16> for Integer
impl BitAndAssign<&u16> for Integer
sourcefn bitand_assign(&mut self, rhs: &u16)
fn bitand_assign(&mut self, rhs: &u16)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&u32> for Integer
impl BitAndAssign<&u32> for Integer
sourcefn bitand_assign(&mut self, rhs: &u32)
fn bitand_assign(&mut self, rhs: &u32)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&u64> for Integer
impl BitAndAssign<&u64> for Integer
sourcefn bitand_assign(&mut self, rhs: &u64)
fn bitand_assign(&mut self, rhs: &u64)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&u8> for Integer
impl BitAndAssign<&u8> for Integer
sourcefn bitand_assign(&mut self, rhs: &u8)
fn bitand_assign(&mut self, rhs: &u8)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<&usize> for Integer
impl BitAndAssign<&usize> for Integer
sourcefn bitand_assign(&mut self, rhs: &usize)
fn bitand_assign(&mut self, rhs: &usize)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<Integer> for Integer
impl BitAndAssign<Integer> for Integer
sourcefn bitand_assign(&mut self, rhs: Integer)
fn bitand_assign(&mut self, rhs: Integer)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<i128> for Integer
impl BitAndAssign<i128> for Integer
sourcefn bitand_assign(&mut self, rhs: i128)
fn bitand_assign(&mut self, rhs: i128)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<i16> for Integer
impl BitAndAssign<i16> for Integer
sourcefn bitand_assign(&mut self, rhs: i16)
fn bitand_assign(&mut self, rhs: i16)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<i32> for Integer
impl BitAndAssign<i32> for Integer
sourcefn bitand_assign(&mut self, rhs: i32)
fn bitand_assign(&mut self, rhs: i32)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<i64> for Integer
impl BitAndAssign<i64> for Integer
sourcefn bitand_assign(&mut self, rhs: i64)
fn bitand_assign(&mut self, rhs: i64)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<i8> for Integer
impl BitAndAssign<i8> for Integer
sourcefn bitand_assign(&mut self, rhs: i8)
fn bitand_assign(&mut self, rhs: i8)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<isize> for Integer
impl BitAndAssign<isize> for Integer
sourcefn bitand_assign(&mut self, rhs: isize)
fn bitand_assign(&mut self, rhs: isize)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<u128> for Integer
impl BitAndAssign<u128> for Integer
sourcefn bitand_assign(&mut self, rhs: u128)
fn bitand_assign(&mut self, rhs: u128)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<u16> for Integer
impl BitAndAssign<u16> for Integer
sourcefn bitand_assign(&mut self, rhs: u16)
fn bitand_assign(&mut self, rhs: u16)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<u32> for Integer
impl BitAndAssign<u32> for Integer
sourcefn bitand_assign(&mut self, rhs: u32)
fn bitand_assign(&mut self, rhs: u32)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<u64> for Integer
impl BitAndAssign<u64> for Integer
sourcefn bitand_assign(&mut self, rhs: u64)
fn bitand_assign(&mut self, rhs: u64)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<u8> for Integer
impl BitAndAssign<u8> for Integer
sourcefn bitand_assign(&mut self, rhs: u8)
fn bitand_assign(&mut self, rhs: u8)
Performs the &=
operation. Read more
sourceimpl BitAndAssign<usize> for Integer
impl BitAndAssign<usize> for Integer
sourcefn bitand_assign(&mut self, rhs: usize)
fn bitand_assign(&mut self, rhs: usize)
Performs the &=
operation. Read more
sourceimpl BitAndFrom<&Integer> for Integer
impl BitAndFrom<&Integer> for Integer
sourcefn bitand_from(&mut self, lhs: &Integer)
fn bitand_from(&mut self, lhs: &Integer)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&i128> for Integer
impl BitAndFrom<&i128> for Integer
sourcefn bitand_from(&mut self, lhs: &i128)
fn bitand_from(&mut self, lhs: &i128)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&i16> for Integer
impl BitAndFrom<&i16> for Integer
sourcefn bitand_from(&mut self, lhs: &i16)
fn bitand_from(&mut self, lhs: &i16)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&i32> for Integer
impl BitAndFrom<&i32> for Integer
sourcefn bitand_from(&mut self, lhs: &i32)
fn bitand_from(&mut self, lhs: &i32)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&i64> for Integer
impl BitAndFrom<&i64> for Integer
sourcefn bitand_from(&mut self, lhs: &i64)
fn bitand_from(&mut self, lhs: &i64)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&i8> for Integer
impl BitAndFrom<&i8> for Integer
sourcefn bitand_from(&mut self, lhs: &i8)
fn bitand_from(&mut self, lhs: &i8)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&isize> for Integer
impl BitAndFrom<&isize> for Integer
sourcefn bitand_from(&mut self, lhs: &isize)
fn bitand_from(&mut self, lhs: &isize)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&u128> for Integer
impl BitAndFrom<&u128> for Integer
sourcefn bitand_from(&mut self, lhs: &u128)
fn bitand_from(&mut self, lhs: &u128)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&u16> for Integer
impl BitAndFrom<&u16> for Integer
sourcefn bitand_from(&mut self, lhs: &u16)
fn bitand_from(&mut self, lhs: &u16)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&u32> for Integer
impl BitAndFrom<&u32> for Integer
sourcefn bitand_from(&mut self, lhs: &u32)
fn bitand_from(&mut self, lhs: &u32)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&u64> for Integer
impl BitAndFrom<&u64> for Integer
sourcefn bitand_from(&mut self, lhs: &u64)
fn bitand_from(&mut self, lhs: &u64)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&u8> for Integer
impl BitAndFrom<&u8> for Integer
sourcefn bitand_from(&mut self, lhs: &u8)
fn bitand_from(&mut self, lhs: &u8)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<&usize> for Integer
impl BitAndFrom<&usize> for Integer
sourcefn bitand_from(&mut self, lhs: &usize)
fn bitand_from(&mut self, lhs: &usize)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<Integer> for Integer
impl BitAndFrom<Integer> for Integer
sourcefn bitand_from(&mut self, lhs: Integer)
fn bitand_from(&mut self, lhs: Integer)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<i128> for Integer
impl BitAndFrom<i128> for Integer
sourcefn bitand_from(&mut self, lhs: i128)
fn bitand_from(&mut self, lhs: i128)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<i16> for Integer
impl BitAndFrom<i16> for Integer
sourcefn bitand_from(&mut self, lhs: i16)
fn bitand_from(&mut self, lhs: i16)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<i32> for Integer
impl BitAndFrom<i32> for Integer
sourcefn bitand_from(&mut self, lhs: i32)
fn bitand_from(&mut self, lhs: i32)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<i64> for Integer
impl BitAndFrom<i64> for Integer
sourcefn bitand_from(&mut self, lhs: i64)
fn bitand_from(&mut self, lhs: i64)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<i8> for Integer
impl BitAndFrom<i8> for Integer
sourcefn bitand_from(&mut self, lhs: i8)
fn bitand_from(&mut self, lhs: i8)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<isize> for Integer
impl BitAndFrom<isize> for Integer
sourcefn bitand_from(&mut self, lhs: isize)
fn bitand_from(&mut self, lhs: isize)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<u128> for Integer
impl BitAndFrom<u128> for Integer
sourcefn bitand_from(&mut self, lhs: u128)
fn bitand_from(&mut self, lhs: u128)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<u16> for Integer
impl BitAndFrom<u16> for Integer
sourcefn bitand_from(&mut self, lhs: u16)
fn bitand_from(&mut self, lhs: u16)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<u32> for Integer
impl BitAndFrom<u32> for Integer
sourcefn bitand_from(&mut self, lhs: u32)
fn bitand_from(&mut self, lhs: u32)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<u64> for Integer
impl BitAndFrom<u64> for Integer
sourcefn bitand_from(&mut self, lhs: u64)
fn bitand_from(&mut self, lhs: u64)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<u8> for Integer
impl BitAndFrom<u8> for Integer
sourcefn bitand_from(&mut self, lhs: u8)
fn bitand_from(&mut self, lhs: u8)
Peforms the AND operation. Read more
sourceimpl BitAndFrom<usize> for Integer
impl BitAndFrom<usize> for Integer
sourcefn bitand_from(&mut self, lhs: usize)
fn bitand_from(&mut self, lhs: usize)
Peforms the AND operation. Read more
sourceimpl BitOrAssign<&Integer> for Integer
impl BitOrAssign<&Integer> for Integer
sourcefn bitor_assign(&mut self, rhs: &Integer)
fn bitor_assign(&mut self, rhs: &Integer)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&i128> for Integer
impl BitOrAssign<&i128> for Integer
sourcefn bitor_assign(&mut self, rhs: &i128)
fn bitor_assign(&mut self, rhs: &i128)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&i16> for Integer
impl BitOrAssign<&i16> for Integer
sourcefn bitor_assign(&mut self, rhs: &i16)
fn bitor_assign(&mut self, rhs: &i16)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&i32> for Integer
impl BitOrAssign<&i32> for Integer
sourcefn bitor_assign(&mut self, rhs: &i32)
fn bitor_assign(&mut self, rhs: &i32)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&i64> for Integer
impl BitOrAssign<&i64> for Integer
sourcefn bitor_assign(&mut self, rhs: &i64)
fn bitor_assign(&mut self, rhs: &i64)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&i8> for Integer
impl BitOrAssign<&i8> for Integer
sourcefn bitor_assign(&mut self, rhs: &i8)
fn bitor_assign(&mut self, rhs: &i8)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&isize> for Integer
impl BitOrAssign<&isize> for Integer
sourcefn bitor_assign(&mut self, rhs: &isize)
fn bitor_assign(&mut self, rhs: &isize)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&u128> for Integer
impl BitOrAssign<&u128> for Integer
sourcefn bitor_assign(&mut self, rhs: &u128)
fn bitor_assign(&mut self, rhs: &u128)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&u16> for Integer
impl BitOrAssign<&u16> for Integer
sourcefn bitor_assign(&mut self, rhs: &u16)
fn bitor_assign(&mut self, rhs: &u16)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&u32> for Integer
impl BitOrAssign<&u32> for Integer
sourcefn bitor_assign(&mut self, rhs: &u32)
fn bitor_assign(&mut self, rhs: &u32)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&u64> for Integer
impl BitOrAssign<&u64> for Integer
sourcefn bitor_assign(&mut self, rhs: &u64)
fn bitor_assign(&mut self, rhs: &u64)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&u8> for Integer
impl BitOrAssign<&u8> for Integer
sourcefn bitor_assign(&mut self, rhs: &u8)
fn bitor_assign(&mut self, rhs: &u8)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<&usize> for Integer
impl BitOrAssign<&usize> for Integer
sourcefn bitor_assign(&mut self, rhs: &usize)
fn bitor_assign(&mut self, rhs: &usize)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<Integer> for Integer
impl BitOrAssign<Integer> for Integer
sourcefn bitor_assign(&mut self, rhs: Integer)
fn bitor_assign(&mut self, rhs: Integer)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<i128> for Integer
impl BitOrAssign<i128> for Integer
sourcefn bitor_assign(&mut self, rhs: i128)
fn bitor_assign(&mut self, rhs: i128)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<i16> for Integer
impl BitOrAssign<i16> for Integer
sourcefn bitor_assign(&mut self, rhs: i16)
fn bitor_assign(&mut self, rhs: i16)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<i32> for Integer
impl BitOrAssign<i32> for Integer
sourcefn bitor_assign(&mut self, rhs: i32)
fn bitor_assign(&mut self, rhs: i32)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<i64> for Integer
impl BitOrAssign<i64> for Integer
sourcefn bitor_assign(&mut self, rhs: i64)
fn bitor_assign(&mut self, rhs: i64)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<i8> for Integer
impl BitOrAssign<i8> for Integer
sourcefn bitor_assign(&mut self, rhs: i8)
fn bitor_assign(&mut self, rhs: i8)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<isize> for Integer
impl BitOrAssign<isize> for Integer
sourcefn bitor_assign(&mut self, rhs: isize)
fn bitor_assign(&mut self, rhs: isize)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<u128> for Integer
impl BitOrAssign<u128> for Integer
sourcefn bitor_assign(&mut self, rhs: u128)
fn bitor_assign(&mut self, rhs: u128)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<u16> for Integer
impl BitOrAssign<u16> for Integer
sourcefn bitor_assign(&mut self, rhs: u16)
fn bitor_assign(&mut self, rhs: u16)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<u32> for Integer
impl BitOrAssign<u32> for Integer
sourcefn bitor_assign(&mut self, rhs: u32)
fn bitor_assign(&mut self, rhs: u32)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<u64> for Integer
impl BitOrAssign<u64> for Integer
sourcefn bitor_assign(&mut self, rhs: u64)
fn bitor_assign(&mut self, rhs: u64)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<u8> for Integer
impl BitOrAssign<u8> for Integer
sourcefn bitor_assign(&mut self, rhs: u8)
fn bitor_assign(&mut self, rhs: u8)
Performs the |=
operation. Read more
sourceimpl BitOrAssign<usize> for Integer
impl BitOrAssign<usize> for Integer
sourcefn bitor_assign(&mut self, rhs: usize)
fn bitor_assign(&mut self, rhs: usize)
Performs the |=
operation. Read more
sourceimpl BitOrFrom<&Integer> for Integer
impl BitOrFrom<&Integer> for Integer
sourcefn bitor_from(&mut self, lhs: &Integer)
fn bitor_from(&mut self, lhs: &Integer)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&i128> for Integer
impl BitOrFrom<&i128> for Integer
sourcefn bitor_from(&mut self, lhs: &i128)
fn bitor_from(&mut self, lhs: &i128)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&i16> for Integer
impl BitOrFrom<&i16> for Integer
sourcefn bitor_from(&mut self, lhs: &i16)
fn bitor_from(&mut self, lhs: &i16)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&i32> for Integer
impl BitOrFrom<&i32> for Integer
sourcefn bitor_from(&mut self, lhs: &i32)
fn bitor_from(&mut self, lhs: &i32)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&i64> for Integer
impl BitOrFrom<&i64> for Integer
sourcefn bitor_from(&mut self, lhs: &i64)
fn bitor_from(&mut self, lhs: &i64)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&i8> for Integer
impl BitOrFrom<&i8> for Integer
sourcefn bitor_from(&mut self, lhs: &i8)
fn bitor_from(&mut self, lhs: &i8)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&isize> for Integer
impl BitOrFrom<&isize> for Integer
sourcefn bitor_from(&mut self, lhs: &isize)
fn bitor_from(&mut self, lhs: &isize)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&u128> for Integer
impl BitOrFrom<&u128> for Integer
sourcefn bitor_from(&mut self, lhs: &u128)
fn bitor_from(&mut self, lhs: &u128)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&u16> for Integer
impl BitOrFrom<&u16> for Integer
sourcefn bitor_from(&mut self, lhs: &u16)
fn bitor_from(&mut self, lhs: &u16)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&u32> for Integer
impl BitOrFrom<&u32> for Integer
sourcefn bitor_from(&mut self, lhs: &u32)
fn bitor_from(&mut self, lhs: &u32)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&u64> for Integer
impl BitOrFrom<&u64> for Integer
sourcefn bitor_from(&mut self, lhs: &u64)
fn bitor_from(&mut self, lhs: &u64)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&u8> for Integer
impl BitOrFrom<&u8> for Integer
sourcefn bitor_from(&mut self, lhs: &u8)
fn bitor_from(&mut self, lhs: &u8)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<&usize> for Integer
impl BitOrFrom<&usize> for Integer
sourcefn bitor_from(&mut self, lhs: &usize)
fn bitor_from(&mut self, lhs: &usize)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<Integer> for Integer
impl BitOrFrom<Integer> for Integer
sourcefn bitor_from(&mut self, lhs: Integer)
fn bitor_from(&mut self, lhs: Integer)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<i128> for Integer
impl BitOrFrom<i128> for Integer
sourcefn bitor_from(&mut self, lhs: i128)
fn bitor_from(&mut self, lhs: i128)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<i16> for Integer
impl BitOrFrom<i16> for Integer
sourcefn bitor_from(&mut self, lhs: i16)
fn bitor_from(&mut self, lhs: i16)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<i32> for Integer
impl BitOrFrom<i32> for Integer
sourcefn bitor_from(&mut self, lhs: i32)
fn bitor_from(&mut self, lhs: i32)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<i64> for Integer
impl BitOrFrom<i64> for Integer
sourcefn bitor_from(&mut self, lhs: i64)
fn bitor_from(&mut self, lhs: i64)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<i8> for Integer
impl BitOrFrom<i8> for Integer
sourcefn bitor_from(&mut self, lhs: i8)
fn bitor_from(&mut self, lhs: i8)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<isize> for Integer
impl BitOrFrom<isize> for Integer
sourcefn bitor_from(&mut self, lhs: isize)
fn bitor_from(&mut self, lhs: isize)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<u128> for Integer
impl BitOrFrom<u128> for Integer
sourcefn bitor_from(&mut self, lhs: u128)
fn bitor_from(&mut self, lhs: u128)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<u16> for Integer
impl BitOrFrom<u16> for Integer
sourcefn bitor_from(&mut self, lhs: u16)
fn bitor_from(&mut self, lhs: u16)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<u32> for Integer
impl BitOrFrom<u32> for Integer
sourcefn bitor_from(&mut self, lhs: u32)
fn bitor_from(&mut self, lhs: u32)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<u64> for Integer
impl BitOrFrom<u64> for Integer
sourcefn bitor_from(&mut self, lhs: u64)
fn bitor_from(&mut self, lhs: u64)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<u8> for Integer
impl BitOrFrom<u8> for Integer
sourcefn bitor_from(&mut self, lhs: u8)
fn bitor_from(&mut self, lhs: u8)
Peforms the OR operation. Read more
sourceimpl BitOrFrom<usize> for Integer
impl BitOrFrom<usize> for Integer
sourcefn bitor_from(&mut self, lhs: usize)
fn bitor_from(&mut self, lhs: usize)
Peforms the OR operation. Read more
sourceimpl BitXorAssign<&Integer> for Integer
impl BitXorAssign<&Integer> for Integer
sourcefn bitxor_assign(&mut self, rhs: &Integer)
fn bitxor_assign(&mut self, rhs: &Integer)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&i128> for Integer
impl BitXorAssign<&i128> for Integer
sourcefn bitxor_assign(&mut self, rhs: &i128)
fn bitxor_assign(&mut self, rhs: &i128)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&i16> for Integer
impl BitXorAssign<&i16> for Integer
sourcefn bitxor_assign(&mut self, rhs: &i16)
fn bitxor_assign(&mut self, rhs: &i16)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&i32> for Integer
impl BitXorAssign<&i32> for Integer
sourcefn bitxor_assign(&mut self, rhs: &i32)
fn bitxor_assign(&mut self, rhs: &i32)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&i64> for Integer
impl BitXorAssign<&i64> for Integer
sourcefn bitxor_assign(&mut self, rhs: &i64)
fn bitxor_assign(&mut self, rhs: &i64)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&i8> for Integer
impl BitXorAssign<&i8> for Integer
sourcefn bitxor_assign(&mut self, rhs: &i8)
fn bitxor_assign(&mut self, rhs: &i8)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&isize> for Integer
impl BitXorAssign<&isize> for Integer
sourcefn bitxor_assign(&mut self, rhs: &isize)
fn bitxor_assign(&mut self, rhs: &isize)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&u128> for Integer
impl BitXorAssign<&u128> for Integer
sourcefn bitxor_assign(&mut self, rhs: &u128)
fn bitxor_assign(&mut self, rhs: &u128)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&u16> for Integer
impl BitXorAssign<&u16> for Integer
sourcefn bitxor_assign(&mut self, rhs: &u16)
fn bitxor_assign(&mut self, rhs: &u16)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&u32> for Integer
impl BitXorAssign<&u32> for Integer
sourcefn bitxor_assign(&mut self, rhs: &u32)
fn bitxor_assign(&mut self, rhs: &u32)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&u64> for Integer
impl BitXorAssign<&u64> for Integer
sourcefn bitxor_assign(&mut self, rhs: &u64)
fn bitxor_assign(&mut self, rhs: &u64)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&u8> for Integer
impl BitXorAssign<&u8> for Integer
sourcefn bitxor_assign(&mut self, rhs: &u8)
fn bitxor_assign(&mut self, rhs: &u8)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<&usize> for Integer
impl BitXorAssign<&usize> for Integer
sourcefn bitxor_assign(&mut self, rhs: &usize)
fn bitxor_assign(&mut self, rhs: &usize)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<Integer> for Integer
impl BitXorAssign<Integer> for Integer
sourcefn bitxor_assign(&mut self, rhs: Integer)
fn bitxor_assign(&mut self, rhs: Integer)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<i128> for Integer
impl BitXorAssign<i128> for Integer
sourcefn bitxor_assign(&mut self, rhs: i128)
fn bitxor_assign(&mut self, rhs: i128)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<i16> for Integer
impl BitXorAssign<i16> for Integer
sourcefn bitxor_assign(&mut self, rhs: i16)
fn bitxor_assign(&mut self, rhs: i16)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<i32> for Integer
impl BitXorAssign<i32> for Integer
sourcefn bitxor_assign(&mut self, rhs: i32)
fn bitxor_assign(&mut self, rhs: i32)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<i64> for Integer
impl BitXorAssign<i64> for Integer
sourcefn bitxor_assign(&mut self, rhs: i64)
fn bitxor_assign(&mut self, rhs: i64)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<i8> for Integer
impl BitXorAssign<i8> for Integer
sourcefn bitxor_assign(&mut self, rhs: i8)
fn bitxor_assign(&mut self, rhs: i8)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<isize> for Integer
impl BitXorAssign<isize> for Integer
sourcefn bitxor_assign(&mut self, rhs: isize)
fn bitxor_assign(&mut self, rhs: isize)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<u128> for Integer
impl BitXorAssign<u128> for Integer
sourcefn bitxor_assign(&mut self, rhs: u128)
fn bitxor_assign(&mut self, rhs: u128)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<u16> for Integer
impl BitXorAssign<u16> for Integer
sourcefn bitxor_assign(&mut self, rhs: u16)
fn bitxor_assign(&mut self, rhs: u16)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<u32> for Integer
impl BitXorAssign<u32> for Integer
sourcefn bitxor_assign(&mut self, rhs: u32)
fn bitxor_assign(&mut self, rhs: u32)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<u64> for Integer
impl BitXorAssign<u64> for Integer
sourcefn bitxor_assign(&mut self, rhs: u64)
fn bitxor_assign(&mut self, rhs: u64)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<u8> for Integer
impl BitXorAssign<u8> for Integer
sourcefn bitxor_assign(&mut self, rhs: u8)
fn bitxor_assign(&mut self, rhs: u8)
Performs the ^=
operation. Read more
sourceimpl BitXorAssign<usize> for Integer
impl BitXorAssign<usize> for Integer
sourcefn bitxor_assign(&mut self, rhs: usize)
fn bitxor_assign(&mut self, rhs: usize)
Performs the ^=
operation. Read more
sourceimpl BitXorFrom<&Integer> for Integer
impl BitXorFrom<&Integer> for Integer
sourcefn bitxor_from(&mut self, lhs: &Integer)
fn bitxor_from(&mut self, lhs: &Integer)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&i128> for Integer
impl BitXorFrom<&i128> for Integer
sourcefn bitxor_from(&mut self, lhs: &i128)
fn bitxor_from(&mut self, lhs: &i128)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&i16> for Integer
impl BitXorFrom<&i16> for Integer
sourcefn bitxor_from(&mut self, lhs: &i16)
fn bitxor_from(&mut self, lhs: &i16)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&i32> for Integer
impl BitXorFrom<&i32> for Integer
sourcefn bitxor_from(&mut self, lhs: &i32)
fn bitxor_from(&mut self, lhs: &i32)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&i64> for Integer
impl BitXorFrom<&i64> for Integer
sourcefn bitxor_from(&mut self, lhs: &i64)
fn bitxor_from(&mut self, lhs: &i64)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&i8> for Integer
impl BitXorFrom<&i8> for Integer
sourcefn bitxor_from(&mut self, lhs: &i8)
fn bitxor_from(&mut self, lhs: &i8)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&isize> for Integer
impl BitXorFrom<&isize> for Integer
sourcefn bitxor_from(&mut self, lhs: &isize)
fn bitxor_from(&mut self, lhs: &isize)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&u128> for Integer
impl BitXorFrom<&u128> for Integer
sourcefn bitxor_from(&mut self, lhs: &u128)
fn bitxor_from(&mut self, lhs: &u128)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&u16> for Integer
impl BitXorFrom<&u16> for Integer
sourcefn bitxor_from(&mut self, lhs: &u16)
fn bitxor_from(&mut self, lhs: &u16)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&u32> for Integer
impl BitXorFrom<&u32> for Integer
sourcefn bitxor_from(&mut self, lhs: &u32)
fn bitxor_from(&mut self, lhs: &u32)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&u64> for Integer
impl BitXorFrom<&u64> for Integer
sourcefn bitxor_from(&mut self, lhs: &u64)
fn bitxor_from(&mut self, lhs: &u64)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&u8> for Integer
impl BitXorFrom<&u8> for Integer
sourcefn bitxor_from(&mut self, lhs: &u8)
fn bitxor_from(&mut self, lhs: &u8)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<&usize> for Integer
impl BitXorFrom<&usize> for Integer
sourcefn bitxor_from(&mut self, lhs: &usize)
fn bitxor_from(&mut self, lhs: &usize)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<Integer> for Integer
impl BitXorFrom<Integer> for Integer
sourcefn bitxor_from(&mut self, lhs: Integer)
fn bitxor_from(&mut self, lhs: Integer)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<i128> for Integer
impl BitXorFrom<i128> for Integer
sourcefn bitxor_from(&mut self, lhs: i128)
fn bitxor_from(&mut self, lhs: i128)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<i16> for Integer
impl BitXorFrom<i16> for Integer
sourcefn bitxor_from(&mut self, lhs: i16)
fn bitxor_from(&mut self, lhs: i16)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<i32> for Integer
impl BitXorFrom<i32> for Integer
sourcefn bitxor_from(&mut self, lhs: i32)
fn bitxor_from(&mut self, lhs: i32)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<i64> for Integer
impl BitXorFrom<i64> for Integer
sourcefn bitxor_from(&mut self, lhs: i64)
fn bitxor_from(&mut self, lhs: i64)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<i8> for Integer
impl BitXorFrom<i8> for Integer
sourcefn bitxor_from(&mut self, lhs: i8)
fn bitxor_from(&mut self, lhs: i8)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<isize> for Integer
impl BitXorFrom<isize> for Integer
sourcefn bitxor_from(&mut self, lhs: isize)
fn bitxor_from(&mut self, lhs: isize)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<u128> for Integer
impl BitXorFrom<u128> for Integer
sourcefn bitxor_from(&mut self, lhs: u128)
fn bitxor_from(&mut self, lhs: u128)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<u16> for Integer
impl BitXorFrom<u16> for Integer
sourcefn bitxor_from(&mut self, lhs: u16)
fn bitxor_from(&mut self, lhs: u16)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<u32> for Integer
impl BitXorFrom<u32> for Integer
sourcefn bitxor_from(&mut self, lhs: u32)
fn bitxor_from(&mut self, lhs: u32)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<u64> for Integer
impl BitXorFrom<u64> for Integer
sourcefn bitxor_from(&mut self, lhs: u64)
fn bitxor_from(&mut self, lhs: u64)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<u8> for Integer
impl BitXorFrom<u8> for Integer
sourcefn bitxor_from(&mut self, lhs: u8)
fn bitxor_from(&mut self, lhs: u8)
Peforms the XOR operation. Read more
sourceimpl BitXorFrom<usize> for Integer
impl BitXorFrom<usize> for Integer
sourcefn bitxor_from(&mut self, lhs: usize)
fn bitxor_from(&mut self, lhs: usize)
Peforms the XOR operation. Read more
sourceimpl CheckedCast<Integer> for &Float
impl CheckedCast<Integer> for &Float
sourcefn checked_cast(self) -> Option<Integer>
fn checked_cast(self) -> Option<Integer>
Casts the value.
sourceimpl CheckedCast<Integer> for Float
impl CheckedCast<Integer> for Float
sourcefn checked_cast(self) -> Option<Integer>
fn checked_cast(self) -> Option<Integer>
Casts the value.
sourceimpl CheckedCast<Integer> for Round<f32>
impl CheckedCast<Integer> for Round<f32>
sourcefn checked_cast(self) -> Option<Integer>
fn checked_cast(self) -> Option<Integer>
Casts the value.
sourceimpl CheckedCast<Integer> for Round<f64>
impl CheckedCast<Integer> for Round<f64>
sourcefn checked_cast(self) -> Option<Integer>
fn checked_cast(self) -> Option<Integer>
Casts the value.
sourceimpl CheckedCast<Integer> for f32
impl CheckedCast<Integer> for f32
sourcefn checked_cast(self) -> Option<Integer>
fn checked_cast(self) -> Option<Integer>
Casts the value.
sourceimpl CheckedCast<Integer> for f64
impl CheckedCast<Integer> for f64
sourcefn checked_cast(self) -> Option<Integer>
fn checked_cast(self) -> Option<Integer>
Casts the value.
sourceimpl CheckedCast<i128> for &Integer
impl CheckedCast<i128> for &Integer
sourcefn checked_cast(self) -> Option<i128>
fn checked_cast(self) -> Option<i128>
Casts the value.
sourceimpl CheckedCast<i128> for Integer
impl CheckedCast<i128> for Integer
sourcefn checked_cast(self) -> Option<i128>
fn checked_cast(self) -> Option<i128>
Casts the value.
sourceimpl CheckedCast<i16> for &Integer
impl CheckedCast<i16> for &Integer
sourcefn checked_cast(self) -> Option<i16>
fn checked_cast(self) -> Option<i16>
Casts the value.
sourceimpl CheckedCast<i16> for Integer
impl CheckedCast<i16> for Integer
sourcefn checked_cast(self) -> Option<i16>
fn checked_cast(self) -> Option<i16>
Casts the value.
sourceimpl CheckedCast<i32> for &Integer
impl CheckedCast<i32> for &Integer
sourcefn checked_cast(self) -> Option<i32>
fn checked_cast(self) -> Option<i32>
Casts the value.
sourceimpl CheckedCast<i32> for Integer
impl CheckedCast<i32> for Integer
sourcefn checked_cast(self) -> Option<i32>
fn checked_cast(self) -> Option<i32>
Casts the value.
sourceimpl CheckedCast<i64> for &Integer
impl CheckedCast<i64> for &Integer
sourcefn checked_cast(self) -> Option<i64>
fn checked_cast(self) -> Option<i64>
Casts the value.
sourceimpl CheckedCast<i64> for Integer
impl CheckedCast<i64> for Integer
sourcefn checked_cast(self) -> Option<i64>
fn checked_cast(self) -> Option<i64>
Casts the value.
sourceimpl CheckedCast<i8> for &Integer
impl CheckedCast<i8> for &Integer
sourcefn checked_cast(self) -> Option<i8>
fn checked_cast(self) -> Option<i8>
Casts the value.
sourceimpl CheckedCast<i8> for Integer
impl CheckedCast<i8> for Integer
sourcefn checked_cast(self) -> Option<i8>
fn checked_cast(self) -> Option<i8>
Casts the value.
sourceimpl CheckedCast<isize> for &Integer
impl CheckedCast<isize> for &Integer
sourcefn checked_cast(self) -> Option<isize>
fn checked_cast(self) -> Option<isize>
Casts the value.
sourceimpl CheckedCast<isize> for Integer
impl CheckedCast<isize> for Integer
sourcefn checked_cast(self) -> Option<isize>
fn checked_cast(self) -> Option<isize>
Casts the value.
sourceimpl CheckedCast<u128> for &Integer
impl CheckedCast<u128> for &Integer
sourcefn checked_cast(self) -> Option<u128>
fn checked_cast(self) -> Option<u128>
Casts the value.
sourceimpl CheckedCast<u128> for Integer
impl CheckedCast<u128> for Integer
sourcefn checked_cast(self) -> Option<u128>
fn checked_cast(self) -> Option<u128>
Casts the value.
sourceimpl CheckedCast<u16> for &Integer
impl CheckedCast<u16> for &Integer
sourcefn checked_cast(self) -> Option<u16>
fn checked_cast(self) -> Option<u16>
Casts the value.
sourceimpl CheckedCast<u16> for Integer
impl CheckedCast<u16> for Integer
sourcefn checked_cast(self) -> Option<u16>
fn checked_cast(self) -> Option<u16>
Casts the value.
sourceimpl CheckedCast<u32> for &Integer
impl CheckedCast<u32> for &Integer
sourcefn checked_cast(self) -> Option<u32>
fn checked_cast(self) -> Option<u32>
Casts the value.
sourceimpl CheckedCast<u32> for Integer
impl CheckedCast<u32> for Integer
sourcefn checked_cast(self) -> Option<u32>
fn checked_cast(self) -> Option<u32>
Casts the value.
sourceimpl CheckedCast<u64> for &Integer
impl CheckedCast<u64> for &Integer
sourcefn checked_cast(self) -> Option<u64>
fn checked_cast(self) -> Option<u64>
Casts the value.
sourceimpl CheckedCast<u64> for Integer
impl CheckedCast<u64> for Integer
sourcefn checked_cast(self) -> Option<u64>
fn checked_cast(self) -> Option<u64>
Casts the value.
sourceimpl CheckedCast<u8> for &Integer
impl CheckedCast<u8> for &Integer
sourcefn checked_cast(self) -> Option<u8>
fn checked_cast(self) -> Option<u8>
Casts the value.
sourceimpl CheckedCast<u8> for Integer
impl CheckedCast<u8> for Integer
sourcefn checked_cast(self) -> Option<u8>
fn checked_cast(self) -> Option<u8>
Casts the value.
sourceimpl CheckedCast<usize> for &Integer
impl CheckedCast<usize> for &Integer
sourcefn checked_cast(self) -> Option<usize>
fn checked_cast(self) -> Option<usize>
Casts the value.
sourceimpl CheckedCast<usize> for Integer
impl CheckedCast<usize> for Integer
sourcefn checked_cast(self) -> Option<usize>
fn checked_cast(self) -> Option<usize>
Casts the value.
sourceimpl<'de> Deserialize<'de> for Integer
impl<'de> Deserialize<'de> for Integer
sourcefn deserialize<D: Deserializer<'de>>(
deserializer: D
) -> Result<Integer, D::Error>
fn deserialize<D: Deserializer<'de>>(
deserializer: D
) -> Result<Integer, D::Error>
Deserialize this value from the given Serde deserializer. Read more
sourceimpl DivAssign<&Integer> for Complex
impl DivAssign<&Integer> for Complex
sourcefn div_assign(&mut self, rhs: &Integer)
fn div_assign(&mut self, rhs: &Integer)
Performs the /=
operation. Read more
sourceimpl DivAssign<&Integer> for Float
impl DivAssign<&Integer> for Float
sourcefn div_assign(&mut self, rhs: &Integer)
fn div_assign(&mut self, rhs: &Integer)
Performs the /=
operation. Read more
sourceimpl DivAssign<&Integer> for Integer
impl DivAssign<&Integer> for Integer
sourcefn div_assign(&mut self, rhs: &Integer)
fn div_assign(&mut self, rhs: &Integer)
Performs the /=
operation. Read more
sourceimpl DivAssign<&Integer> for Rational
impl DivAssign<&Integer> for Rational
sourcefn div_assign(&mut self, rhs: &Integer)
fn div_assign(&mut self, rhs: &Integer)
Performs the /=
operation. Read more
sourceimpl DivAssign<&i128> for Integer
impl DivAssign<&i128> for Integer
sourcefn div_assign(&mut self, rhs: &i128)
fn div_assign(&mut self, rhs: &i128)
Performs the /=
operation. Read more
sourceimpl DivAssign<&i16> for Integer
impl DivAssign<&i16> for Integer
sourcefn div_assign(&mut self, rhs: &i16)
fn div_assign(&mut self, rhs: &i16)
Performs the /=
operation. Read more
sourceimpl DivAssign<&i32> for Integer
impl DivAssign<&i32> for Integer
sourcefn div_assign(&mut self, rhs: &i32)
fn div_assign(&mut self, rhs: &i32)
Performs the /=
operation. Read more
sourceimpl DivAssign<&i64> for Integer
impl DivAssign<&i64> for Integer
sourcefn div_assign(&mut self, rhs: &i64)
fn div_assign(&mut self, rhs: &i64)
Performs the /=
operation. Read more
sourceimpl DivAssign<&i8> for Integer
impl DivAssign<&i8> for Integer
sourcefn div_assign(&mut self, rhs: &i8)
fn div_assign(&mut self, rhs: &i8)
Performs the /=
operation. Read more
sourceimpl DivAssign<&isize> for Integer
impl DivAssign<&isize> for Integer
sourcefn div_assign(&mut self, rhs: &isize)
fn div_assign(&mut self, rhs: &isize)
Performs the /=
operation. Read more
sourceimpl DivAssign<&u128> for Integer
impl DivAssign<&u128> for Integer
sourcefn div_assign(&mut self, rhs: &u128)
fn div_assign(&mut self, rhs: &u128)
Performs the /=
operation. Read more
sourceimpl DivAssign<&u16> for Integer
impl DivAssign<&u16> for Integer
sourcefn div_assign(&mut self, rhs: &u16)
fn div_assign(&mut self, rhs: &u16)
Performs the /=
operation. Read more
sourceimpl DivAssign<&u32> for Integer
impl DivAssign<&u32> for Integer
sourcefn div_assign(&mut self, rhs: &u32)
fn div_assign(&mut self, rhs: &u32)
Performs the /=
operation. Read more
sourceimpl DivAssign<&u64> for Integer
impl DivAssign<&u64> for Integer
sourcefn div_assign(&mut self, rhs: &u64)
fn div_assign(&mut self, rhs: &u64)
Performs the /=
operation. Read more
sourceimpl DivAssign<&u8> for Integer
impl DivAssign<&u8> for Integer
sourcefn div_assign(&mut self, rhs: &u8)
fn div_assign(&mut self, rhs: &u8)
Performs the /=
operation. Read more
sourceimpl DivAssign<&usize> for Integer
impl DivAssign<&usize> for Integer
sourcefn div_assign(&mut self, rhs: &usize)
fn div_assign(&mut self, rhs: &usize)
Performs the /=
operation. Read more
sourceimpl DivAssign<Integer> for Complex
impl DivAssign<Integer> for Complex
sourcefn div_assign(&mut self, rhs: Integer)
fn div_assign(&mut self, rhs: Integer)
Performs the /=
operation. Read more
sourceimpl DivAssign<Integer> for Float
impl DivAssign<Integer> for Float
sourcefn div_assign(&mut self, rhs: Integer)
fn div_assign(&mut self, rhs: Integer)
Performs the /=
operation. Read more
sourceimpl DivAssign<Integer> for Integer
impl DivAssign<Integer> for Integer
sourcefn div_assign(&mut self, rhs: Integer)
fn div_assign(&mut self, rhs: Integer)
Performs the /=
operation. Read more
sourceimpl DivAssign<Integer> for Rational
impl DivAssign<Integer> for Rational
sourcefn div_assign(&mut self, rhs: Integer)
fn div_assign(&mut self, rhs: Integer)
Performs the /=
operation. Read more
sourceimpl DivAssign<i128> for Integer
impl DivAssign<i128> for Integer
sourcefn div_assign(&mut self, rhs: i128)
fn div_assign(&mut self, rhs: i128)
Performs the /=
operation. Read more
sourceimpl DivAssign<i16> for Integer
impl DivAssign<i16> for Integer
sourcefn div_assign(&mut self, rhs: i16)
fn div_assign(&mut self, rhs: i16)
Performs the /=
operation. Read more
sourceimpl DivAssign<i32> for Integer
impl DivAssign<i32> for Integer
sourcefn div_assign(&mut self, rhs: i32)
fn div_assign(&mut self, rhs: i32)
Performs the /=
operation. Read more
sourceimpl DivAssign<i64> for Integer
impl DivAssign<i64> for Integer
sourcefn div_assign(&mut self, rhs: i64)
fn div_assign(&mut self, rhs: i64)
Performs the /=
operation. Read more
sourceimpl DivAssign<i8> for Integer
impl DivAssign<i8> for Integer
sourcefn div_assign(&mut self, rhs: i8)
fn div_assign(&mut self, rhs: i8)
Performs the /=
operation. Read more
sourceimpl DivAssign<isize> for Integer
impl DivAssign<isize> for Integer
sourcefn div_assign(&mut self, rhs: isize)
fn div_assign(&mut self, rhs: isize)
Performs the /=
operation. Read more
sourceimpl DivAssign<u128> for Integer
impl DivAssign<u128> for Integer
sourcefn div_assign(&mut self, rhs: u128)
fn div_assign(&mut self, rhs: u128)
Performs the /=
operation. Read more
sourceimpl DivAssign<u16> for Integer
impl DivAssign<u16> for Integer
sourcefn div_assign(&mut self, rhs: u16)
fn div_assign(&mut self, rhs: u16)
Performs the /=
operation. Read more
sourceimpl DivAssign<u32> for Integer
impl DivAssign<u32> for Integer
sourcefn div_assign(&mut self, rhs: u32)
fn div_assign(&mut self, rhs: u32)
Performs the /=
operation. Read more
sourceimpl DivAssign<u64> for Integer
impl DivAssign<u64> for Integer
sourcefn div_assign(&mut self, rhs: u64)
fn div_assign(&mut self, rhs: u64)
Performs the /=
operation. Read more
sourceimpl DivAssign<u8> for Integer
impl DivAssign<u8> for Integer
sourcefn div_assign(&mut self, rhs: u8)
fn div_assign(&mut self, rhs: u8)
Performs the /=
operation. Read more
sourceimpl DivAssign<usize> for Integer
impl DivAssign<usize> for Integer
sourcefn div_assign(&mut self, rhs: usize)
fn div_assign(&mut self, rhs: usize)
Performs the /=
operation. Read more
sourceimpl DivAssignRound<&Integer> for Complex
impl DivAssignRound<&Integer> for Complex
sourceimpl DivAssignRound<&Integer> for Float
impl DivAssignRound<&Integer> for Float
sourceimpl DivAssignRound<Integer> for Complex
impl DivAssignRound<Integer> for Complex
sourceimpl DivAssignRound<Integer> for Float
impl DivAssignRound<Integer> for Float
sourceimpl DivFromRound<&Integer> for Float
impl DivFromRound<&Integer> for Float
sourceimpl DivFromRound<Integer> for Float
impl DivFromRound<Integer> for Float
sourceimpl<'i> DivRounding<&'i Integer> for &'i Integer
impl<'i> DivRounding<&'i Integer> for &'i Integer
type Output = DivRoundingIncomplete<'i>
type Output = DivRoundingIncomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &'i Integer) -> DivRoundingIncomplete<'_>
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingIncomplete<'_>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &'i Integer) -> DivRoundingIncomplete<'_>
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingIncomplete<'_>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for &i128
impl<'i> DivRounding<&'i Integer> for &i128
type Output = DivRoundingFromI128Incomplete<'i>
type Output = DivRoundingFromI128Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI128Incomplete<'i>
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI128Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI128Incomplete<'i>
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI128Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for &i16
impl<'i> DivRounding<&'i Integer> for &i16
type Output = DivRoundingFromI16Incomplete<'i>
type Output = DivRoundingFromI16Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI16Incomplete<'i>
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI16Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI16Incomplete<'i>
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI16Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for &i32
impl<'i> DivRounding<&'i Integer> for &i32
type Output = DivRoundingFromI32Incomplete<'i>
type Output = DivRoundingFromI32Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i>
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i>
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI32Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for &i64
impl<'i> DivRounding<&'i Integer> for &i64
type Output = DivRoundingFromI64Incomplete<'i>
type Output = DivRoundingFromI64Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI64Incomplete<'i>
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI64Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI64Incomplete<'i>
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI64Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for &i8
impl<'i> DivRounding<&'i Integer> for &i8
type Output = DivRoundingFromI8Incomplete<'i>
type Output = DivRoundingFromI8Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI8Incomplete<'i>
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromI8Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI8Incomplete<'i>
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromI8Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for &u128
impl<'i> DivRounding<&'i Integer> for &u128
type Output = DivRoundingFromU128Incomplete<'i>
type Output = DivRoundingFromU128Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU128Incomplete<'i>
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU128Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU128Incomplete<'i>
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU128Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for &u16
impl<'i> DivRounding<&'i Integer> for &u16
type Output = DivRoundingFromU16Incomplete<'i>
type Output = DivRoundingFromU16Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU16Incomplete<'i>
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU16Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU16Incomplete<'i>
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU16Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for &u32
impl<'i> DivRounding<&'i Integer> for &u32
type Output = DivRoundingFromU32Incomplete<'i>
type Output = DivRoundingFromU32Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i>
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i>
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU32Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for &u64
impl<'i> DivRounding<&'i Integer> for &u64
type Output = DivRoundingFromU64Incomplete<'i>
type Output = DivRoundingFromU64Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU64Incomplete<'i>
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU64Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU64Incomplete<'i>
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU64Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for &u8
impl<'i> DivRounding<&'i Integer> for &u8
type Output = DivRoundingFromU8Incomplete<'i>
type Output = DivRoundingFromU8Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU8Incomplete<'i>
fn div_trunc(self, rhs: &'i Integer) -> DivRoundingFromU8Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU8Incomplete<'i>
fn div_ceil(self, rhs: &'i Integer) -> DivRoundingFromU8Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for i128
impl<'i> DivRounding<&'i Integer> for i128
type Output = DivRoundingFromI128Incomplete<'i>
type Output = DivRoundingFromI128Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &Integer) -> DivRoundingFromI128Incomplete<'_>
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromI128Incomplete<'_>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &Integer) -> DivRoundingFromI128Incomplete<'_>
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromI128Incomplete<'_>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for i16
impl<'i> DivRounding<&'i Integer> for i16
type Output = DivRoundingFromI16Incomplete<'i>
type Output = DivRoundingFromI16Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &Integer) -> DivRoundingFromI16Incomplete<'_>
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromI16Incomplete<'_>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &Integer) -> DivRoundingFromI16Incomplete<'_>
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromI16Incomplete<'_>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for i32
impl<'i> DivRounding<&'i Integer> for i32
type Output = DivRoundingFromI32Incomplete<'i>
type Output = DivRoundingFromI32Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &Integer) -> DivRoundingFromI32Incomplete<'_>
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromI32Incomplete<'_>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &Integer) -> DivRoundingFromI32Incomplete<'_>
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromI32Incomplete<'_>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for i64
impl<'i> DivRounding<&'i Integer> for i64
type Output = DivRoundingFromI64Incomplete<'i>
type Output = DivRoundingFromI64Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &Integer) -> DivRoundingFromI64Incomplete<'_>
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromI64Incomplete<'_>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &Integer) -> DivRoundingFromI64Incomplete<'_>
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromI64Incomplete<'_>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for i8
impl<'i> DivRounding<&'i Integer> for i8
type Output = DivRoundingFromI8Incomplete<'i>
type Output = DivRoundingFromI8Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &Integer) -> DivRoundingFromI8Incomplete<'_>
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromI8Incomplete<'_>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &Integer) -> DivRoundingFromI8Incomplete<'_>
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromI8Incomplete<'_>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for u128
impl<'i> DivRounding<&'i Integer> for u128
type Output = DivRoundingFromU128Incomplete<'i>
type Output = DivRoundingFromU128Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &Integer) -> DivRoundingFromU128Incomplete<'_>
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromU128Incomplete<'_>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &Integer) -> DivRoundingFromU128Incomplete<'_>
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromU128Incomplete<'_>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for u16
impl<'i> DivRounding<&'i Integer> for u16
type Output = DivRoundingFromU16Incomplete<'i>
type Output = DivRoundingFromU16Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &Integer) -> DivRoundingFromU16Incomplete<'_>
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromU16Incomplete<'_>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &Integer) -> DivRoundingFromU16Incomplete<'_>
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromU16Incomplete<'_>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for u32
impl<'i> DivRounding<&'i Integer> for u32
type Output = DivRoundingFromU32Incomplete<'i>
type Output = DivRoundingFromU32Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &Integer) -> DivRoundingFromU32Incomplete<'_>
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromU32Incomplete<'_>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &Integer) -> DivRoundingFromU32Incomplete<'_>
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromU32Incomplete<'_>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for u64
impl<'i> DivRounding<&'i Integer> for u64
type Output = DivRoundingFromU64Incomplete<'i>
type Output = DivRoundingFromU64Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &Integer) -> DivRoundingFromU64Incomplete<'_>
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromU64Incomplete<'_>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &Integer) -> DivRoundingFromU64Incomplete<'_>
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromU64Incomplete<'_>
Performs division, rounding the quotient up.
sourceimpl<'i> DivRounding<&'i Integer> for u8
impl<'i> DivRounding<&'i Integer> for u8
type Output = DivRoundingFromU8Incomplete<'i>
type Output = DivRoundingFromU8Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &Integer) -> DivRoundingFromU8Incomplete<'_>
fn div_trunc(self, rhs: &Integer) -> DivRoundingFromU8Incomplete<'_>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &Integer) -> DivRoundingFromU8Incomplete<'_>
fn div_ceil(self, rhs: &Integer) -> DivRoundingFromU8Incomplete<'_>
Performs division, rounding the quotient up.
sourceimpl<'t, 'i> DivRounding<&'t i128> for &'i Integer
impl<'t, 'i> DivRounding<&'t i128> for &'i Integer
type Output = DivRoundingI128Incomplete<'i>
type Output = DivRoundingI128Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &i128) -> DivRoundingI128Incomplete<'i>
fn div_trunc(self, rhs: &i128) -> DivRoundingI128Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &i128) -> DivRoundingI128Incomplete<'i>
fn div_ceil(self, rhs: &i128) -> DivRoundingI128Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'t, 'i> DivRounding<&'t i16> for &'i Integer
impl<'t, 'i> DivRounding<&'t i16> for &'i Integer
type Output = DivRoundingI16Incomplete<'i>
type Output = DivRoundingI16Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &i16) -> DivRoundingI16Incomplete<'i>
fn div_trunc(self, rhs: &i16) -> DivRoundingI16Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &i16) -> DivRoundingI16Incomplete<'i>
fn div_ceil(self, rhs: &i16) -> DivRoundingI16Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'t, 'i> DivRounding<&'t i32> for &'i Integer
impl<'t, 'i> DivRounding<&'t i32> for &'i Integer
type Output = DivRoundingI32Incomplete<'i>
type Output = DivRoundingI32Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &i32) -> DivRoundingI32Incomplete<'i>
fn div_trunc(self, rhs: &i32) -> DivRoundingI32Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &i32) -> DivRoundingI32Incomplete<'i>
fn div_ceil(self, rhs: &i32) -> DivRoundingI32Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'t, 'i> DivRounding<&'t i64> for &'i Integer
impl<'t, 'i> DivRounding<&'t i64> for &'i Integer
type Output = DivRoundingI64Incomplete<'i>
type Output = DivRoundingI64Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &i64) -> DivRoundingI64Incomplete<'i>
fn div_trunc(self, rhs: &i64) -> DivRoundingI64Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &i64) -> DivRoundingI64Incomplete<'i>
fn div_ceil(self, rhs: &i64) -> DivRoundingI64Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'t, 'i> DivRounding<&'t i8> for &'i Integer
impl<'t, 'i> DivRounding<&'t i8> for &'i Integer
type Output = DivRoundingI8Incomplete<'i>
type Output = DivRoundingI8Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &i8) -> DivRoundingI8Incomplete<'i>
fn div_trunc(self, rhs: &i8) -> DivRoundingI8Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &i8) -> DivRoundingI8Incomplete<'i>
fn div_ceil(self, rhs: &i8) -> DivRoundingI8Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'t, 'i> DivRounding<&'t u128> for &'i Integer
impl<'t, 'i> DivRounding<&'t u128> for &'i Integer
type Output = DivRoundingU128Incomplete<'i>
type Output = DivRoundingU128Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &u128) -> DivRoundingU128Incomplete<'i>
fn div_trunc(self, rhs: &u128) -> DivRoundingU128Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &u128) -> DivRoundingU128Incomplete<'i>
fn div_ceil(self, rhs: &u128) -> DivRoundingU128Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'t, 'i> DivRounding<&'t u16> for &'i Integer
impl<'t, 'i> DivRounding<&'t u16> for &'i Integer
type Output = DivRoundingU16Incomplete<'i>
type Output = DivRoundingU16Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &u16) -> DivRoundingU16Incomplete<'i>
fn div_trunc(self, rhs: &u16) -> DivRoundingU16Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &u16) -> DivRoundingU16Incomplete<'i>
fn div_ceil(self, rhs: &u16) -> DivRoundingU16Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'t, 'i> DivRounding<&'t u32> for &'i Integer
impl<'t, 'i> DivRounding<&'t u32> for &'i Integer
type Output = DivRoundingU32Incomplete<'i>
type Output = DivRoundingU32Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &u32) -> DivRoundingU32Incomplete<'i>
fn div_trunc(self, rhs: &u32) -> DivRoundingU32Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &u32) -> DivRoundingU32Incomplete<'i>
fn div_ceil(self, rhs: &u32) -> DivRoundingU32Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'t, 'i> DivRounding<&'t u64> for &'i Integer
impl<'t, 'i> DivRounding<&'t u64> for &'i Integer
type Output = DivRoundingU64Incomplete<'i>
type Output = DivRoundingU64Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &u64) -> DivRoundingU64Incomplete<'i>
fn div_trunc(self, rhs: &u64) -> DivRoundingU64Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &u64) -> DivRoundingU64Incomplete<'i>
fn div_ceil(self, rhs: &u64) -> DivRoundingU64Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl<'t, 'i> DivRounding<&'t u8> for &'i Integer
impl<'t, 'i> DivRounding<&'t u8> for &'i Integer
type Output = DivRoundingU8Incomplete<'i>
type Output = DivRoundingU8Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: &u8) -> DivRoundingU8Incomplete<'i>
fn div_trunc(self, rhs: &u8) -> DivRoundingU8Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: &u8) -> DivRoundingU8Incomplete<'i>
fn div_ceil(self, rhs: &u8) -> DivRoundingU8Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl DivRounding<&Integer> for Integer
impl DivRounding<&Integer> for Integer
sourceimpl DivRounding<&i128> for Integer
impl DivRounding<&i128> for Integer
sourceimpl DivRounding<&i16> for Integer
impl DivRounding<&i16> for Integer
sourceimpl DivRounding<&i32> for Integer
impl DivRounding<&i32> for Integer
sourceimpl DivRounding<&i64> for Integer
impl DivRounding<&i64> for Integer
sourceimpl DivRounding<&i8> for Integer
impl DivRounding<&i8> for Integer
sourceimpl DivRounding<&u128> for Integer
impl DivRounding<&u128> for Integer
sourceimpl DivRounding<&u16> for Integer
impl DivRounding<&u16> for Integer
sourceimpl DivRounding<&u32> for Integer
impl DivRounding<&u32> for Integer
sourceimpl DivRounding<&u64> for Integer
impl DivRounding<&u64> for Integer
sourceimpl DivRounding<&u8> for Integer
impl DivRounding<&u8> for Integer
sourceimpl DivRounding<Integer> for &Integer
impl DivRounding<Integer> for &Integer
sourceimpl DivRounding<Integer> for &i128
impl DivRounding<Integer> for &i128
sourceimpl DivRounding<Integer> for &i16
impl DivRounding<Integer> for &i16
sourceimpl DivRounding<Integer> for &i32
impl DivRounding<Integer> for &i32
sourceimpl DivRounding<Integer> for &i64
impl DivRounding<Integer> for &i64
sourceimpl DivRounding<Integer> for &i8
impl DivRounding<Integer> for &i8
sourceimpl DivRounding<Integer> for &u128
impl DivRounding<Integer> for &u128
sourceimpl DivRounding<Integer> for &u16
impl DivRounding<Integer> for &u16
sourceimpl DivRounding<Integer> for &u32
impl DivRounding<Integer> for &u32
sourceimpl DivRounding<Integer> for &u64
impl DivRounding<Integer> for &u64
sourceimpl DivRounding<Integer> for &u8
impl DivRounding<Integer> for &u8
sourceimpl DivRounding<Integer> for Integer
impl DivRounding<Integer> for Integer
sourceimpl DivRounding<Integer> for i128
impl DivRounding<Integer> for i128
sourceimpl DivRounding<Integer> for i16
impl DivRounding<Integer> for i16
sourceimpl DivRounding<Integer> for i32
impl DivRounding<Integer> for i32
sourceimpl DivRounding<Integer> for i64
impl DivRounding<Integer> for i64
sourceimpl DivRounding<Integer> for i8
impl DivRounding<Integer> for i8
sourceimpl DivRounding<Integer> for u128
impl DivRounding<Integer> for u128
sourceimpl DivRounding<Integer> for u16
impl DivRounding<Integer> for u16
sourceimpl DivRounding<Integer> for u32
impl DivRounding<Integer> for u32
sourceimpl DivRounding<Integer> for u64
impl DivRounding<Integer> for u64
sourceimpl DivRounding<Integer> for u8
impl DivRounding<Integer> for u8
sourceimpl<'i> DivRounding<i128> for &'i Integer
impl<'i> DivRounding<i128> for &'i Integer
type Output = DivRoundingI128Incomplete<'i>
type Output = DivRoundingI128Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: i128) -> DivRoundingI128Incomplete<'i>
fn div_trunc(self, rhs: i128) -> DivRoundingI128Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: i128) -> DivRoundingI128Incomplete<'i>
fn div_ceil(self, rhs: i128) -> DivRoundingI128Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl DivRounding<i128> for Integer
impl DivRounding<i128> for Integer
sourceimpl<'i> DivRounding<i16> for &'i Integer
impl<'i> DivRounding<i16> for &'i Integer
type Output = DivRoundingI16Incomplete<'i>
type Output = DivRoundingI16Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: i16) -> DivRoundingI16Incomplete<'i>
fn div_trunc(self, rhs: i16) -> DivRoundingI16Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: i16) -> DivRoundingI16Incomplete<'i>
fn div_ceil(self, rhs: i16) -> DivRoundingI16Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl DivRounding<i16> for Integer
impl DivRounding<i16> for Integer
sourceimpl<'i> DivRounding<i32> for &'i Integer
impl<'i> DivRounding<i32> for &'i Integer
type Output = DivRoundingI32Incomplete<'i>
type Output = DivRoundingI32Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: i32) -> DivRoundingI32Incomplete<'i>
fn div_trunc(self, rhs: i32) -> DivRoundingI32Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: i32) -> DivRoundingI32Incomplete<'i>
fn div_ceil(self, rhs: i32) -> DivRoundingI32Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl DivRounding<i32> for Integer
impl DivRounding<i32> for Integer
sourceimpl<'i> DivRounding<i64> for &'i Integer
impl<'i> DivRounding<i64> for &'i Integer
type Output = DivRoundingI64Incomplete<'i>
type Output = DivRoundingI64Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: i64) -> DivRoundingI64Incomplete<'i>
fn div_trunc(self, rhs: i64) -> DivRoundingI64Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: i64) -> DivRoundingI64Incomplete<'i>
fn div_ceil(self, rhs: i64) -> DivRoundingI64Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl DivRounding<i64> for Integer
impl DivRounding<i64> for Integer
sourceimpl<'i> DivRounding<i8> for &'i Integer
impl<'i> DivRounding<i8> for &'i Integer
type Output = DivRoundingI8Incomplete<'i>
type Output = DivRoundingI8Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: i8) -> DivRoundingI8Incomplete<'i>
fn div_trunc(self, rhs: i8) -> DivRoundingI8Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: i8) -> DivRoundingI8Incomplete<'i>
fn div_ceil(self, rhs: i8) -> DivRoundingI8Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl DivRounding<i8> for Integer
impl DivRounding<i8> for Integer
sourceimpl<'i> DivRounding<u128> for &'i Integer
impl<'i> DivRounding<u128> for &'i Integer
type Output = DivRoundingU128Incomplete<'i>
type Output = DivRoundingU128Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: u128) -> DivRoundingU128Incomplete<'i>
fn div_trunc(self, rhs: u128) -> DivRoundingU128Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: u128) -> DivRoundingU128Incomplete<'i>
fn div_ceil(self, rhs: u128) -> DivRoundingU128Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl DivRounding<u128> for Integer
impl DivRounding<u128> for Integer
sourceimpl<'i> DivRounding<u16> for &'i Integer
impl<'i> DivRounding<u16> for &'i Integer
type Output = DivRoundingU16Incomplete<'i>
type Output = DivRoundingU16Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: u16) -> DivRoundingU16Incomplete<'i>
fn div_trunc(self, rhs: u16) -> DivRoundingU16Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: u16) -> DivRoundingU16Incomplete<'i>
fn div_ceil(self, rhs: u16) -> DivRoundingU16Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl DivRounding<u16> for Integer
impl DivRounding<u16> for Integer
sourceimpl<'i> DivRounding<u32> for &'i Integer
impl<'i> DivRounding<u32> for &'i Integer
type Output = DivRoundingU32Incomplete<'i>
type Output = DivRoundingU32Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: u32) -> DivRoundingU32Incomplete<'i>
fn div_trunc(self, rhs: u32) -> DivRoundingU32Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: u32) -> DivRoundingU32Incomplete<'i>
fn div_ceil(self, rhs: u32) -> DivRoundingU32Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl DivRounding<u32> for Integer
impl DivRounding<u32> for Integer
sourceimpl<'i> DivRounding<u64> for &'i Integer
impl<'i> DivRounding<u64> for &'i Integer
type Output = DivRoundingU64Incomplete<'i>
type Output = DivRoundingU64Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: u64) -> DivRoundingU64Incomplete<'i>
fn div_trunc(self, rhs: u64) -> DivRoundingU64Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: u64) -> DivRoundingU64Incomplete<'i>
fn div_ceil(self, rhs: u64) -> DivRoundingU64Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl DivRounding<u64> for Integer
impl DivRounding<u64> for Integer
sourceimpl<'i> DivRounding<u8> for &'i Integer
impl<'i> DivRounding<u8> for &'i Integer
type Output = DivRoundingU8Incomplete<'i>
type Output = DivRoundingU8Incomplete<'i>
The resulting type from the division operation.
sourcefn div_trunc(self, rhs: u8) -> DivRoundingU8Incomplete<'i>
fn div_trunc(self, rhs: u8) -> DivRoundingU8Incomplete<'i>
Performs division, rounding the quotient towards zero.
sourcefn div_ceil(self, rhs: u8) -> DivRoundingU8Incomplete<'i>
fn div_ceil(self, rhs: u8) -> DivRoundingU8Incomplete<'i>
Performs division, rounding the quotient up.
sourceimpl DivRounding<u8> for Integer
impl DivRounding<u8> for Integer
sourceimpl DivRoundingAssign<&Integer> for Integer
impl DivRoundingAssign<&Integer> for Integer
sourcefn div_trunc_assign(&mut self, rhs: &Integer)
fn div_trunc_assign(&mut self, rhs: &Integer)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: &Integer)
fn div_ceil_assign(&mut self, rhs: &Integer)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: &Integer)
fn div_floor_assign(&mut self, rhs: &Integer)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: &Integer)
fn div_euc_assign(&mut self, rhs: &Integer)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<&i128> for Integer
impl DivRoundingAssign<&i128> for Integer
sourcefn div_trunc_assign(&mut self, rhs: &i128)
fn div_trunc_assign(&mut self, rhs: &i128)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: &i128)
fn div_ceil_assign(&mut self, rhs: &i128)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: &i128)
fn div_floor_assign(&mut self, rhs: &i128)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: &i128)
fn div_euc_assign(&mut self, rhs: &i128)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<&i16> for Integer
impl DivRoundingAssign<&i16> for Integer
sourcefn div_trunc_assign(&mut self, rhs: &i16)
fn div_trunc_assign(&mut self, rhs: &i16)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: &i16)
fn div_ceil_assign(&mut self, rhs: &i16)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: &i16)
fn div_floor_assign(&mut self, rhs: &i16)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: &i16)
fn div_euc_assign(&mut self, rhs: &i16)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<&i32> for Integer
impl DivRoundingAssign<&i32> for Integer
sourcefn div_trunc_assign(&mut self, rhs: &i32)
fn div_trunc_assign(&mut self, rhs: &i32)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: &i32)
fn div_ceil_assign(&mut self, rhs: &i32)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: &i32)
fn div_floor_assign(&mut self, rhs: &i32)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: &i32)
fn div_euc_assign(&mut self, rhs: &i32)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<&i64> for Integer
impl DivRoundingAssign<&i64> for Integer
sourcefn div_trunc_assign(&mut self, rhs: &i64)
fn div_trunc_assign(&mut self, rhs: &i64)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: &i64)
fn div_ceil_assign(&mut self, rhs: &i64)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: &i64)
fn div_floor_assign(&mut self, rhs: &i64)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: &i64)
fn div_euc_assign(&mut self, rhs: &i64)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<&i8> for Integer
impl DivRoundingAssign<&i8> for Integer
sourcefn div_trunc_assign(&mut self, rhs: &i8)
fn div_trunc_assign(&mut self, rhs: &i8)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: &i8)
fn div_ceil_assign(&mut self, rhs: &i8)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: &i8)
fn div_floor_assign(&mut self, rhs: &i8)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: &i8)
fn div_euc_assign(&mut self, rhs: &i8)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<&u128> for Integer
impl DivRoundingAssign<&u128> for Integer
sourcefn div_trunc_assign(&mut self, rhs: &u128)
fn div_trunc_assign(&mut self, rhs: &u128)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: &u128)
fn div_ceil_assign(&mut self, rhs: &u128)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: &u128)
fn div_floor_assign(&mut self, rhs: &u128)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: &u128)
fn div_euc_assign(&mut self, rhs: &u128)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<&u16> for Integer
impl DivRoundingAssign<&u16> for Integer
sourcefn div_trunc_assign(&mut self, rhs: &u16)
fn div_trunc_assign(&mut self, rhs: &u16)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: &u16)
fn div_ceil_assign(&mut self, rhs: &u16)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: &u16)
fn div_floor_assign(&mut self, rhs: &u16)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: &u16)
fn div_euc_assign(&mut self, rhs: &u16)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<&u32> for Integer
impl DivRoundingAssign<&u32> for Integer
sourcefn div_trunc_assign(&mut self, rhs: &u32)
fn div_trunc_assign(&mut self, rhs: &u32)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: &u32)
fn div_ceil_assign(&mut self, rhs: &u32)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: &u32)
fn div_floor_assign(&mut self, rhs: &u32)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: &u32)
fn div_euc_assign(&mut self, rhs: &u32)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<&u64> for Integer
impl DivRoundingAssign<&u64> for Integer
sourcefn div_trunc_assign(&mut self, rhs: &u64)
fn div_trunc_assign(&mut self, rhs: &u64)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: &u64)
fn div_ceil_assign(&mut self, rhs: &u64)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: &u64)
fn div_floor_assign(&mut self, rhs: &u64)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: &u64)
fn div_euc_assign(&mut self, rhs: &u64)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<&u8> for Integer
impl DivRoundingAssign<&u8> for Integer
sourcefn div_trunc_assign(&mut self, rhs: &u8)
fn div_trunc_assign(&mut self, rhs: &u8)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: &u8)
fn div_ceil_assign(&mut self, rhs: &u8)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: &u8)
fn div_floor_assign(&mut self, rhs: &u8)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: &u8)
fn div_euc_assign(&mut self, rhs: &u8)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<Integer> for Integer
impl DivRoundingAssign<Integer> for Integer
sourcefn div_trunc_assign(&mut self, rhs: Integer)
fn div_trunc_assign(&mut self, rhs: Integer)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: Integer)
fn div_ceil_assign(&mut self, rhs: Integer)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: Integer)
fn div_floor_assign(&mut self, rhs: Integer)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: Integer)
fn div_euc_assign(&mut self, rhs: Integer)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<i128> for Integer
impl DivRoundingAssign<i128> for Integer
sourcefn div_trunc_assign(&mut self, rhs: i128)
fn div_trunc_assign(&mut self, rhs: i128)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: i128)
fn div_ceil_assign(&mut self, rhs: i128)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: i128)
fn div_floor_assign(&mut self, rhs: i128)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: i128)
fn div_euc_assign(&mut self, rhs: i128)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<i16> for Integer
impl DivRoundingAssign<i16> for Integer
sourcefn div_trunc_assign(&mut self, rhs: i16)
fn div_trunc_assign(&mut self, rhs: i16)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: i16)
fn div_ceil_assign(&mut self, rhs: i16)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: i16)
fn div_floor_assign(&mut self, rhs: i16)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: i16)
fn div_euc_assign(&mut self, rhs: i16)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<i32> for Integer
impl DivRoundingAssign<i32> for Integer
sourcefn div_trunc_assign(&mut self, rhs: i32)
fn div_trunc_assign(&mut self, rhs: i32)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: i32)
fn div_ceil_assign(&mut self, rhs: i32)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: i32)
fn div_floor_assign(&mut self, rhs: i32)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: i32)
fn div_euc_assign(&mut self, rhs: i32)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<i64> for Integer
impl DivRoundingAssign<i64> for Integer
sourcefn div_trunc_assign(&mut self, rhs: i64)
fn div_trunc_assign(&mut self, rhs: i64)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: i64)
fn div_ceil_assign(&mut self, rhs: i64)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: i64)
fn div_floor_assign(&mut self, rhs: i64)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: i64)
fn div_euc_assign(&mut self, rhs: i64)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<i8> for Integer
impl DivRoundingAssign<i8> for Integer
sourcefn div_trunc_assign(&mut self, rhs: i8)
fn div_trunc_assign(&mut self, rhs: i8)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: i8)
fn div_ceil_assign(&mut self, rhs: i8)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: i8)
fn div_floor_assign(&mut self, rhs: i8)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: i8)
fn div_euc_assign(&mut self, rhs: i8)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<u128> for Integer
impl DivRoundingAssign<u128> for Integer
sourcefn div_trunc_assign(&mut self, rhs: u128)
fn div_trunc_assign(&mut self, rhs: u128)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: u128)
fn div_ceil_assign(&mut self, rhs: u128)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: u128)
fn div_floor_assign(&mut self, rhs: u128)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: u128)
fn div_euc_assign(&mut self, rhs: u128)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<u16> for Integer
impl DivRoundingAssign<u16> for Integer
sourcefn div_trunc_assign(&mut self, rhs: u16)
fn div_trunc_assign(&mut self, rhs: u16)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: u16)
fn div_ceil_assign(&mut self, rhs: u16)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: u16)
fn div_floor_assign(&mut self, rhs: u16)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: u16)
fn div_euc_assign(&mut self, rhs: u16)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<u32> for Integer
impl DivRoundingAssign<u32> for Integer
sourcefn div_trunc_assign(&mut self, rhs: u32)
fn div_trunc_assign(&mut self, rhs: u32)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: u32)
fn div_ceil_assign(&mut self, rhs: u32)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: u32)
fn div_floor_assign(&mut self, rhs: u32)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: u32)
fn div_euc_assign(&mut self, rhs: u32)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<u64> for Integer
impl DivRoundingAssign<u64> for Integer
sourcefn div_trunc_assign(&mut self, rhs: u64)
fn div_trunc_assign(&mut self, rhs: u64)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: u64)
fn div_ceil_assign(&mut self, rhs: u64)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: u64)
fn div_floor_assign(&mut self, rhs: u64)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: u64)
fn div_euc_assign(&mut self, rhs: u64)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingAssign<u8> for Integer
impl DivRoundingAssign<u8> for Integer
sourcefn div_trunc_assign(&mut self, rhs: u8)
fn div_trunc_assign(&mut self, rhs: u8)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_assign(&mut self, rhs: u8)
fn div_ceil_assign(&mut self, rhs: u8)
Performs division, rounding the quotient up.
sourcefn div_floor_assign(&mut self, rhs: u8)
fn div_floor_assign(&mut self, rhs: u8)
Performs division, rounding the quotient down.
sourcefn div_euc_assign(&mut self, rhs: u8)
fn div_euc_assign(&mut self, rhs: u8)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<&Integer> for Integer
impl DivRoundingFrom<&Integer> for Integer
sourcefn div_trunc_from(&mut self, lhs: &Integer)
fn div_trunc_from(&mut self, lhs: &Integer)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: &Integer)
fn div_ceil_from(&mut self, lhs: &Integer)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: &Integer)
fn div_floor_from(&mut self, lhs: &Integer)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: &Integer)
fn div_euc_from(&mut self, lhs: &Integer)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<&i128> for Integer
impl DivRoundingFrom<&i128> for Integer
sourcefn div_trunc_from(&mut self, lhs: &i128)
fn div_trunc_from(&mut self, lhs: &i128)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: &i128)
fn div_ceil_from(&mut self, lhs: &i128)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: &i128)
fn div_floor_from(&mut self, lhs: &i128)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: &i128)
fn div_euc_from(&mut self, lhs: &i128)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<&i16> for Integer
impl DivRoundingFrom<&i16> for Integer
sourcefn div_trunc_from(&mut self, lhs: &i16)
fn div_trunc_from(&mut self, lhs: &i16)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: &i16)
fn div_ceil_from(&mut self, lhs: &i16)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: &i16)
fn div_floor_from(&mut self, lhs: &i16)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: &i16)
fn div_euc_from(&mut self, lhs: &i16)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<&i32> for Integer
impl DivRoundingFrom<&i32> for Integer
sourcefn div_trunc_from(&mut self, lhs: &i32)
fn div_trunc_from(&mut self, lhs: &i32)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: &i32)
fn div_ceil_from(&mut self, lhs: &i32)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: &i32)
fn div_floor_from(&mut self, lhs: &i32)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: &i32)
fn div_euc_from(&mut self, lhs: &i32)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<&i64> for Integer
impl DivRoundingFrom<&i64> for Integer
sourcefn div_trunc_from(&mut self, lhs: &i64)
fn div_trunc_from(&mut self, lhs: &i64)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: &i64)
fn div_ceil_from(&mut self, lhs: &i64)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: &i64)
fn div_floor_from(&mut self, lhs: &i64)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: &i64)
fn div_euc_from(&mut self, lhs: &i64)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<&i8> for Integer
impl DivRoundingFrom<&i8> for Integer
sourcefn div_trunc_from(&mut self, lhs: &i8)
fn div_trunc_from(&mut self, lhs: &i8)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: &i8)
fn div_ceil_from(&mut self, lhs: &i8)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: &i8)
fn div_floor_from(&mut self, lhs: &i8)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: &i8)
fn div_euc_from(&mut self, lhs: &i8)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<&u128> for Integer
impl DivRoundingFrom<&u128> for Integer
sourcefn div_trunc_from(&mut self, lhs: &u128)
fn div_trunc_from(&mut self, lhs: &u128)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: &u128)
fn div_ceil_from(&mut self, lhs: &u128)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: &u128)
fn div_floor_from(&mut self, lhs: &u128)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: &u128)
fn div_euc_from(&mut self, lhs: &u128)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<&u16> for Integer
impl DivRoundingFrom<&u16> for Integer
sourcefn div_trunc_from(&mut self, lhs: &u16)
fn div_trunc_from(&mut self, lhs: &u16)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: &u16)
fn div_ceil_from(&mut self, lhs: &u16)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: &u16)
fn div_floor_from(&mut self, lhs: &u16)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: &u16)
fn div_euc_from(&mut self, lhs: &u16)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<&u32> for Integer
impl DivRoundingFrom<&u32> for Integer
sourcefn div_trunc_from(&mut self, lhs: &u32)
fn div_trunc_from(&mut self, lhs: &u32)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: &u32)
fn div_ceil_from(&mut self, lhs: &u32)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: &u32)
fn div_floor_from(&mut self, lhs: &u32)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: &u32)
fn div_euc_from(&mut self, lhs: &u32)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<&u64> for Integer
impl DivRoundingFrom<&u64> for Integer
sourcefn div_trunc_from(&mut self, lhs: &u64)
fn div_trunc_from(&mut self, lhs: &u64)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: &u64)
fn div_ceil_from(&mut self, lhs: &u64)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: &u64)
fn div_floor_from(&mut self, lhs: &u64)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: &u64)
fn div_euc_from(&mut self, lhs: &u64)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<&u8> for Integer
impl DivRoundingFrom<&u8> for Integer
sourcefn div_trunc_from(&mut self, lhs: &u8)
fn div_trunc_from(&mut self, lhs: &u8)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: &u8)
fn div_ceil_from(&mut self, lhs: &u8)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: &u8)
fn div_floor_from(&mut self, lhs: &u8)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: &u8)
fn div_euc_from(&mut self, lhs: &u8)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<Integer> for Integer
impl DivRoundingFrom<Integer> for Integer
sourcefn div_trunc_from(&mut self, lhs: Integer)
fn div_trunc_from(&mut self, lhs: Integer)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: Integer)
fn div_ceil_from(&mut self, lhs: Integer)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: Integer)
fn div_floor_from(&mut self, lhs: Integer)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: Integer)
fn div_euc_from(&mut self, lhs: Integer)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<i128> for Integer
impl DivRoundingFrom<i128> for Integer
sourcefn div_trunc_from(&mut self, lhs: i128)
fn div_trunc_from(&mut self, lhs: i128)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: i128)
fn div_ceil_from(&mut self, lhs: i128)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: i128)
fn div_floor_from(&mut self, lhs: i128)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: i128)
fn div_euc_from(&mut self, lhs: i128)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<i16> for Integer
impl DivRoundingFrom<i16> for Integer
sourcefn div_trunc_from(&mut self, lhs: i16)
fn div_trunc_from(&mut self, lhs: i16)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: i16)
fn div_ceil_from(&mut self, lhs: i16)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: i16)
fn div_floor_from(&mut self, lhs: i16)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: i16)
fn div_euc_from(&mut self, lhs: i16)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<i32> for Integer
impl DivRoundingFrom<i32> for Integer
sourcefn div_trunc_from(&mut self, lhs: i32)
fn div_trunc_from(&mut self, lhs: i32)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: i32)
fn div_ceil_from(&mut self, lhs: i32)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: i32)
fn div_floor_from(&mut self, lhs: i32)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: i32)
fn div_euc_from(&mut self, lhs: i32)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<i64> for Integer
impl DivRoundingFrom<i64> for Integer
sourcefn div_trunc_from(&mut self, lhs: i64)
fn div_trunc_from(&mut self, lhs: i64)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: i64)
fn div_ceil_from(&mut self, lhs: i64)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: i64)
fn div_floor_from(&mut self, lhs: i64)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: i64)
fn div_euc_from(&mut self, lhs: i64)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<i8> for Integer
impl DivRoundingFrom<i8> for Integer
sourcefn div_trunc_from(&mut self, lhs: i8)
fn div_trunc_from(&mut self, lhs: i8)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: i8)
fn div_ceil_from(&mut self, lhs: i8)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: i8)
fn div_floor_from(&mut self, lhs: i8)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: i8)
fn div_euc_from(&mut self, lhs: i8)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<u128> for Integer
impl DivRoundingFrom<u128> for Integer
sourcefn div_trunc_from(&mut self, lhs: u128)
fn div_trunc_from(&mut self, lhs: u128)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: u128)
fn div_ceil_from(&mut self, lhs: u128)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: u128)
fn div_floor_from(&mut self, lhs: u128)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: u128)
fn div_euc_from(&mut self, lhs: u128)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<u16> for Integer
impl DivRoundingFrom<u16> for Integer
sourcefn div_trunc_from(&mut self, lhs: u16)
fn div_trunc_from(&mut self, lhs: u16)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: u16)
fn div_ceil_from(&mut self, lhs: u16)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: u16)
fn div_floor_from(&mut self, lhs: u16)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: u16)
fn div_euc_from(&mut self, lhs: u16)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<u32> for Integer
impl DivRoundingFrom<u32> for Integer
sourcefn div_trunc_from(&mut self, lhs: u32)
fn div_trunc_from(&mut self, lhs: u32)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: u32)
fn div_ceil_from(&mut self, lhs: u32)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: u32)
fn div_floor_from(&mut self, lhs: u32)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: u32)
fn div_euc_from(&mut self, lhs: u32)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<u64> for Integer
impl DivRoundingFrom<u64> for Integer
sourcefn div_trunc_from(&mut self, lhs: u64)
fn div_trunc_from(&mut self, lhs: u64)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: u64)
fn div_ceil_from(&mut self, lhs: u64)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: u64)
fn div_floor_from(&mut self, lhs: u64)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: u64)
fn div_euc_from(&mut self, lhs: u64)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl DivRoundingFrom<u8> for Integer
impl DivRoundingFrom<u8> for Integer
sourcefn div_trunc_from(&mut self, lhs: u8)
fn div_trunc_from(&mut self, lhs: u8)
Performs division, rounding the quotient towards zero.
sourcefn div_ceil_from(&mut self, lhs: u8)
fn div_ceil_from(&mut self, lhs: u8)
Performs division, rounding the quotient up.
sourcefn div_floor_from(&mut self, lhs: u8)
fn div_floor_from(&mut self, lhs: u8)
Performs division, rounding the quotient down.
sourcefn div_euc_from(&mut self, lhs: u8)
fn div_euc_from(&mut self, lhs: u8)
Performs Euclidean division, rounding the quotient so that the remainder cannot be negative. Read more
sourceimpl FromPrimitive for Integer
impl FromPrimitive for Integer
sourcefn from_i64(n: i64) -> Option<Self>
fn from_i64(n: i64) -> Option<Self>
Converts an i64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_u64(n: u64) -> Option<Self>
fn from_u64(n: u64) -> Option<Self>
Converts an u64
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_isize(n: isize) -> Option<Self>
fn from_isize(n: isize) -> Option<Self>
Converts an isize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_i8(n: i8) -> Option<Self>
fn from_i8(n: i8) -> Option<Self>
Converts an i8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_i16(n: i16) -> Option<Self>
fn from_i16(n: i16) -> Option<Self>
Converts an i16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_i32(n: i32) -> Option<Self>
fn from_i32(n: i32) -> Option<Self>
Converts an i32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_i128(n: i128) -> Option<Self>
fn from_i128(n: i128) -> Option<Self>
Converts an i128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_usize(n: usize) -> Option<Self>
fn from_usize(n: usize) -> Option<Self>
Converts a usize
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_u8(n: u8) -> Option<Self>
fn from_u8(n: u8) -> Option<Self>
Converts an u8
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_u16(n: u16) -> Option<Self>
fn from_u16(n: u16) -> Option<Self>
Converts an u16
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_u32(n: u32) -> Option<Self>
fn from_u32(n: u32) -> Option<Self>
Converts an u32
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourcefn from_u128(n: u128) -> Option<Self>
fn from_u128(n: u128) -> Option<Self>
Converts an u128
to return an optional value of this type. If the
value cannot be represented by this type, then None
is returned. Read more
sourceimpl FromStr for Integer
impl FromStr for Integer
type Err = ParseIntegerError
type Err = ParseIntegerError
The associated error which can be returned from parsing.
sourceimpl Integer for Integer
impl Integer for Integer
sourcefn is_multiple_of(&self, other: &Self) -> bool
fn is_multiple_of(&self, other: &Self) -> bool
Returns true
if self
is a multiple of other
. Read more
sourcefn div_rem(&self, other: &Self) -> (Self, Self)
fn div_rem(&self, other: &Self) -> (Self, Self)
Simultaneous truncated integer division and modulus.
Returns (quotient, remainder)
. Read more
sourcefn gcd_lcm(&self, other: &Self) -> (Self, Self)
fn gcd_lcm(&self, other: &Self) -> (Self, Self)
Greatest Common Divisor (GCD) and Lowest Common Multiple (LCM) together. Read more
sourcefn extended_gcd(&self, other: &Self) -> ExtendedGcd<Self>
fn extended_gcd(&self, other: &Self) -> ExtendedGcd<Self>
Greatest common divisor and Bézout coefficients. Read more
sourcefn extended_gcd_lcm(&self, other: &Self) -> (ExtendedGcd<Self>, Self)
fn extended_gcd_lcm(&self, other: &Self) -> (ExtendedGcd<Self>, Self)
Greatest common divisor, least common multiple, and Bézout coefficients.
sourcefn div_mod_floor(&self, other: &Self) -> (Self, Self)
fn div_mod_floor(&self, other: &Self) -> (Self, Self)
Simultaneous floored integer division and modulus.
Returns (quotient, remainder)
. Read more
sourcefn next_multiple_of(&self, other: &Self) -> Self
fn next_multiple_of(&self, other: &Self) -> Self
Rounds up to nearest multiple of argument. Read more
sourcefn prev_multiple_of(&self, other: &Self) -> Self
fn prev_multiple_of(&self, other: &Self) -> Self
Rounds down to nearest multiple of argument. Read more
sourceimpl MulAddAssign<&Integer, &Integer> for Integer
impl MulAddAssign<&Integer, &Integer> for Integer
sourcefn mul_add_assign(&mut self, a: &Integer, b: &Integer)
fn mul_add_assign(&mut self, a: &Integer, b: &Integer)
Performs the fused multiply-add operation.
sourceimpl MulAddAssign<Integer, Integer> for Integer
impl MulAddAssign<Integer, Integer> for Integer
sourcefn mul_add_assign(&mut self, a: Integer, b: Integer)
fn mul_add_assign(&mut self, a: Integer, b: Integer)
Performs the fused multiply-add operation.
sourceimpl MulAssign<&Integer> for Complex
impl MulAssign<&Integer> for Complex
sourcefn mul_assign(&mut self, rhs: &Integer)
fn mul_assign(&mut self, rhs: &Integer)
Performs the *=
operation. Read more
sourceimpl MulAssign<&Integer> for Float
impl MulAssign<&Integer> for Float
sourcefn mul_assign(&mut self, rhs: &Integer)
fn mul_assign(&mut self, rhs: &Integer)
Performs the *=
operation. Read more
sourceimpl MulAssign<&Integer> for Integer
impl MulAssign<&Integer> for Integer
sourcefn mul_assign(&mut self, rhs: &Integer)
fn mul_assign(&mut self, rhs: &Integer)
Performs the *=
operation. Read more
sourceimpl MulAssign<&Integer> for Rational
impl MulAssign<&Integer> for Rational
sourcefn mul_assign(&mut self, rhs: &Integer)
fn mul_assign(&mut self, rhs: &Integer)
Performs the *=
operation. Read more
sourceimpl MulAssign<&i128> for Integer
impl MulAssign<&i128> for Integer
sourcefn mul_assign(&mut self, rhs: &i128)
fn mul_assign(&mut self, rhs: &i128)
Performs the *=
operation. Read more
sourceimpl MulAssign<&i16> for Integer
impl MulAssign<&i16> for Integer
sourcefn mul_assign(&mut self, rhs: &i16)
fn mul_assign(&mut self, rhs: &i16)
Performs the *=
operation. Read more
sourceimpl MulAssign<&i32> for Integer
impl MulAssign<&i32> for Integer
sourcefn mul_assign(&mut self, rhs: &i32)
fn mul_assign(&mut self, rhs: &i32)
Performs the *=
operation. Read more
sourceimpl MulAssign<&i64> for Integer
impl MulAssign<&i64> for Integer
sourcefn mul_assign(&mut self, rhs: &i64)
fn mul_assign(&mut self, rhs: &i64)
Performs the *=
operation. Read more
sourceimpl MulAssign<&i8> for Integer
impl MulAssign<&i8> for Integer
sourcefn mul_assign(&mut self, rhs: &i8)
fn mul_assign(&mut self, rhs: &i8)
Performs the *=
operation. Read more
sourceimpl MulAssign<&isize> for Integer
impl MulAssign<&isize> for Integer
sourcefn mul_assign(&mut self, rhs: &isize)
fn mul_assign(&mut self, rhs: &isize)
Performs the *=
operation. Read more
sourceimpl MulAssign<&u128> for Integer
impl MulAssign<&u128> for Integer
sourcefn mul_assign(&mut self, rhs: &u128)
fn mul_assign(&mut self, rhs: &u128)
Performs the *=
operation. Read more
sourceimpl MulAssign<&u16> for Integer
impl MulAssign<&u16> for Integer
sourcefn mul_assign(&mut self, rhs: &u16)
fn mul_assign(&mut self, rhs: &u16)
Performs the *=
operation. Read more
sourceimpl MulAssign<&u32> for Integer
impl MulAssign<&u32> for Integer
sourcefn mul_assign(&mut self, rhs: &u32)
fn mul_assign(&mut self, rhs: &u32)
Performs the *=
operation. Read more
sourceimpl MulAssign<&u64> for Integer
impl MulAssign<&u64> for Integer
sourcefn mul_assign(&mut self, rhs: &u64)
fn mul_assign(&mut self, rhs: &u64)
Performs the *=
operation. Read more
sourceimpl MulAssign<&u8> for Integer
impl MulAssign<&u8> for Integer
sourcefn mul_assign(&mut self, rhs: &u8)
fn mul_assign(&mut self, rhs: &u8)
Performs the *=
operation. Read more
sourceimpl MulAssign<&usize> for Integer
impl MulAssign<&usize> for Integer
sourcefn mul_assign(&mut self, rhs: &usize)
fn mul_assign(&mut self, rhs: &usize)
Performs the *=
operation. Read more
sourceimpl MulAssign<Integer> for Complex
impl MulAssign<Integer> for Complex
sourcefn mul_assign(&mut self, rhs: Integer)
fn mul_assign(&mut self, rhs: Integer)
Performs the *=
operation. Read more
sourceimpl MulAssign<Integer> for Float
impl MulAssign<Integer> for Float
sourcefn mul_assign(&mut self, rhs: Integer)
fn mul_assign(&mut self, rhs: Integer)
Performs the *=
operation. Read more
sourceimpl MulAssign<Integer> for Integer
impl MulAssign<Integer> for Integer
sourcefn mul_assign(&mut self, rhs: Integer)
fn mul_assign(&mut self, rhs: Integer)
Performs the *=
operation. Read more
sourceimpl MulAssign<Integer> for Rational
impl MulAssign<Integer> for Rational
sourcefn mul_assign(&mut self, rhs: Integer)
fn mul_assign(&mut self, rhs: Integer)
Performs the *=
operation. Read more
sourceimpl MulAssign<i128> for Integer
impl MulAssign<i128> for Integer
sourcefn mul_assign(&mut self, rhs: i128)
fn mul_assign(&mut self, rhs: i128)
Performs the *=
operation. Read more
sourceimpl MulAssign<i16> for Integer
impl MulAssign<i16> for Integer
sourcefn mul_assign(&mut self, rhs: i16)
fn mul_assign(&mut self, rhs: i16)
Performs the *=
operation. Read more
sourceimpl MulAssign<i32> for Integer
impl MulAssign<i32> for Integer
sourcefn mul_assign(&mut self, rhs: i32)
fn mul_assign(&mut self, rhs: i32)
Performs the *=
operation. Read more
sourceimpl MulAssign<i64> for Integer
impl MulAssign<i64> for Integer
sourcefn mul_assign(&mut self, rhs: i64)
fn mul_assign(&mut self, rhs: i64)
Performs the *=
operation. Read more
sourceimpl MulAssign<i8> for Integer
impl MulAssign<i8> for Integer
sourcefn mul_assign(&mut self, rhs: i8)
fn mul_assign(&mut self, rhs: i8)
Performs the *=
operation. Read more
sourceimpl MulAssign<isize> for Integer
impl MulAssign<isize> for Integer
sourcefn mul_assign(&mut self, rhs: isize)
fn mul_assign(&mut self, rhs: isize)
Performs the *=
operation. Read more
sourceimpl MulAssign<u128> for Integer
impl MulAssign<u128> for Integer
sourcefn mul_assign(&mut self, rhs: u128)
fn mul_assign(&mut self, rhs: u128)
Performs the *=
operation. Read more
sourceimpl MulAssign<u16> for Integer
impl MulAssign<u16> for Integer
sourcefn mul_assign(&mut self, rhs: u16)
fn mul_assign(&mut self, rhs: u16)
Performs the *=
operation. Read more
sourceimpl MulAssign<u32> for Integer
impl MulAssign<u32> for Integer
sourcefn mul_assign(&mut self, rhs: u32)
fn mul_assign(&mut self, rhs: u32)
Performs the *=
operation. Read more
sourceimpl MulAssign<u64> for Integer
impl MulAssign<u64> for Integer
sourcefn mul_assign(&mut self, rhs: u64)
fn mul_assign(&mut self, rhs: u64)
Performs the *=
operation. Read more
sourceimpl MulAssign<u8> for Integer
impl MulAssign<u8> for Integer
sourcefn mul_assign(&mut self, rhs: u8)
fn mul_assign(&mut self, rhs: u8)
Performs the *=
operation. Read more
sourceimpl MulAssign<usize> for Integer
impl MulAssign<usize> for Integer
sourcefn mul_assign(&mut self, rhs: usize)
fn mul_assign(&mut self, rhs: usize)
Performs the *=
operation. Read more
sourceimpl MulAssignRound<&Integer> for Complex
impl MulAssignRound<&Integer> for Complex
sourceimpl MulAssignRound<&Integer> for Float
impl MulAssignRound<&Integer> for Float
sourceimpl MulAssignRound<Integer> for Complex
impl MulAssignRound<Integer> for Complex
sourceimpl MulAssignRound<Integer> for Float
impl MulAssignRound<Integer> for Float
sourceimpl MulFromRound<&Integer> for Complex
impl MulFromRound<&Integer> for Complex
sourceimpl MulFromRound<&Integer> for Float
impl MulFromRound<&Integer> for Float
sourceimpl MulFromRound<Integer> for Complex
impl MulFromRound<Integer> for Complex
sourceimpl MulFromRound<Integer> for Float
impl MulFromRound<Integer> for Float
sourceimpl Num for Integer
impl Num for Integer
type FromStrRadixErr = ParseIntegerError
sourcefn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntegerError>
fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntegerError>
Convert from a string and radix (typically 2..=36
). Read more
sourceimpl Ord for Integer
impl Ord for Integer
1.21.0 · sourcefn max(self, other: Self) -> Self
fn max(self, other: Self) -> Self
Compares and returns the maximum of two values. Read more
1.21.0 · sourcefn min(self, other: Self) -> Self
fn min(self, other: Self) -> Self
Compares and returns the minimum of two values. Read more
1.50.0 · sourcefn clamp(self, min: Self, max: Self) -> Self where
Self: PartialOrd<Self>,
fn clamp(self, min: Self, max: Self) -> Self where
Self: PartialOrd<Self>,
Restrict a value to a certain interval. Read more
sourceimpl OverflowingCast<i128> for &Integer
impl OverflowingCast<i128> for &Integer
sourcefn overflowing_cast(self) -> (i128, bool)
fn overflowing_cast(self) -> (i128, bool)
Casts the value.
sourceimpl OverflowingCast<i128> for Integer
impl OverflowingCast<i128> for Integer
sourcefn overflowing_cast(self) -> (i128, bool)
fn overflowing_cast(self) -> (i128, bool)
Casts the value.
sourceimpl OverflowingCast<i16> for &Integer
impl OverflowingCast<i16> for &Integer
sourcefn overflowing_cast(self) -> (i16, bool)
fn overflowing_cast(self) -> (i16, bool)
Casts the value.
sourceimpl OverflowingCast<i16> for Integer
impl OverflowingCast<i16> for Integer
sourcefn overflowing_cast(self) -> (i16, bool)
fn overflowing_cast(self) -> (i16, bool)
Casts the value.
sourceimpl OverflowingCast<i32> for &Integer
impl OverflowingCast<i32> for &Integer
sourcefn overflowing_cast(self) -> (i32, bool)
fn overflowing_cast(self) -> (i32, bool)
Casts the value.
sourceimpl OverflowingCast<i32> for Integer
impl OverflowingCast<i32> for Integer
sourcefn overflowing_cast(self) -> (i32, bool)
fn overflowing_cast(self) -> (i32, bool)
Casts the value.
sourceimpl OverflowingCast<i64> for &Integer
impl OverflowingCast<i64> for &Integer
sourcefn overflowing_cast(self) -> (i64, bool)
fn overflowing_cast(self) -> (i64, bool)
Casts the value.
sourceimpl OverflowingCast<i64> for Integer
impl OverflowingCast<i64> for Integer
sourcefn overflowing_cast(self) -> (i64, bool)
fn overflowing_cast(self) -> (i64, bool)
Casts the value.
sourceimpl OverflowingCast<i8> for &Integer
impl OverflowingCast<i8> for &Integer
sourcefn overflowing_cast(self) -> (i8, bool)
fn overflowing_cast(self) -> (i8, bool)
Casts the value.
sourceimpl OverflowingCast<i8> for Integer
impl OverflowingCast<i8> for Integer
sourcefn overflowing_cast(self) -> (i8, bool)
fn overflowing_cast(self) -> (i8, bool)
Casts the value.
sourceimpl OverflowingCast<isize> for &Integer
impl OverflowingCast<isize> for &Integer
sourcefn overflowing_cast(self) -> (isize, bool)
fn overflowing_cast(self) -> (isize, bool)
Casts the value.
sourceimpl OverflowingCast<isize> for Integer
impl OverflowingCast<isize> for Integer
sourcefn overflowing_cast(self) -> (isize, bool)
fn overflowing_cast(self) -> (isize, bool)
Casts the value.
sourceimpl OverflowingCast<u128> for &Integer
impl OverflowingCast<u128> for &Integer
sourcefn overflowing_cast(self) -> (u128, bool)
fn overflowing_cast(self) -> (u128, bool)
Casts the value.
sourceimpl OverflowingCast<u128> for Integer
impl OverflowingCast<u128> for Integer
sourcefn overflowing_cast(self) -> (u128, bool)
fn overflowing_cast(self) -> (u128, bool)
Casts the value.
sourceimpl OverflowingCast<u16> for &Integer
impl OverflowingCast<u16> for &Integer
sourcefn overflowing_cast(self) -> (u16, bool)
fn overflowing_cast(self) -> (u16, bool)
Casts the value.
sourceimpl OverflowingCast<u16> for Integer
impl OverflowingCast<u16> for Integer
sourcefn overflowing_cast(self) -> (u16, bool)
fn overflowing_cast(self) -> (u16, bool)
Casts the value.
sourceimpl OverflowingCast<u32> for &Integer
impl OverflowingCast<u32> for &Integer
sourcefn overflowing_cast(self) -> (u32, bool)
fn overflowing_cast(self) -> (u32, bool)
Casts the value.
sourceimpl OverflowingCast<u32> for Integer
impl OverflowingCast<u32> for Integer
sourcefn overflowing_cast(self) -> (u32, bool)
fn overflowing_cast(self) -> (u32, bool)
Casts the value.
sourceimpl OverflowingCast<u64> for &Integer
impl OverflowingCast<u64> for &Integer
sourcefn overflowing_cast(self) -> (u64, bool)
fn overflowing_cast(self) -> (u64, bool)
Casts the value.
sourceimpl OverflowingCast<u64> for Integer
impl OverflowingCast<u64> for Integer
sourcefn overflowing_cast(self) -> (u64, bool)
fn overflowing_cast(self) -> (u64, bool)
Casts the value.
sourceimpl OverflowingCast<u8> for &Integer
impl OverflowingCast<u8> for &Integer
sourcefn overflowing_cast(self) -> (u8, bool)
fn overflowing_cast(self) -> (u8, bool)
Casts the value.
sourceimpl OverflowingCast<u8> for Integer
impl OverflowingCast<u8> for Integer
sourcefn overflowing_cast(self) -> (u8, bool)
fn overflowing_cast(self) -> (u8, bool)
Casts the value.
sourceimpl OverflowingCast<usize> for &Integer
impl OverflowingCast<usize> for &Integer
sourcefn overflowing_cast(self) -> (usize, bool)
fn overflowing_cast(self) -> (usize, bool)
Casts the value.
sourceimpl OverflowingCast<usize> for Integer
impl OverflowingCast<usize> for Integer
sourcefn overflowing_cast(self) -> (usize, bool)
fn overflowing_cast(self) -> (usize, bool)
Casts the value.
sourceimpl PartialOrd<Float> for Integer
impl PartialOrd<Float> for Integer
sourcefn partial_cmp(&self, other: &Float) -> Option<Ordering>
fn partial_cmp(&self, other: &Float) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for Float
impl PartialOrd<Integer> for Float
sourcefn partial_cmp(&self, z: &Integer) -> Option<Ordering>
fn partial_cmp(&self, z: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for Integer
impl PartialOrd<Integer> for Integer
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for Rational
impl PartialOrd<Integer> for Rational
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for f32
impl PartialOrd<Integer> for f32
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for f64
impl PartialOrd<Integer> for f64
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for i128
impl PartialOrd<Integer> for i128
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for i16
impl PartialOrd<Integer> for i16
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for i32
impl PartialOrd<Integer> for i32
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for i64
impl PartialOrd<Integer> for i64
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for i8
impl PartialOrd<Integer> for i8
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for isize
impl PartialOrd<Integer> for isize
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for u128
impl PartialOrd<Integer> for u128
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for u16
impl PartialOrd<Integer> for u16
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for u32
impl PartialOrd<Integer> for u32
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for u64
impl PartialOrd<Integer> for u64
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for u8
impl PartialOrd<Integer> for u8
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for usize
impl PartialOrd<Integer> for usize
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Rational> for Integer
impl PartialOrd<Rational> for Integer
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<f32> for Integer
impl PartialOrd<f32> for Integer
sourcefn partial_cmp(&self, other: &f32) -> Option<Ordering>
fn partial_cmp(&self, other: &f32) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<f64> for Integer
impl PartialOrd<f64> for Integer
sourcefn partial_cmp(&self, other: &f64) -> Option<Ordering>
fn partial_cmp(&self, other: &f64) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i128> for Integer
impl PartialOrd<i128> for Integer
sourcefn partial_cmp(&self, other: &i128) -> Option<Ordering>
fn partial_cmp(&self, other: &i128) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i16> for Integer
impl PartialOrd<i16> for Integer
sourcefn partial_cmp(&self, other: &i16) -> Option<Ordering>
fn partial_cmp(&self, other: &i16) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i32> for Integer
impl PartialOrd<i32> for Integer
sourcefn partial_cmp(&self, other: &i32) -> Option<Ordering>
fn partial_cmp(&self, other: &i32) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i64> for Integer
impl PartialOrd<i64> for Integer
sourcefn partial_cmp(&self, other: &i64) -> Option<Ordering>
fn partial_cmp(&self, other: &i64) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i8> for Integer
impl PartialOrd<i8> for Integer
sourcefn partial_cmp(&self, other: &i8) -> Option<Ordering>
fn partial_cmp(&self, other: &i8) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<isize> for Integer
impl PartialOrd<isize> for Integer
sourcefn partial_cmp(&self, other: &isize) -> Option<Ordering>
fn partial_cmp(&self, other: &isize) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u128> for Integer
impl PartialOrd<u128> for Integer
sourcefn partial_cmp(&self, other: &u128) -> Option<Ordering>
fn partial_cmp(&self, other: &u128) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u16> for Integer
impl PartialOrd<u16> for Integer
sourcefn partial_cmp(&self, other: &u16) -> Option<Ordering>
fn partial_cmp(&self, other: &u16) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u32> for Integer
impl PartialOrd<u32> for Integer
sourcefn partial_cmp(&self, other: &u32) -> Option<Ordering>
fn partial_cmp(&self, other: &u32) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u64> for Integer
impl PartialOrd<u64> for Integer
sourcefn partial_cmp(&self, other: &u64) -> Option<Ordering>
fn partial_cmp(&self, other: &u64) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u8> for Integer
impl PartialOrd<u8> for Integer
sourcefn partial_cmp(&self, other: &u8) -> Option<Ordering>
fn partial_cmp(&self, other: &u8) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<usize> for Integer
impl PartialOrd<usize> for Integer
sourcefn partial_cmp(&self, other: &usize) -> Option<Ordering>
fn partial_cmp(&self, other: &usize) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PowAssign<&Integer> for Complex
impl PowAssign<&Integer> for Complex
sourcefn pow_assign(&mut self, rhs: &Integer)
fn pow_assign(&mut self, rhs: &Integer)
Peforms the power operation. Read more
sourceimpl PowAssign<&Integer> for Float
impl PowAssign<&Integer> for Float
sourcefn pow_assign(&mut self, rhs: &Integer)
fn pow_assign(&mut self, rhs: &Integer)
Peforms the power operation. Read more
sourceimpl PowAssign<&u32> for Integer
impl PowAssign<&u32> for Integer
sourcefn pow_assign(&mut self, rhs: &u32)
fn pow_assign(&mut self, rhs: &u32)
Peforms the power operation. Read more
sourceimpl PowAssign<Integer> for Complex
impl PowAssign<Integer> for Complex
sourcefn pow_assign(&mut self, rhs: Integer)
fn pow_assign(&mut self, rhs: Integer)
Peforms the power operation. Read more
sourceimpl PowAssign<Integer> for Float
impl PowAssign<Integer> for Float
sourcefn pow_assign(&mut self, rhs: Integer)
fn pow_assign(&mut self, rhs: Integer)
Peforms the power operation. Read more
sourceimpl PowAssign<u32> for Integer
impl PowAssign<u32> for Integer
sourcefn pow_assign(&mut self, rhs: u32)
fn pow_assign(&mut self, rhs: u32)
Peforms the power operation. Read more
sourceimpl PowAssignRound<&Integer> for Complex
impl PowAssignRound<&Integer> for Complex
sourceimpl PowAssignRound<&Integer> for Float
impl PowAssignRound<&Integer> for Float
sourceimpl PowAssignRound<Integer> for Complex
impl PowAssignRound<Integer> for Complex
sourceimpl PowAssignRound<Integer> for Float
impl PowAssignRound<Integer> for Float
sourceimpl RemAssign<&Integer> for Integer
impl RemAssign<&Integer> for Integer
sourcefn rem_assign(&mut self, rhs: &Integer)
fn rem_assign(&mut self, rhs: &Integer)
Performs the %=
operation. Read more
sourceimpl RemAssign<&i128> for Integer
impl RemAssign<&i128> for Integer
sourcefn rem_assign(&mut self, rhs: &i128)
fn rem_assign(&mut self, rhs: &i128)
Performs the %=
operation. Read more
sourceimpl RemAssign<&i16> for Integer
impl RemAssign<&i16> for Integer
sourcefn rem_assign(&mut self, rhs: &i16)
fn rem_assign(&mut self, rhs: &i16)
Performs the %=
operation. Read more
sourceimpl RemAssign<&i32> for Integer
impl RemAssign<&i32> for Integer
sourcefn rem_assign(&mut self, rhs: &i32)
fn rem_assign(&mut self, rhs: &i32)
Performs the %=
operation. Read more
sourceimpl RemAssign<&i64> for Integer
impl RemAssign<&i64> for Integer
sourcefn rem_assign(&mut self, rhs: &i64)
fn rem_assign(&mut self, rhs: &i64)
Performs the %=
operation. Read more
sourceimpl RemAssign<&i8> for Integer
impl RemAssign<&i8> for Integer
sourcefn rem_assign(&mut self, rhs: &i8)
fn rem_assign(&mut self, rhs: &i8)
Performs the %=
operation. Read more
sourceimpl RemAssign<&isize> for Integer
impl RemAssign<&isize> for Integer
sourcefn rem_assign(&mut self, rhs: &isize)
fn rem_assign(&mut self, rhs: &isize)
Performs the %=
operation. Read more
sourceimpl RemAssign<&u128> for Integer
impl RemAssign<&u128> for Integer
sourcefn rem_assign(&mut self, rhs: &u128)
fn rem_assign(&mut self, rhs: &u128)
Performs the %=
operation. Read more
sourceimpl RemAssign<&u16> for Integer
impl RemAssign<&u16> for Integer
sourcefn rem_assign(&mut self, rhs: &u16)
fn rem_assign(&mut self, rhs: &u16)
Performs the %=
operation. Read more
sourceimpl RemAssign<&u32> for Integer
impl RemAssign<&u32> for Integer
sourcefn rem_assign(&mut self, rhs: &u32)
fn rem_assign(&mut self, rhs: &u32)
Performs the %=
operation. Read more
sourceimpl RemAssign<&u64> for Integer
impl RemAssign<&u64> for Integer
sourcefn rem_assign(&mut self, rhs: &u64)
fn rem_assign(&mut self, rhs: &u64)
Performs the %=
operation. Read more
sourceimpl RemAssign<&u8> for Integer
impl RemAssign<&u8> for Integer
sourcefn rem_assign(&mut self, rhs: &u8)
fn rem_assign(&mut self, rhs: &u8)
Performs the %=
operation. Read more
sourceimpl RemAssign<&usize> for Integer
impl RemAssign<&usize> for Integer
sourcefn rem_assign(&mut self, rhs: &usize)
fn rem_assign(&mut self, rhs: &usize)
Performs the %=
operation. Read more
sourceimpl RemAssign<Integer> for Integer
impl RemAssign<Integer> for Integer
sourcefn rem_assign(&mut self, rhs: Integer)
fn rem_assign(&mut self, rhs: Integer)
Performs the %=
operation. Read more
sourceimpl RemAssign<i128> for Integer
impl RemAssign<i128> for Integer
sourcefn rem_assign(&mut self, rhs: i128)
fn rem_assign(&mut self, rhs: i128)
Performs the %=
operation. Read more
sourceimpl RemAssign<i16> for Integer
impl RemAssign<i16> for Integer
sourcefn rem_assign(&mut self, rhs: i16)
fn rem_assign(&mut self, rhs: i16)
Performs the %=
operation. Read more
sourceimpl RemAssign<i32> for Integer
impl RemAssign<i32> for Integer
sourcefn rem_assign(&mut self, rhs: i32)
fn rem_assign(&mut self, rhs: i32)
Performs the %=
operation. Read more
sourceimpl RemAssign<i64> for Integer
impl RemAssign<i64> for Integer
sourcefn rem_assign(&mut self, rhs: i64)
fn rem_assign(&mut self, rhs: i64)
Performs the %=
operation. Read more
sourceimpl RemAssign<i8> for Integer
impl RemAssign<i8> for Integer
sourcefn rem_assign(&mut self, rhs: i8)
fn rem_assign(&mut self, rhs: i8)
Performs the %=
operation. Read more
sourceimpl RemAssign<isize> for Integer
impl RemAssign<isize> for Integer
sourcefn rem_assign(&mut self, rhs: isize)
fn rem_assign(&mut self, rhs: isize)
Performs the %=
operation. Read more
sourceimpl RemAssign<u128> for Integer
impl RemAssign<u128> for Integer
sourcefn rem_assign(&mut self, rhs: u128)
fn rem_assign(&mut self, rhs: u128)
Performs the %=
operation. Read more
sourceimpl RemAssign<u16> for Integer
impl RemAssign<u16> for Integer
sourcefn rem_assign(&mut self, rhs: u16)
fn rem_assign(&mut self, rhs: u16)
Performs the %=
operation. Read more
sourceimpl RemAssign<u32> for Integer
impl RemAssign<u32> for Integer
sourcefn rem_assign(&mut self, rhs: u32)
fn rem_assign(&mut self, rhs: u32)
Performs the %=
operation. Read more
sourceimpl RemAssign<u64> for Integer
impl RemAssign<u64> for Integer
sourcefn rem_assign(&mut self, rhs: u64)
fn rem_assign(&mut self, rhs: u64)
Performs the %=
operation. Read more
sourceimpl RemAssign<u8> for Integer
impl RemAssign<u8> for Integer
sourcefn rem_assign(&mut self, rhs: u8)
fn rem_assign(&mut self, rhs: u8)
Performs the %=
operation. Read more
sourceimpl RemAssign<usize> for Integer
impl RemAssign<usize> for Integer
sourcefn rem_assign(&mut self, rhs: usize)
fn rem_assign(&mut self, rhs: usize)
Performs the %=
operation. Read more
sourceimpl<'i> RemRounding<&'i Integer> for &'i Integer
impl<'i> RemRounding<&'i Integer> for &'i Integer
type Output = RemRoundingIncomplete<'i>
type Output = RemRoundingIncomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingIncomplete<'_>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for &i128
impl<'i> RemRounding<&'i Integer> for &i128
type Output = RemRoundingFromI128Incomplete<'i>
type Output = RemRoundingFromI128Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI128Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for &i16
impl<'i> RemRounding<&'i Integer> for &i16
type Output = RemRoundingFromI16Incomplete<'i>
type Output = RemRoundingFromI16Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI16Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for &i32
impl<'i> RemRounding<&'i Integer> for &i32
type Output = RemRoundingFromI32Incomplete<'i>
type Output = RemRoundingFromI32Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI32Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for &i64
impl<'i> RemRounding<&'i Integer> for &i64
type Output = RemRoundingFromI64Incomplete<'i>
type Output = RemRoundingFromI64Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI64Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for &i8
impl<'i> RemRounding<&'i Integer> for &i8
type Output = RemRoundingFromI8Incomplete<'i>
type Output = RemRoundingFromI8Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromI8Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for &u128
impl<'i> RemRounding<&'i Integer> for &u128
type Output = RemRoundingFromU128Incomplete<'i>
type Output = RemRoundingFromU128Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU128Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for &u16
impl<'i> RemRounding<&'i Integer> for &u16
type Output = RemRoundingFromU16Incomplete<'i>
type Output = RemRoundingFromU16Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU16Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for &u32
impl<'i> RemRounding<&'i Integer> for &u32
type Output = RemRoundingFromU32Incomplete<'i>
type Output = RemRoundingFromU32Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU32Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for &u64
impl<'i> RemRounding<&'i Integer> for &u64
type Output = RemRoundingFromU64Incomplete<'i>
type Output = RemRoundingFromU64Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU64Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for &u8
impl<'i> RemRounding<&'i Integer> for &u8
type Output = RemRoundingFromU8Incomplete<'i>
type Output = RemRoundingFromU8Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>
fn rem_trunc(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>
fn rem_ceil(self, rhs: &'i Integer) -> RemRoundingFromU8Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for i128
impl<'i> RemRounding<&'i Integer> for i128
type Output = RemRoundingFromI128Incomplete<'i>
type Output = RemRoundingFromI128Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI128Incomplete<'_>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for i16
impl<'i> RemRounding<&'i Integer> for i16
type Output = RemRoundingFromI16Incomplete<'i>
type Output = RemRoundingFromI16Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI16Incomplete<'_>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for i32
impl<'i> RemRounding<&'i Integer> for i32
type Output = RemRoundingFromI32Incomplete<'i>
type Output = RemRoundingFromI32Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI32Incomplete<'_>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for i64
impl<'i> RemRounding<&'i Integer> for i64
type Output = RemRoundingFromI64Incomplete<'i>
type Output = RemRoundingFromI64Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI64Incomplete<'_>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for i8
impl<'i> RemRounding<&'i Integer> for i8
type Output = RemRoundingFromI8Incomplete<'i>
type Output = RemRoundingFromI8Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromI8Incomplete<'_>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for u128
impl<'i> RemRounding<&'i Integer> for u128
type Output = RemRoundingFromU128Incomplete<'i>
type Output = RemRoundingFromU128Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU128Incomplete<'_>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for u16
impl<'i> RemRounding<&'i Integer> for u16
type Output = RemRoundingFromU16Incomplete<'i>
type Output = RemRoundingFromU16Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU16Incomplete<'_>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for u32
impl<'i> RemRounding<&'i Integer> for u32
type Output = RemRoundingFromU32Incomplete<'i>
type Output = RemRoundingFromU32Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU32Incomplete<'_>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for u64
impl<'i> RemRounding<&'i Integer> for u64
type Output = RemRoundingFromU64Incomplete<'i>
type Output = RemRoundingFromU64Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU64Incomplete<'_>
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<&'i Integer> for u8
impl<'i> RemRounding<&'i Integer> for u8
type Output = RemRoundingFromU8Incomplete<'i>
type Output = RemRoundingFromU8Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>
fn rem_trunc(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>
fn rem_ceil(self, rhs: &Integer) -> RemRoundingFromU8Incomplete<'_>
Finds the remainder when the quotient is rounded up.
sourceimpl<'t, 'i> RemRounding<&'t i128> for &'i Integer
impl<'t, 'i> RemRounding<&'t i128> for &'i Integer
type Output = RemRoundingI128Incomplete<'i>
type Output = RemRoundingI128Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>
fn rem_trunc(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>
fn rem_ceil(self, rhs: &i128) -> RemRoundingI128Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'t, 'i> RemRounding<&'t i16> for &'i Integer
impl<'t, 'i> RemRounding<&'t i16> for &'i Integer
type Output = RemRoundingI16Incomplete<'i>
type Output = RemRoundingI16Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>
fn rem_trunc(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>
fn rem_ceil(self, rhs: &i16) -> RemRoundingI16Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'t, 'i> RemRounding<&'t i32> for &'i Integer
impl<'t, 'i> RemRounding<&'t i32> for &'i Integer
type Output = RemRoundingI32Incomplete<'i>
type Output = RemRoundingI32Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>
fn rem_trunc(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>
fn rem_ceil(self, rhs: &i32) -> RemRoundingI32Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'t, 'i> RemRounding<&'t i64> for &'i Integer
impl<'t, 'i> RemRounding<&'t i64> for &'i Integer
type Output = RemRoundingI64Incomplete<'i>
type Output = RemRoundingI64Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>
fn rem_trunc(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>
fn rem_ceil(self, rhs: &i64) -> RemRoundingI64Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'t, 'i> RemRounding<&'t i8> for &'i Integer
impl<'t, 'i> RemRounding<&'t i8> for &'i Integer
type Output = RemRoundingI8Incomplete<'i>
type Output = RemRoundingI8Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>
fn rem_trunc(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>
fn rem_ceil(self, rhs: &i8) -> RemRoundingI8Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'t, 'i> RemRounding<&'t u128> for &'i Integer
impl<'t, 'i> RemRounding<&'t u128> for &'i Integer
type Output = RemRoundingU128Incomplete<'i>
type Output = RemRoundingU128Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>
fn rem_trunc(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>
fn rem_ceil(self, rhs: &u128) -> RemRoundingU128Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'t, 'i> RemRounding<&'t u16> for &'i Integer
impl<'t, 'i> RemRounding<&'t u16> for &'i Integer
type Output = RemRoundingU16Incomplete<'i>
type Output = RemRoundingU16Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>
fn rem_trunc(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>
fn rem_ceil(self, rhs: &u16) -> RemRoundingU16Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'t, 'i> RemRounding<&'t u32> for &'i Integer
impl<'t, 'i> RemRounding<&'t u32> for &'i Integer
type Output = RemRoundingU32Incomplete<'i>
type Output = RemRoundingU32Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>
fn rem_trunc(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>
fn rem_ceil(self, rhs: &u32) -> RemRoundingU32Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'t, 'i> RemRounding<&'t u64> for &'i Integer
impl<'t, 'i> RemRounding<&'t u64> for &'i Integer
type Output = RemRoundingU64Incomplete<'i>
type Output = RemRoundingU64Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>
fn rem_trunc(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>
fn rem_ceil(self, rhs: &u64) -> RemRoundingU64Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl<'t, 'i> RemRounding<&'t u8> for &'i Integer
impl<'t, 'i> RemRounding<&'t u8> for &'i Integer
type Output = RemRoundingU8Incomplete<'i>
type Output = RemRoundingU8Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>
fn rem_trunc(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>
fn rem_ceil(self, rhs: &u8) -> RemRoundingU8Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<&Integer> for Integer
impl RemRounding<&Integer> for Integer
sourcefn rem_trunc(self, rhs: &Integer) -> Integer
fn rem_trunc(self, rhs: &Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: &Integer) -> Integer
fn rem_ceil(self, rhs: &Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<&i128> for Integer
impl RemRounding<&i128> for Integer
sourceimpl RemRounding<&i16> for Integer
impl RemRounding<&i16> for Integer
sourceimpl RemRounding<&i32> for Integer
impl RemRounding<&i32> for Integer
sourceimpl RemRounding<&i64> for Integer
impl RemRounding<&i64> for Integer
sourceimpl RemRounding<&i8> for Integer
impl RemRounding<&i8> for Integer
sourceimpl RemRounding<&u128> for Integer
impl RemRounding<&u128> for Integer
sourceimpl RemRounding<&u16> for Integer
impl RemRounding<&u16> for Integer
sourceimpl RemRounding<&u32> for Integer
impl RemRounding<&u32> for Integer
sourceimpl RemRounding<&u64> for Integer
impl RemRounding<&u64> for Integer
sourceimpl RemRounding<&u8> for Integer
impl RemRounding<&u8> for Integer
sourceimpl RemRounding<Integer> for &Integer
impl RemRounding<Integer> for &Integer
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for &i128
impl RemRounding<Integer> for &i128
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for &i16
impl RemRounding<Integer> for &i16
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for &i32
impl RemRounding<Integer> for &i32
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for &i64
impl RemRounding<Integer> for &i64
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for &i8
impl RemRounding<Integer> for &i8
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for &u128
impl RemRounding<Integer> for &u128
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for &u16
impl RemRounding<Integer> for &u16
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for &u32
impl RemRounding<Integer> for &u32
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for &u64
impl RemRounding<Integer> for &u64
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for &u8
impl RemRounding<Integer> for &u8
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for Integer
impl RemRounding<Integer> for Integer
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for i128
impl RemRounding<Integer> for i128
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for i16
impl RemRounding<Integer> for i16
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for i32
impl RemRounding<Integer> for i32
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for i64
impl RemRounding<Integer> for i64
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for i8
impl RemRounding<Integer> for i8
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for u128
impl RemRounding<Integer> for u128
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for u16
impl RemRounding<Integer> for u16
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for u32
impl RemRounding<Integer> for u32
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for u64
impl RemRounding<Integer> for u64
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<Integer> for u8
impl RemRounding<Integer> for u8
sourcefn rem_trunc(self, rhs: Integer) -> Integer
fn rem_trunc(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: Integer) -> Integer
fn rem_ceil(self, rhs: Integer) -> Integer
Finds the remainder when the quotient is rounded up.
sourceimpl<'i> RemRounding<i128> for &'i Integer
impl<'i> RemRounding<i128> for &'i Integer
type Output = RemRoundingI128Incomplete<'i>
type Output = RemRoundingI128Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: i128) -> RemRoundingI128Incomplete<'i>
fn rem_trunc(self, rhs: i128) -> RemRoundingI128Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: i128) -> RemRoundingI128Incomplete<'i>
fn rem_ceil(self, rhs: i128) -> RemRoundingI128Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<i128> for Integer
impl RemRounding<i128> for Integer
sourceimpl<'i> RemRounding<i16> for &'i Integer
impl<'i> RemRounding<i16> for &'i Integer
type Output = RemRoundingI16Incomplete<'i>
type Output = RemRoundingI16Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: i16) -> RemRoundingI16Incomplete<'i>
fn rem_trunc(self, rhs: i16) -> RemRoundingI16Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: i16) -> RemRoundingI16Incomplete<'i>
fn rem_ceil(self, rhs: i16) -> RemRoundingI16Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<i16> for Integer
impl RemRounding<i16> for Integer
sourceimpl<'i> RemRounding<i32> for &'i Integer
impl<'i> RemRounding<i32> for &'i Integer
type Output = RemRoundingI32Incomplete<'i>
type Output = RemRoundingI32Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: i32) -> RemRoundingI32Incomplete<'i>
fn rem_trunc(self, rhs: i32) -> RemRoundingI32Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: i32) -> RemRoundingI32Incomplete<'i>
fn rem_ceil(self, rhs: i32) -> RemRoundingI32Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<i32> for Integer
impl RemRounding<i32> for Integer
sourceimpl<'i> RemRounding<i64> for &'i Integer
impl<'i> RemRounding<i64> for &'i Integer
type Output = RemRoundingI64Incomplete<'i>
type Output = RemRoundingI64Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: i64) -> RemRoundingI64Incomplete<'i>
fn rem_trunc(self, rhs: i64) -> RemRoundingI64Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: i64) -> RemRoundingI64Incomplete<'i>
fn rem_ceil(self, rhs: i64) -> RemRoundingI64Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<i64> for Integer
impl RemRounding<i64> for Integer
sourceimpl<'i> RemRounding<i8> for &'i Integer
impl<'i> RemRounding<i8> for &'i Integer
type Output = RemRoundingI8Incomplete<'i>
type Output = RemRoundingI8Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: i8) -> RemRoundingI8Incomplete<'i>
fn rem_trunc(self, rhs: i8) -> RemRoundingI8Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: i8) -> RemRoundingI8Incomplete<'i>
fn rem_ceil(self, rhs: i8) -> RemRoundingI8Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<i8> for Integer
impl RemRounding<i8> for Integer
sourceimpl<'i> RemRounding<u128> for &'i Integer
impl<'i> RemRounding<u128> for &'i Integer
type Output = RemRoundingU128Incomplete<'i>
type Output = RemRoundingU128Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: u128) -> RemRoundingU128Incomplete<'i>
fn rem_trunc(self, rhs: u128) -> RemRoundingU128Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: u128) -> RemRoundingU128Incomplete<'i>
fn rem_ceil(self, rhs: u128) -> RemRoundingU128Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<u128> for Integer
impl RemRounding<u128> for Integer
sourceimpl<'i> RemRounding<u16> for &'i Integer
impl<'i> RemRounding<u16> for &'i Integer
type Output = RemRoundingU16Incomplete<'i>
type Output = RemRoundingU16Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: u16) -> RemRoundingU16Incomplete<'i>
fn rem_trunc(self, rhs: u16) -> RemRoundingU16Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: u16) -> RemRoundingU16Incomplete<'i>
fn rem_ceil(self, rhs: u16) -> RemRoundingU16Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<u16> for Integer
impl RemRounding<u16> for Integer
sourceimpl<'i> RemRounding<u32> for &'i Integer
impl<'i> RemRounding<u32> for &'i Integer
type Output = RemRoundingU32Incomplete<'i>
type Output = RemRoundingU32Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: u32) -> RemRoundingU32Incomplete<'i>
fn rem_trunc(self, rhs: u32) -> RemRoundingU32Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: u32) -> RemRoundingU32Incomplete<'i>
fn rem_ceil(self, rhs: u32) -> RemRoundingU32Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<u32> for Integer
impl RemRounding<u32> for Integer
sourceimpl<'i> RemRounding<u64> for &'i Integer
impl<'i> RemRounding<u64> for &'i Integer
type Output = RemRoundingU64Incomplete<'i>
type Output = RemRoundingU64Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: u64) -> RemRoundingU64Incomplete<'i>
fn rem_trunc(self, rhs: u64) -> RemRoundingU64Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: u64) -> RemRoundingU64Incomplete<'i>
fn rem_ceil(self, rhs: u64) -> RemRoundingU64Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<u64> for Integer
impl RemRounding<u64> for Integer
sourceimpl<'i> RemRounding<u8> for &'i Integer
impl<'i> RemRounding<u8> for &'i Integer
type Output = RemRoundingU8Incomplete<'i>
type Output = RemRoundingU8Incomplete<'i>
The resulting type from the remainder operation.
sourcefn rem_trunc(self, rhs: u8) -> RemRoundingU8Incomplete<'i>
fn rem_trunc(self, rhs: u8) -> RemRoundingU8Incomplete<'i>
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil(self, rhs: u8) -> RemRoundingU8Incomplete<'i>
fn rem_ceil(self, rhs: u8) -> RemRoundingU8Incomplete<'i>
Finds the remainder when the quotient is rounded up.
sourceimpl RemRounding<u8> for Integer
impl RemRounding<u8> for Integer
sourceimpl RemRoundingAssign<&Integer> for Integer
impl RemRoundingAssign<&Integer> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: &Integer)
fn rem_trunc_assign(&mut self, rhs: &Integer)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: &Integer)
fn rem_ceil_assign(&mut self, rhs: &Integer)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: &Integer)
fn rem_floor_assign(&mut self, rhs: &Integer)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: &Integer)
fn rem_euc_assign(&mut self, rhs: &Integer)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<&i128> for Integer
impl RemRoundingAssign<&i128> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: &i128)
fn rem_trunc_assign(&mut self, rhs: &i128)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: &i128)
fn rem_ceil_assign(&mut self, rhs: &i128)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: &i128)
fn rem_floor_assign(&mut self, rhs: &i128)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: &i128)
fn rem_euc_assign(&mut self, rhs: &i128)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<&i16> for Integer
impl RemRoundingAssign<&i16> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: &i16)
fn rem_trunc_assign(&mut self, rhs: &i16)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: &i16)
fn rem_ceil_assign(&mut self, rhs: &i16)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: &i16)
fn rem_floor_assign(&mut self, rhs: &i16)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: &i16)
fn rem_euc_assign(&mut self, rhs: &i16)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<&i32> for Integer
impl RemRoundingAssign<&i32> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: &i32)
fn rem_trunc_assign(&mut self, rhs: &i32)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: &i32)
fn rem_ceil_assign(&mut self, rhs: &i32)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: &i32)
fn rem_floor_assign(&mut self, rhs: &i32)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: &i32)
fn rem_euc_assign(&mut self, rhs: &i32)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<&i64> for Integer
impl RemRoundingAssign<&i64> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: &i64)
fn rem_trunc_assign(&mut self, rhs: &i64)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: &i64)
fn rem_ceil_assign(&mut self, rhs: &i64)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: &i64)
fn rem_floor_assign(&mut self, rhs: &i64)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: &i64)
fn rem_euc_assign(&mut self, rhs: &i64)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<&i8> for Integer
impl RemRoundingAssign<&i8> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: &i8)
fn rem_trunc_assign(&mut self, rhs: &i8)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: &i8)
fn rem_ceil_assign(&mut self, rhs: &i8)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: &i8)
fn rem_floor_assign(&mut self, rhs: &i8)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: &i8)
fn rem_euc_assign(&mut self, rhs: &i8)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<&u128> for Integer
impl RemRoundingAssign<&u128> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: &u128)
fn rem_trunc_assign(&mut self, rhs: &u128)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: &u128)
fn rem_ceil_assign(&mut self, rhs: &u128)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: &u128)
fn rem_floor_assign(&mut self, rhs: &u128)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: &u128)
fn rem_euc_assign(&mut self, rhs: &u128)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<&u16> for Integer
impl RemRoundingAssign<&u16> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: &u16)
fn rem_trunc_assign(&mut self, rhs: &u16)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: &u16)
fn rem_ceil_assign(&mut self, rhs: &u16)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: &u16)
fn rem_floor_assign(&mut self, rhs: &u16)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: &u16)
fn rem_euc_assign(&mut self, rhs: &u16)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<&u32> for Integer
impl RemRoundingAssign<&u32> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: &u32)
fn rem_trunc_assign(&mut self, rhs: &u32)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: &u32)
fn rem_ceil_assign(&mut self, rhs: &u32)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: &u32)
fn rem_floor_assign(&mut self, rhs: &u32)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: &u32)
fn rem_euc_assign(&mut self, rhs: &u32)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<&u64> for Integer
impl RemRoundingAssign<&u64> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: &u64)
fn rem_trunc_assign(&mut self, rhs: &u64)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: &u64)
fn rem_ceil_assign(&mut self, rhs: &u64)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: &u64)
fn rem_floor_assign(&mut self, rhs: &u64)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: &u64)
fn rem_euc_assign(&mut self, rhs: &u64)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<&u8> for Integer
impl RemRoundingAssign<&u8> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: &u8)
fn rem_trunc_assign(&mut self, rhs: &u8)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: &u8)
fn rem_ceil_assign(&mut self, rhs: &u8)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: &u8)
fn rem_floor_assign(&mut self, rhs: &u8)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: &u8)
fn rem_euc_assign(&mut self, rhs: &u8)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<Integer> for Integer
impl RemRoundingAssign<Integer> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: Integer)
fn rem_trunc_assign(&mut self, rhs: Integer)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: Integer)
fn rem_ceil_assign(&mut self, rhs: Integer)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: Integer)
fn rem_floor_assign(&mut self, rhs: Integer)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: Integer)
fn rem_euc_assign(&mut self, rhs: Integer)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<i128> for Integer
impl RemRoundingAssign<i128> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: i128)
fn rem_trunc_assign(&mut self, rhs: i128)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: i128)
fn rem_ceil_assign(&mut self, rhs: i128)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: i128)
fn rem_floor_assign(&mut self, rhs: i128)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: i128)
fn rem_euc_assign(&mut self, rhs: i128)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<i16> for Integer
impl RemRoundingAssign<i16> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: i16)
fn rem_trunc_assign(&mut self, rhs: i16)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: i16)
fn rem_ceil_assign(&mut self, rhs: i16)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: i16)
fn rem_floor_assign(&mut self, rhs: i16)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: i16)
fn rem_euc_assign(&mut self, rhs: i16)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<i32> for Integer
impl RemRoundingAssign<i32> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: i32)
fn rem_trunc_assign(&mut self, rhs: i32)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: i32)
fn rem_ceil_assign(&mut self, rhs: i32)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: i32)
fn rem_floor_assign(&mut self, rhs: i32)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: i32)
fn rem_euc_assign(&mut self, rhs: i32)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<i64> for Integer
impl RemRoundingAssign<i64> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: i64)
fn rem_trunc_assign(&mut self, rhs: i64)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: i64)
fn rem_ceil_assign(&mut self, rhs: i64)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: i64)
fn rem_floor_assign(&mut self, rhs: i64)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: i64)
fn rem_euc_assign(&mut self, rhs: i64)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<i8> for Integer
impl RemRoundingAssign<i8> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: i8)
fn rem_trunc_assign(&mut self, rhs: i8)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: i8)
fn rem_ceil_assign(&mut self, rhs: i8)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: i8)
fn rem_floor_assign(&mut self, rhs: i8)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: i8)
fn rem_euc_assign(&mut self, rhs: i8)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<u128> for Integer
impl RemRoundingAssign<u128> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: u128)
fn rem_trunc_assign(&mut self, rhs: u128)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: u128)
fn rem_ceil_assign(&mut self, rhs: u128)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: u128)
fn rem_floor_assign(&mut self, rhs: u128)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: u128)
fn rem_euc_assign(&mut self, rhs: u128)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<u16> for Integer
impl RemRoundingAssign<u16> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: u16)
fn rem_trunc_assign(&mut self, rhs: u16)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: u16)
fn rem_ceil_assign(&mut self, rhs: u16)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: u16)
fn rem_floor_assign(&mut self, rhs: u16)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: u16)
fn rem_euc_assign(&mut self, rhs: u16)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<u32> for Integer
impl RemRoundingAssign<u32> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: u32)
fn rem_trunc_assign(&mut self, rhs: u32)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: u32)
fn rem_ceil_assign(&mut self, rhs: u32)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: u32)
fn rem_floor_assign(&mut self, rhs: u32)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: u32)
fn rem_euc_assign(&mut self, rhs: u32)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<u64> for Integer
impl RemRoundingAssign<u64> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: u64)
fn rem_trunc_assign(&mut self, rhs: u64)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: u64)
fn rem_ceil_assign(&mut self, rhs: u64)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: u64)
fn rem_floor_assign(&mut self, rhs: u64)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: u64)
fn rem_euc_assign(&mut self, rhs: u64)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingAssign<u8> for Integer
impl RemRoundingAssign<u8> for Integer
sourcefn rem_trunc_assign(&mut self, rhs: u8)
fn rem_trunc_assign(&mut self, rhs: u8)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_assign(&mut self, rhs: u8)
fn rem_ceil_assign(&mut self, rhs: u8)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_assign(&mut self, rhs: u8)
fn rem_floor_assign(&mut self, rhs: u8)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_assign(&mut self, rhs: u8)
fn rem_euc_assign(&mut self, rhs: u8)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<&Integer> for Integer
impl RemRoundingFrom<&Integer> for Integer
sourcefn rem_trunc_from(&mut self, lhs: &Integer)
fn rem_trunc_from(&mut self, lhs: &Integer)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: &Integer)
fn rem_ceil_from(&mut self, lhs: &Integer)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: &Integer)
fn rem_floor_from(&mut self, lhs: &Integer)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: &Integer)
fn rem_euc_from(&mut self, lhs: &Integer)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<&i128> for Integer
impl RemRoundingFrom<&i128> for Integer
sourcefn rem_trunc_from(&mut self, lhs: &i128)
fn rem_trunc_from(&mut self, lhs: &i128)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: &i128)
fn rem_ceil_from(&mut self, lhs: &i128)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: &i128)
fn rem_floor_from(&mut self, lhs: &i128)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: &i128)
fn rem_euc_from(&mut self, lhs: &i128)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<&i16> for Integer
impl RemRoundingFrom<&i16> for Integer
sourcefn rem_trunc_from(&mut self, lhs: &i16)
fn rem_trunc_from(&mut self, lhs: &i16)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: &i16)
fn rem_ceil_from(&mut self, lhs: &i16)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: &i16)
fn rem_floor_from(&mut self, lhs: &i16)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: &i16)
fn rem_euc_from(&mut self, lhs: &i16)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<&i32> for Integer
impl RemRoundingFrom<&i32> for Integer
sourcefn rem_trunc_from(&mut self, lhs: &i32)
fn rem_trunc_from(&mut self, lhs: &i32)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: &i32)
fn rem_ceil_from(&mut self, lhs: &i32)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: &i32)
fn rem_floor_from(&mut self, lhs: &i32)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: &i32)
fn rem_euc_from(&mut self, lhs: &i32)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<&i64> for Integer
impl RemRoundingFrom<&i64> for Integer
sourcefn rem_trunc_from(&mut self, lhs: &i64)
fn rem_trunc_from(&mut self, lhs: &i64)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: &i64)
fn rem_ceil_from(&mut self, lhs: &i64)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: &i64)
fn rem_floor_from(&mut self, lhs: &i64)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: &i64)
fn rem_euc_from(&mut self, lhs: &i64)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<&i8> for Integer
impl RemRoundingFrom<&i8> for Integer
sourcefn rem_trunc_from(&mut self, lhs: &i8)
fn rem_trunc_from(&mut self, lhs: &i8)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: &i8)
fn rem_ceil_from(&mut self, lhs: &i8)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: &i8)
fn rem_floor_from(&mut self, lhs: &i8)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: &i8)
fn rem_euc_from(&mut self, lhs: &i8)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<&u128> for Integer
impl RemRoundingFrom<&u128> for Integer
sourcefn rem_trunc_from(&mut self, lhs: &u128)
fn rem_trunc_from(&mut self, lhs: &u128)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: &u128)
fn rem_ceil_from(&mut self, lhs: &u128)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: &u128)
fn rem_floor_from(&mut self, lhs: &u128)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: &u128)
fn rem_euc_from(&mut self, lhs: &u128)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<&u16> for Integer
impl RemRoundingFrom<&u16> for Integer
sourcefn rem_trunc_from(&mut self, lhs: &u16)
fn rem_trunc_from(&mut self, lhs: &u16)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: &u16)
fn rem_ceil_from(&mut self, lhs: &u16)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: &u16)
fn rem_floor_from(&mut self, lhs: &u16)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: &u16)
fn rem_euc_from(&mut self, lhs: &u16)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<&u32> for Integer
impl RemRoundingFrom<&u32> for Integer
sourcefn rem_trunc_from(&mut self, lhs: &u32)
fn rem_trunc_from(&mut self, lhs: &u32)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: &u32)
fn rem_ceil_from(&mut self, lhs: &u32)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: &u32)
fn rem_floor_from(&mut self, lhs: &u32)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: &u32)
fn rem_euc_from(&mut self, lhs: &u32)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<&u64> for Integer
impl RemRoundingFrom<&u64> for Integer
sourcefn rem_trunc_from(&mut self, lhs: &u64)
fn rem_trunc_from(&mut self, lhs: &u64)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: &u64)
fn rem_ceil_from(&mut self, lhs: &u64)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: &u64)
fn rem_floor_from(&mut self, lhs: &u64)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: &u64)
fn rem_euc_from(&mut self, lhs: &u64)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<&u8> for Integer
impl RemRoundingFrom<&u8> for Integer
sourcefn rem_trunc_from(&mut self, lhs: &u8)
fn rem_trunc_from(&mut self, lhs: &u8)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: &u8)
fn rem_ceil_from(&mut self, lhs: &u8)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: &u8)
fn rem_floor_from(&mut self, lhs: &u8)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: &u8)
fn rem_euc_from(&mut self, lhs: &u8)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<Integer> for Integer
impl RemRoundingFrom<Integer> for Integer
sourcefn rem_trunc_from(&mut self, lhs: Integer)
fn rem_trunc_from(&mut self, lhs: Integer)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: Integer)
fn rem_ceil_from(&mut self, lhs: Integer)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: Integer)
fn rem_floor_from(&mut self, lhs: Integer)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: Integer)
fn rem_euc_from(&mut self, lhs: Integer)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<i128> for Integer
impl RemRoundingFrom<i128> for Integer
sourcefn rem_trunc_from(&mut self, lhs: i128)
fn rem_trunc_from(&mut self, lhs: i128)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: i128)
fn rem_ceil_from(&mut self, lhs: i128)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: i128)
fn rem_floor_from(&mut self, lhs: i128)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: i128)
fn rem_euc_from(&mut self, lhs: i128)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<i16> for Integer
impl RemRoundingFrom<i16> for Integer
sourcefn rem_trunc_from(&mut self, lhs: i16)
fn rem_trunc_from(&mut self, lhs: i16)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: i16)
fn rem_ceil_from(&mut self, lhs: i16)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: i16)
fn rem_floor_from(&mut self, lhs: i16)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: i16)
fn rem_euc_from(&mut self, lhs: i16)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<i32> for Integer
impl RemRoundingFrom<i32> for Integer
sourcefn rem_trunc_from(&mut self, lhs: i32)
fn rem_trunc_from(&mut self, lhs: i32)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: i32)
fn rem_ceil_from(&mut self, lhs: i32)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: i32)
fn rem_floor_from(&mut self, lhs: i32)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: i32)
fn rem_euc_from(&mut self, lhs: i32)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<i64> for Integer
impl RemRoundingFrom<i64> for Integer
sourcefn rem_trunc_from(&mut self, lhs: i64)
fn rem_trunc_from(&mut self, lhs: i64)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: i64)
fn rem_ceil_from(&mut self, lhs: i64)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: i64)
fn rem_floor_from(&mut self, lhs: i64)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: i64)
fn rem_euc_from(&mut self, lhs: i64)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<i8> for Integer
impl RemRoundingFrom<i8> for Integer
sourcefn rem_trunc_from(&mut self, lhs: i8)
fn rem_trunc_from(&mut self, lhs: i8)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: i8)
fn rem_ceil_from(&mut self, lhs: i8)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: i8)
fn rem_floor_from(&mut self, lhs: i8)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: i8)
fn rem_euc_from(&mut self, lhs: i8)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<u128> for Integer
impl RemRoundingFrom<u128> for Integer
sourcefn rem_trunc_from(&mut self, lhs: u128)
fn rem_trunc_from(&mut self, lhs: u128)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: u128)
fn rem_ceil_from(&mut self, lhs: u128)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: u128)
fn rem_floor_from(&mut self, lhs: u128)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: u128)
fn rem_euc_from(&mut self, lhs: u128)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<u16> for Integer
impl RemRoundingFrom<u16> for Integer
sourcefn rem_trunc_from(&mut self, lhs: u16)
fn rem_trunc_from(&mut self, lhs: u16)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: u16)
fn rem_ceil_from(&mut self, lhs: u16)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: u16)
fn rem_floor_from(&mut self, lhs: u16)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: u16)
fn rem_euc_from(&mut self, lhs: u16)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<u32> for Integer
impl RemRoundingFrom<u32> for Integer
sourcefn rem_trunc_from(&mut self, lhs: u32)
fn rem_trunc_from(&mut self, lhs: u32)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: u32)
fn rem_ceil_from(&mut self, lhs: u32)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: u32)
fn rem_floor_from(&mut self, lhs: u32)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: u32)
fn rem_euc_from(&mut self, lhs: u32)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<u64> for Integer
impl RemRoundingFrom<u64> for Integer
sourcefn rem_trunc_from(&mut self, lhs: u64)
fn rem_trunc_from(&mut self, lhs: u64)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: u64)
fn rem_ceil_from(&mut self, lhs: u64)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: u64)
fn rem_floor_from(&mut self, lhs: u64)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: u64)
fn rem_euc_from(&mut self, lhs: u64)
Finds the positive remainder from Euclidean division.
sourceimpl RemRoundingFrom<u8> for Integer
impl RemRoundingFrom<u8> for Integer
sourcefn rem_trunc_from(&mut self, lhs: u8)
fn rem_trunc_from(&mut self, lhs: u8)
Finds the remainder when the quotient is rounded towards zero.
sourcefn rem_ceil_from(&mut self, lhs: u8)
fn rem_ceil_from(&mut self, lhs: u8)
Finds the remainder when the quotient is rounded up.
sourcefn rem_floor_from(&mut self, lhs: u8)
fn rem_floor_from(&mut self, lhs: u8)
Finds the remainder when the quotient is rounded down.
sourcefn rem_euc_from(&mut self, lhs: u8)
fn rem_euc_from(&mut self, lhs: u8)
Finds the positive remainder from Euclidean division.
sourceimpl Roots for Integer
impl Roots for Integer
sourceimpl SaturatingCast<i128> for &Integer
impl SaturatingCast<i128> for &Integer
sourcefn saturating_cast(self) -> i128
fn saturating_cast(self) -> i128
Casts the value.
sourceimpl SaturatingCast<i128> for Integer
impl SaturatingCast<i128> for Integer
sourcefn saturating_cast(self) -> i128
fn saturating_cast(self) -> i128
Casts the value.
sourceimpl SaturatingCast<i16> for &Integer
impl SaturatingCast<i16> for &Integer
sourcefn saturating_cast(self) -> i16
fn saturating_cast(self) -> i16
Casts the value.
sourceimpl SaturatingCast<i16> for Integer
impl SaturatingCast<i16> for Integer
sourcefn saturating_cast(self) -> i16
fn saturating_cast(self) -> i16
Casts the value.
sourceimpl SaturatingCast<i32> for &Integer
impl SaturatingCast<i32> for &Integer
sourcefn saturating_cast(self) -> i32
fn saturating_cast(self) -> i32
Casts the value.
sourceimpl SaturatingCast<i32> for Integer
impl SaturatingCast<i32> for Integer
sourcefn saturating_cast(self) -> i32
fn saturating_cast(self) -> i32
Casts the value.
sourceimpl SaturatingCast<i64> for &Integer
impl SaturatingCast<i64> for &Integer
sourcefn saturating_cast(self) -> i64
fn saturating_cast(self) -> i64
Casts the value.
sourceimpl SaturatingCast<i64> for Integer
impl SaturatingCast<i64> for Integer
sourcefn saturating_cast(self) -> i64
fn saturating_cast(self) -> i64
Casts the value.
sourceimpl SaturatingCast<i8> for &Integer
impl SaturatingCast<i8> for &Integer
sourcefn saturating_cast(self) -> i8
fn saturating_cast(self) -> i8
Casts the value.
sourceimpl SaturatingCast<i8> for Integer
impl SaturatingCast<i8> for Integer
sourcefn saturating_cast(self) -> i8
fn saturating_cast(self) -> i8
Casts the value.
sourceimpl SaturatingCast<isize> for &Integer
impl SaturatingCast<isize> for &Integer
sourcefn saturating_cast(self) -> isize
fn saturating_cast(self) -> isize
Casts the value.
sourceimpl SaturatingCast<isize> for Integer
impl SaturatingCast<isize> for Integer
sourcefn saturating_cast(self) -> isize
fn saturating_cast(self) -> isize
Casts the value.
sourceimpl SaturatingCast<u128> for &Integer
impl SaturatingCast<u128> for &Integer
sourcefn saturating_cast(self) -> u128
fn saturating_cast(self) -> u128
Casts the value.
sourceimpl SaturatingCast<u128> for Integer
impl SaturatingCast<u128> for Integer
sourcefn saturating_cast(self) -> u128
fn saturating_cast(self) -> u128
Casts the value.
sourceimpl SaturatingCast<u16> for &Integer
impl SaturatingCast<u16> for &Integer
sourcefn saturating_cast(self) -> u16
fn saturating_cast(self) -> u16
Casts the value.
sourceimpl SaturatingCast<u16> for Integer
impl SaturatingCast<u16> for Integer
sourcefn saturating_cast(self) -> u16
fn saturating_cast(self) -> u16
Casts the value.
sourceimpl SaturatingCast<u32> for &Integer
impl SaturatingCast<u32> for &Integer
sourcefn saturating_cast(self) -> u32
fn saturating_cast(self) -> u32
Casts the value.
sourceimpl SaturatingCast<u32> for Integer
impl SaturatingCast<u32> for Integer
sourcefn saturating_cast(self) -> u32
fn saturating_cast(self) -> u32
Casts the value.
sourceimpl SaturatingCast<u64> for &Integer
impl SaturatingCast<u64> for &Integer
sourcefn saturating_cast(self) -> u64
fn saturating_cast(self) -> u64
Casts the value.
sourceimpl SaturatingCast<u64> for Integer
impl SaturatingCast<u64> for Integer
sourcefn saturating_cast(self) -> u64
fn saturating_cast(self) -> u64
Casts the value.
sourceimpl SaturatingCast<u8> for &Integer
impl SaturatingCast<u8> for &Integer
sourcefn saturating_cast(self) -> u8
fn saturating_cast(self) -> u8
Casts the value.
sourceimpl SaturatingCast<u8> for Integer
impl SaturatingCast<u8> for Integer
sourcefn saturating_cast(self) -> u8
fn saturating_cast(self) -> u8
Casts the value.
sourceimpl SaturatingCast<usize> for &Integer
impl SaturatingCast<usize> for &Integer
sourcefn saturating_cast(self) -> usize
fn saturating_cast(self) -> usize
Casts the value.
sourceimpl SaturatingCast<usize> for Integer
impl SaturatingCast<usize> for Integer
sourcefn saturating_cast(self) -> usize
fn saturating_cast(self) -> usize
Casts the value.
sourceimpl ShlAssign<&i32> for Integer
impl ShlAssign<&i32> for Integer
sourcefn shl_assign(&mut self, rhs: &i32)
fn shl_assign(&mut self, rhs: &i32)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<&isize> for Integer
impl ShlAssign<&isize> for Integer
sourcefn shl_assign(&mut self, rhs: &isize)
fn shl_assign(&mut self, rhs: &isize)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<&u32> for Integer
impl ShlAssign<&u32> for Integer
sourcefn shl_assign(&mut self, rhs: &u32)
fn shl_assign(&mut self, rhs: &u32)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<&usize> for Integer
impl ShlAssign<&usize> for Integer
sourcefn shl_assign(&mut self, rhs: &usize)
fn shl_assign(&mut self, rhs: &usize)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<i32> for Integer
impl ShlAssign<i32> for Integer
sourcefn shl_assign(&mut self, rhs: i32)
fn shl_assign(&mut self, rhs: i32)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<isize> for Integer
impl ShlAssign<isize> for Integer
sourcefn shl_assign(&mut self, rhs: isize)
fn shl_assign(&mut self, rhs: isize)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<u32> for Integer
impl ShlAssign<u32> for Integer
sourcefn shl_assign(&mut self, rhs: u32)
fn shl_assign(&mut self, rhs: u32)
Performs the <<=
operation. Read more
sourceimpl ShlAssign<usize> for Integer
impl ShlAssign<usize> for Integer
sourcefn shl_assign(&mut self, rhs: usize)
fn shl_assign(&mut self, rhs: usize)
Performs the <<=
operation. Read more
sourceimpl ShrAssign<&i32> for Integer
impl ShrAssign<&i32> for Integer
sourcefn shr_assign(&mut self, rhs: &i32)
fn shr_assign(&mut self, rhs: &i32)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<&isize> for Integer
impl ShrAssign<&isize> for Integer
sourcefn shr_assign(&mut self, rhs: &isize)
fn shr_assign(&mut self, rhs: &isize)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<&u32> for Integer
impl ShrAssign<&u32> for Integer
sourcefn shr_assign(&mut self, rhs: &u32)
fn shr_assign(&mut self, rhs: &u32)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<&usize> for Integer
impl ShrAssign<&usize> for Integer
sourcefn shr_assign(&mut self, rhs: &usize)
fn shr_assign(&mut self, rhs: &usize)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<i32> for Integer
impl ShrAssign<i32> for Integer
sourcefn shr_assign(&mut self, rhs: i32)
fn shr_assign(&mut self, rhs: i32)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<isize> for Integer
impl ShrAssign<isize> for Integer
sourcefn shr_assign(&mut self, rhs: isize)
fn shr_assign(&mut self, rhs: isize)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<u32> for Integer
impl ShrAssign<u32> for Integer
sourcefn shr_assign(&mut self, rhs: u32)
fn shr_assign(&mut self, rhs: u32)
Performs the >>=
operation. Read more
sourceimpl ShrAssign<usize> for Integer
impl ShrAssign<usize> for Integer
sourcefn shr_assign(&mut self, rhs: usize)
fn shr_assign(&mut self, rhs: usize)
Performs the >>=
operation. Read more
sourceimpl Signed for Integer
impl Signed for Integer
sourcefn is_positive(&self) -> bool
fn is_positive(&self) -> bool
Returns true if the number is positive and false if the number is zero or negative.
sourcefn is_negative(&self) -> bool
fn is_negative(&self) -> bool
Returns true if the number is negative and false if the number is zero or positive.
sourceimpl SubAssign<&Integer> for Complex
impl SubAssign<&Integer> for Complex
sourcefn sub_assign(&mut self, rhs: &Integer)
fn sub_assign(&mut self, rhs: &Integer)
Performs the -=
operation. Read more
sourceimpl SubAssign<&Integer> for Float
impl SubAssign<&Integer> for Float
sourcefn sub_assign(&mut self, rhs: &Integer)
fn sub_assign(&mut self, rhs: &Integer)
Performs the -=
operation. Read more
sourceimpl SubAssign<&Integer> for Integer
impl SubAssign<&Integer> for Integer
sourcefn sub_assign(&mut self, rhs: &Integer)
fn sub_assign(&mut self, rhs: &Integer)
Performs the -=
operation. Read more
sourceimpl SubAssign<&Integer> for Rational
impl SubAssign<&Integer> for Rational
sourcefn sub_assign(&mut self, rhs: &Integer)
fn sub_assign(&mut self, rhs: &Integer)
Performs the -=
operation. Read more
sourceimpl SubAssign<&i128> for Integer
impl SubAssign<&i128> for Integer
sourcefn sub_assign(&mut self, rhs: &i128)
fn sub_assign(&mut self, rhs: &i128)
Performs the -=
operation. Read more
sourceimpl SubAssign<&i16> for Integer
impl SubAssign<&i16> for Integer
sourcefn sub_assign(&mut self, rhs: &i16)
fn sub_assign(&mut self, rhs: &i16)
Performs the -=
operation. Read more
sourceimpl SubAssign<&i32> for Integer
impl SubAssign<&i32> for Integer
sourcefn sub_assign(&mut self, rhs: &i32)
fn sub_assign(&mut self, rhs: &i32)
Performs the -=
operation. Read more
sourceimpl SubAssign<&i64> for Integer
impl SubAssign<&i64> for Integer
sourcefn sub_assign(&mut self, rhs: &i64)
fn sub_assign(&mut self, rhs: &i64)
Performs the -=
operation. Read more
sourceimpl SubAssign<&i8> for Integer
impl SubAssign<&i8> for Integer
sourcefn sub_assign(&mut self, rhs: &i8)
fn sub_assign(&mut self, rhs: &i8)
Performs the -=
operation. Read more
sourceimpl SubAssign<&isize> for Integer
impl SubAssign<&isize> for Integer
sourcefn sub_assign(&mut self, rhs: &isize)
fn sub_assign(&mut self, rhs: &isize)
Performs the -=
operation. Read more
sourceimpl SubAssign<&u128> for Integer
impl SubAssign<&u128> for Integer
sourcefn sub_assign(&mut self, rhs: &u128)
fn sub_assign(&mut self, rhs: &u128)
Performs the -=
operation. Read more
sourceimpl SubAssign<&u16> for Integer
impl SubAssign<&u16> for Integer
sourcefn sub_assign(&mut self, rhs: &u16)
fn sub_assign(&mut self, rhs: &u16)
Performs the -=
operation. Read more
sourceimpl SubAssign<&u32> for Integer
impl SubAssign<&u32> for Integer
sourcefn sub_assign(&mut self, rhs: &u32)
fn sub_assign(&mut self, rhs: &u32)
Performs the -=
operation. Read more
sourceimpl SubAssign<&u64> for Integer
impl SubAssign<&u64> for Integer
sourcefn sub_assign(&mut self, rhs: &u64)
fn sub_assign(&mut self, rhs: &u64)
Performs the -=
operation. Read more
sourceimpl SubAssign<&u8> for Integer
impl SubAssign<&u8> for Integer
sourcefn sub_assign(&mut self, rhs: &u8)
fn sub_assign(&mut self, rhs: &u8)
Performs the -=
operation. Read more
sourceimpl SubAssign<&usize> for Integer
impl SubAssign<&usize> for Integer
sourcefn sub_assign(&mut self, rhs: &usize)
fn sub_assign(&mut self, rhs: &usize)
Performs the -=
operation. Read more
sourceimpl SubAssign<Integer> for Complex
impl SubAssign<Integer> for Complex
sourcefn sub_assign(&mut self, rhs: Integer)
fn sub_assign(&mut self, rhs: Integer)
Performs the -=
operation. Read more
sourceimpl SubAssign<Integer> for Float
impl SubAssign<Integer> for Float
sourcefn sub_assign(&mut self, rhs: Integer)
fn sub_assign(&mut self, rhs: Integer)
Performs the -=
operation. Read more
sourceimpl SubAssign<Integer> for Integer
impl SubAssign<Integer> for Integer
sourcefn sub_assign(&mut self, rhs: Integer)
fn sub_assign(&mut self, rhs: Integer)
Performs the -=
operation. Read more
sourceimpl SubAssign<Integer> for Rational
impl SubAssign<Integer> for Rational
sourcefn sub_assign(&mut self, rhs: Integer)
fn sub_assign(&mut self, rhs: Integer)
Performs the -=
operation. Read more
sourceimpl SubAssign<i128> for Integer
impl SubAssign<i128> for Integer
sourcefn sub_assign(&mut self, rhs: i128)
fn sub_assign(&mut self, rhs: i128)
Performs the -=
operation. Read more
sourceimpl SubAssign<i16> for Integer
impl SubAssign<i16> for Integer
sourcefn sub_assign(&mut self, rhs: i16)
fn sub_assign(&mut self, rhs: i16)
Performs the -=
operation. Read more
sourceimpl SubAssign<i32> for Integer
impl SubAssign<i32> for Integer
sourcefn sub_assign(&mut self, rhs: i32)
fn sub_assign(&mut self, rhs: i32)
Performs the -=
operation. Read more
sourceimpl SubAssign<i64> for Integer
impl SubAssign<i64> for Integer
sourcefn sub_assign(&mut self, rhs: i64)
fn sub_assign(&mut self, rhs: i64)
Performs the -=
operation. Read more
sourceimpl SubAssign<i8> for Integer
impl SubAssign<i8> for Integer
sourcefn sub_assign(&mut self, rhs: i8)
fn sub_assign(&mut self, rhs: i8)
Performs the -=
operation. Read more
sourceimpl SubAssign<isize> for Integer
impl SubAssign<isize> for Integer
sourcefn sub_assign(&mut self, rhs: isize)
fn sub_assign(&mut self, rhs: isize)
Performs the -=
operation. Read more
sourceimpl SubAssign<u128> for Integer
impl SubAssign<u128> for Integer
sourcefn sub_assign(&mut self, rhs: u128)
fn sub_assign(&mut self, rhs: u128)
Performs the -=
operation. Read more
sourceimpl SubAssign<u16> for Integer
impl SubAssign<u16> for Integer
sourcefn sub_assign(&mut self, rhs: u16)
fn sub_assign(&mut self, rhs: u16)
Performs the -=
operation. Read more
sourceimpl SubAssign<u32> for Integer
impl SubAssign<u32> for Integer
sourcefn sub_assign(&mut self, rhs: u32)
fn sub_assign(&mut self, rhs: u32)
Performs the -=
operation. Read more
sourceimpl SubAssign<u64> for Integer
impl SubAssign<u64> for Integer
sourcefn sub_assign(&mut self, rhs: u64)
fn sub_assign(&mut self, rhs: u64)
Performs the -=
operation. Read more
sourceimpl SubAssign<u8> for Integer
impl SubAssign<u8> for Integer
sourcefn sub_assign(&mut self, rhs: u8)
fn sub_assign(&mut self, rhs: u8)
Performs the -=
operation. Read more
sourceimpl SubAssign<usize> for Integer
impl SubAssign<usize> for Integer
sourcefn sub_assign(&mut self, rhs: usize)
fn sub_assign(&mut self, rhs: usize)
Performs the -=
operation. Read more
sourceimpl SubAssignRound<&Integer> for Complex
impl SubAssignRound<&Integer> for Complex
sourceimpl SubAssignRound<&Integer> for Float
impl SubAssignRound<&Integer> for Float
sourceimpl SubAssignRound<Integer> for Complex
impl SubAssignRound<Integer> for Complex
sourceimpl SubAssignRound<Integer> for Float
impl SubAssignRound<Integer> for Float
sourceimpl SubFromRound<&Integer> for Complex
impl SubFromRound<&Integer> for Complex
sourceimpl SubFromRound<&Integer> for Float
impl SubFromRound<&Integer> for Float
sourceimpl SubFromRound<Integer> for Complex
impl SubFromRound<Integer> for Complex
sourceimpl SubFromRound<Integer> for Float
impl SubFromRound<Integer> for Float
sourceimpl ToPrimitive for Integer
impl ToPrimitive for Integer
sourcefn to_i64(&self) -> Option<i64>
fn to_i64(&self) -> Option<i64>
Converts the value of self
to an i64
. If the value cannot be
represented by an i64
, then None
is returned. Read more
sourcefn to_u64(&self) -> Option<u64>
fn to_u64(&self) -> Option<u64>
Converts the value of self
to a u64
. If the value cannot be
represented by a u64
, then None
is returned. Read more
sourcefn to_isize(&self) -> Option<isize>
fn to_isize(&self) -> Option<isize>
Converts the value of self
to an isize
. If the value cannot be
represented by an isize
, then None
is returned. Read more
sourcefn to_i8(&self) -> Option<i8>
fn to_i8(&self) -> Option<i8>
Converts the value of self
to an i8
. If the value cannot be
represented by an i8
, then None
is returned. Read more
sourcefn to_i16(&self) -> Option<i16>
fn to_i16(&self) -> Option<i16>
Converts the value of self
to an i16
. If the value cannot be
represented by an i16
, then None
is returned. Read more
sourcefn to_i32(&self) -> Option<i32>
fn to_i32(&self) -> Option<i32>
Converts the value of self
to an i32
. If the value cannot be
represented by an i32
, then None
is returned. Read more
sourcefn to_i128(&self) -> Option<i128>
fn to_i128(&self) -> Option<i128>
Converts the value of self
to an i128
. If the value cannot be
represented by an i128
(i64
under the default implementation), then
None
is returned. Read more
sourcefn to_usize(&self) -> Option<usize>
fn to_usize(&self) -> Option<usize>
Converts the value of self
to a usize
. If the value cannot be
represented by a usize
, then None
is returned. Read more
sourcefn to_u8(&self) -> Option<u8>
fn to_u8(&self) -> Option<u8>
Converts the value of self
to a u8
. If the value cannot be
represented by a u8
, then None
is returned. Read more
sourcefn to_u16(&self) -> Option<u16>
fn to_u16(&self) -> Option<u16>
Converts the value of self
to a u16
. If the value cannot be
represented by a u16
, then None
is returned. Read more
sourcefn to_u32(&self) -> Option<u32>
fn to_u32(&self) -> Option<u32>
Converts the value of self
to a u32
. If the value cannot be
represented by a u32
, then None
is returned. Read more
sourcefn to_u128(&self) -> Option<u128>
fn to_u128(&self) -> Option<u128>
Converts the value of self
to a u128
. If the value cannot be
represented by a u128
(u64
under the default implementation), then
None
is returned. Read more
sourceimpl TryFrom<&Integer> for i128
impl TryFrom<&Integer> for i128
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<&Integer> for i16
impl TryFrom<&Integer> for i16
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<&Integer> for i32
impl TryFrom<&Integer> for i32
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<&Integer> for i64
impl TryFrom<&Integer> for i64
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<&Integer> for i8
impl TryFrom<&Integer> for i8
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<&Integer> for isize
impl TryFrom<&Integer> for isize
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<&Integer> for u128
impl TryFrom<&Integer> for u128
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<&Integer> for u16
impl TryFrom<&Integer> for u16
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<&Integer> for u32
impl TryFrom<&Integer> for u32
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<&Integer> for u64
impl TryFrom<&Integer> for u64
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<&Integer> for u8
impl TryFrom<&Integer> for u8
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<&Integer> for usize
impl TryFrom<&Integer> for usize
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: &Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for i128
impl TryFrom<Integer> for i128
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for i16
impl TryFrom<Integer> for i16
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for i32
impl TryFrom<Integer> for i32
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for i64
impl TryFrom<Integer> for i64
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for i8
impl TryFrom<Integer> for i8
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for isize
impl TryFrom<Integer> for isize
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for u128
impl TryFrom<Integer> for u128
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for u16
impl TryFrom<Integer> for u16
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for u32
impl TryFrom<Integer> for u32
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for u64
impl TryFrom<Integer> for u64
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for u8
impl TryFrom<Integer> for u8
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl TryFrom<Integer> for usize
impl TryFrom<Integer> for usize
type Error = TryFromIntegerError
type Error = TryFromIntegerError
The type returned in the event of a conversion error.
sourcefn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
fn try_from(value: Integer) -> Result<Self, TryFromIntegerError>
Performs the conversion.
sourceimpl UnwrappedCast<Integer> for &Float
impl UnwrappedCast<Integer> for &Float
sourcefn unwrapped_cast(self) -> Integer
fn unwrapped_cast(self) -> Integer
Casts the value.
sourceimpl UnwrappedCast<Integer> for Float
impl UnwrappedCast<Integer> for Float
sourcefn unwrapped_cast(self) -> Integer
fn unwrapped_cast(self) -> Integer
Casts the value.
sourceimpl UnwrappedCast<Integer> for Round<f32>
impl UnwrappedCast<Integer> for Round<f32>
sourcefn unwrapped_cast(self) -> Integer
fn unwrapped_cast(self) -> Integer
Casts the value.
sourceimpl UnwrappedCast<Integer> for Round<f64>
impl UnwrappedCast<Integer> for Round<f64>
sourcefn unwrapped_cast(self) -> Integer
fn unwrapped_cast(self) -> Integer
Casts the value.
sourceimpl UnwrappedCast<Integer> for f32
impl UnwrappedCast<Integer> for f32
sourcefn unwrapped_cast(self) -> Integer
fn unwrapped_cast(self) -> Integer
Casts the value.
sourceimpl UnwrappedCast<Integer> for f64
impl UnwrappedCast<Integer> for f64
sourcefn unwrapped_cast(self) -> Integer
fn unwrapped_cast(self) -> Integer
Casts the value.
sourceimpl UnwrappedCast<i128> for &Integer
impl UnwrappedCast<i128> for &Integer
sourcefn unwrapped_cast(self) -> i128
fn unwrapped_cast(self) -> i128
Casts the value.
sourceimpl UnwrappedCast<i128> for Integer
impl UnwrappedCast<i128> for Integer
sourcefn unwrapped_cast(self) -> i128
fn unwrapped_cast(self) -> i128
Casts the value.
sourceimpl UnwrappedCast<i16> for &Integer
impl UnwrappedCast<i16> for &Integer
sourcefn unwrapped_cast(self) -> i16
fn unwrapped_cast(self) -> i16
Casts the value.
sourceimpl UnwrappedCast<i16> for Integer
impl UnwrappedCast<i16> for Integer
sourcefn unwrapped_cast(self) -> i16
fn unwrapped_cast(self) -> i16
Casts the value.
sourceimpl UnwrappedCast<i32> for &Integer
impl UnwrappedCast<i32> for &Integer
sourcefn unwrapped_cast(self) -> i32
fn unwrapped_cast(self) -> i32
Casts the value.
sourceimpl UnwrappedCast<i32> for Integer
impl UnwrappedCast<i32> for Integer
sourcefn unwrapped_cast(self) -> i32
fn unwrapped_cast(self) -> i32
Casts the value.
sourceimpl UnwrappedCast<i64> for &Integer
impl UnwrappedCast<i64> for &Integer
sourcefn unwrapped_cast(self) -> i64
fn unwrapped_cast(self) -> i64
Casts the value.
sourceimpl UnwrappedCast<i64> for Integer
impl UnwrappedCast<i64> for Integer
sourcefn unwrapped_cast(self) -> i64
fn unwrapped_cast(self) -> i64
Casts the value.
sourceimpl UnwrappedCast<i8> for &Integer
impl UnwrappedCast<i8> for &Integer
sourcefn unwrapped_cast(self) -> i8
fn unwrapped_cast(self) -> i8
Casts the value.
sourceimpl UnwrappedCast<i8> for Integer
impl UnwrappedCast<i8> for Integer
sourcefn unwrapped_cast(self) -> i8
fn unwrapped_cast(self) -> i8
Casts the value.
sourceimpl UnwrappedCast<isize> for &Integer
impl UnwrappedCast<isize> for &Integer
sourcefn unwrapped_cast(self) -> isize
fn unwrapped_cast(self) -> isize
Casts the value.
sourceimpl UnwrappedCast<isize> for Integer
impl UnwrappedCast<isize> for Integer
sourcefn unwrapped_cast(self) -> isize
fn unwrapped_cast(self) -> isize
Casts the value.
sourceimpl UnwrappedCast<u128> for &Integer
impl UnwrappedCast<u128> for &Integer
sourcefn unwrapped_cast(self) -> u128
fn unwrapped_cast(self) -> u128
Casts the value.
sourceimpl UnwrappedCast<u128> for Integer
impl UnwrappedCast<u128> for Integer
sourcefn unwrapped_cast(self) -> u128
fn unwrapped_cast(self) -> u128
Casts the value.
sourceimpl UnwrappedCast<u16> for &Integer
impl UnwrappedCast<u16> for &Integer
sourcefn unwrapped_cast(self) -> u16
fn unwrapped_cast(self) -> u16
Casts the value.
sourceimpl UnwrappedCast<u16> for Integer
impl UnwrappedCast<u16> for Integer
sourcefn unwrapped_cast(self) -> u16
fn unwrapped_cast(self) -> u16
Casts the value.
sourceimpl UnwrappedCast<u32> for &Integer
impl UnwrappedCast<u32> for &Integer
sourcefn unwrapped_cast(self) -> u32
fn unwrapped_cast(self) -> u32
Casts the value.
sourceimpl UnwrappedCast<u32> for Integer
impl UnwrappedCast<u32> for Integer
sourcefn unwrapped_cast(self) -> u32
fn unwrapped_cast(self) -> u32
Casts the value.
sourceimpl UnwrappedCast<u64> for &Integer
impl UnwrappedCast<u64> for &Integer
sourcefn unwrapped_cast(self) -> u64
fn unwrapped_cast(self) -> u64
Casts the value.
sourceimpl UnwrappedCast<u64> for Integer
impl UnwrappedCast<u64> for Integer
sourcefn unwrapped_cast(self) -> u64
fn unwrapped_cast(self) -> u64
Casts the value.
sourceimpl UnwrappedCast<u8> for &Integer
impl UnwrappedCast<u8> for &Integer
sourcefn unwrapped_cast(self) -> u8
fn unwrapped_cast(self) -> u8
Casts the value.
sourceimpl UnwrappedCast<u8> for Integer
impl UnwrappedCast<u8> for Integer
sourcefn unwrapped_cast(self) -> u8
fn unwrapped_cast(self) -> u8
Casts the value.
sourceimpl UnwrappedCast<usize> for &Integer
impl UnwrappedCast<usize> for &Integer
sourcefn unwrapped_cast(self) -> usize
fn unwrapped_cast(self) -> usize
Casts the value.
sourceimpl UnwrappedCast<usize> for Integer
impl UnwrappedCast<usize> for Integer
sourcefn unwrapped_cast(self) -> usize
fn unwrapped_cast(self) -> usize
Casts the value.
sourceimpl WrappingCast<i128> for &Integer
impl WrappingCast<i128> for &Integer
sourcefn wrapping_cast(self) -> i128
fn wrapping_cast(self) -> i128
Casts the value.
sourceimpl WrappingCast<i128> for Integer
impl WrappingCast<i128> for Integer
sourcefn wrapping_cast(self) -> i128
fn wrapping_cast(self) -> i128
Casts the value.
sourceimpl WrappingCast<i16> for &Integer
impl WrappingCast<i16> for &Integer
sourcefn wrapping_cast(self) -> i16
fn wrapping_cast(self) -> i16
Casts the value.
sourceimpl WrappingCast<i16> for Integer
impl WrappingCast<i16> for Integer
sourcefn wrapping_cast(self) -> i16
fn wrapping_cast(self) -> i16
Casts the value.
sourceimpl WrappingCast<i32> for &Integer
impl WrappingCast<i32> for &Integer
sourcefn wrapping_cast(self) -> i32
fn wrapping_cast(self) -> i32
Casts the value.
sourceimpl WrappingCast<i32> for Integer
impl WrappingCast<i32> for Integer
sourcefn wrapping_cast(self) -> i32
fn wrapping_cast(self) -> i32
Casts the value.
sourceimpl WrappingCast<i64> for &Integer
impl WrappingCast<i64> for &Integer
sourcefn wrapping_cast(self) -> i64
fn wrapping_cast(self) -> i64
Casts the value.
sourceimpl WrappingCast<i64> for Integer
impl WrappingCast<i64> for Integer
sourcefn wrapping_cast(self) -> i64
fn wrapping_cast(self) -> i64
Casts the value.
sourceimpl WrappingCast<i8> for &Integer
impl WrappingCast<i8> for &Integer
sourcefn wrapping_cast(self) -> i8
fn wrapping_cast(self) -> i8
Casts the value.
sourceimpl WrappingCast<i8> for Integer
impl WrappingCast<i8> for Integer
sourcefn wrapping_cast(self) -> i8
fn wrapping_cast(self) -> i8
Casts the value.
sourceimpl WrappingCast<isize> for &Integer
impl WrappingCast<isize> for &Integer
sourcefn wrapping_cast(self) -> isize
fn wrapping_cast(self) -> isize
Casts the value.
sourceimpl WrappingCast<isize> for Integer
impl WrappingCast<isize> for Integer
sourcefn wrapping_cast(self) -> isize
fn wrapping_cast(self) -> isize
Casts the value.
sourceimpl WrappingCast<u128> for &Integer
impl WrappingCast<u128> for &Integer
sourcefn wrapping_cast(self) -> u128
fn wrapping_cast(self) -> u128
Casts the value.
sourceimpl WrappingCast<u128> for Integer
impl WrappingCast<u128> for Integer
sourcefn wrapping_cast(self) -> u128
fn wrapping_cast(self) -> u128
Casts the value.
sourceimpl WrappingCast<u16> for &Integer
impl WrappingCast<u16> for &Integer
sourcefn wrapping_cast(self) -> u16
fn wrapping_cast(self) -> u16
Casts the value.
sourceimpl WrappingCast<u16> for Integer
impl WrappingCast<u16> for Integer
sourcefn wrapping_cast(self) -> u16
fn wrapping_cast(self) -> u16
Casts the value.
sourceimpl WrappingCast<u32> for &Integer
impl WrappingCast<u32> for &Integer
sourcefn wrapping_cast(self) -> u32
fn wrapping_cast(self) -> u32
Casts the value.
sourceimpl WrappingCast<u32> for Integer
impl WrappingCast<u32> for Integer
sourcefn wrapping_cast(self) -> u32
fn wrapping_cast(self) -> u32
Casts the value.
sourceimpl WrappingCast<u64> for &Integer
impl WrappingCast<u64> for &Integer
sourcefn wrapping_cast(self) -> u64
fn wrapping_cast(self) -> u64
Casts the value.
sourceimpl WrappingCast<u64> for Integer
impl WrappingCast<u64> for Integer
sourcefn wrapping_cast(self) -> u64
fn wrapping_cast(self) -> u64
Casts the value.
sourceimpl WrappingCast<u8> for &Integer
impl WrappingCast<u8> for &Integer
sourcefn wrapping_cast(self) -> u8
fn wrapping_cast(self) -> u8
Casts the value.
sourceimpl WrappingCast<u8> for Integer
impl WrappingCast<u8> for Integer
sourcefn wrapping_cast(self) -> u8
fn wrapping_cast(self) -> u8
Casts the value.
sourceimpl WrappingCast<usize> for &Integer
impl WrappingCast<usize> for &Integer
sourcefn wrapping_cast(self) -> usize
fn wrapping_cast(self) -> usize
Casts the value.
sourceimpl WrappingCast<usize> for Integer
impl WrappingCast<usize> for Integer
sourcefn wrapping_cast(self) -> usize
fn wrapping_cast(self) -> usize
Casts the value.
impl Eq for Integer
impl Send for Integer
impl Sync for Integer
Auto Trait Implementations
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> CheckedAs for T
impl<T> CheckedAs for T
sourcefn checked_as<Dst>(self) -> Option<Dst> where
T: CheckedCast<Dst>,
fn checked_as<Dst>(self) -> Option<Dst> where
T: CheckedCast<Dst>,
Casts the value.
sourceimpl<Src, Dst> CheckedCastFrom<Src> for Dst where
Src: CheckedCast<Dst>,
impl<Src, Dst> CheckedCastFrom<Src> for Dst where
Src: CheckedCast<Dst>,
sourcefn checked_cast_from(src: Src) -> Option<Dst>
fn checked_cast_from(src: Src) -> Option<Dst>
Casts the value.
sourceimpl<T> OverflowingAs for T
impl<T> OverflowingAs for T
sourcefn overflowing_as<Dst>(self) -> (Dst, bool) where
T: OverflowingCast<Dst>,
fn overflowing_as<Dst>(self) -> (Dst, bool) where
T: OverflowingCast<Dst>,
Casts the value.
sourceimpl<Src, Dst> OverflowingCastFrom<Src> for Dst where
Src: OverflowingCast<Dst>,
impl<Src, Dst> OverflowingCastFrom<Src> for Dst where
Src: OverflowingCast<Dst>,
sourcefn overflowing_cast_from(src: Src) -> (Dst, bool)
fn overflowing_cast_from(src: Src) -> (Dst, bool)
Casts the value.
sourceimpl<T> SaturatingAs for T
impl<T> SaturatingAs for T
sourcefn saturating_as<Dst>(self) -> Dst where
T: SaturatingCast<Dst>,
fn saturating_as<Dst>(self) -> Dst where
T: SaturatingCast<Dst>,
Casts the value.
sourceimpl<Src, Dst> SaturatingCastFrom<Src> for Dst where
Src: SaturatingCast<Dst>,
impl<Src, Dst> SaturatingCastFrom<Src> for Dst where
Src: SaturatingCast<Dst>,
sourcefn saturating_cast_from(src: Src) -> Dst
fn saturating_cast_from(src: Src) -> Dst
Casts the value.
sourceimpl<T> UnwrappedAs for T
impl<T> UnwrappedAs for T
sourcefn unwrapped_as<Dst>(self) -> Dst where
T: UnwrappedCast<Dst>,
fn unwrapped_as<Dst>(self) -> Dst where
T: UnwrappedCast<Dst>,
Casts the value.
sourceimpl<Src, Dst> UnwrappedCastFrom<Src> for Dst where
Src: UnwrappedCast<Dst>,
impl<Src, Dst> UnwrappedCastFrom<Src> for Dst where
Src: UnwrappedCast<Dst>,
sourcefn unwrapped_cast_from(src: Src) -> Dst
fn unwrapped_cast_from(src: Src) -> Dst
Casts the value.
sourceimpl<T> WrappingAs for T
impl<T> WrappingAs for T
sourcefn wrapping_as<Dst>(self) -> Dst where
T: WrappingCast<Dst>,
fn wrapping_as<Dst>(self) -> Dst where
T: WrappingCast<Dst>,
Casts the value.
sourceimpl<Src, Dst> WrappingCastFrom<Src> for Dst where
Src: WrappingCast<Dst>,
impl<Src, Dst> WrappingCastFrom<Src> for Dst where
Src: WrappingCast<Dst>,
sourcefn wrapping_cast_from(src: Src) -> Dst
fn wrapping_cast_from(src: Src) -> Dst
Casts the value.