Struct dashu_int::UBig

#[repr(transparent)]
pub struct UBig(_);

An unsigned arbitrary precision integer.

This struct represents an arbitrarily large unsigned integer. Technically the size of the integer is bounded by the memory size, but it’s enough for practical use on modern devices.

Parsing and printing

To create a UBig instance, there are three ways:

1. Use predifined constants (e.g. UBig::ZERO, UBig::ONE).
2. Use the literal macro ubig! defined in the dashu-macro crate.
3. Parse from a string.

Parsing from either literal or string supports representation with base 2~36.

For printing, the UBig type supports common formatting traits (Display, Debug, LowerHex, etc.). Specially, printing huge number using Debug will conveniently omit the middle digits of the number, only print the least and most significant (decimal) digits.

// parsing
let a = UBig::from(408580953453092208335085386466371u128);
let b = UBig::from(0x1231abcd4134u64);
let c = UBig::from_str_radix("a2a123bbb127779cccc123", 32)?;
let d = UBig::from_str_radix("1231abcd4134", 16)?;
assert_eq!(a, c);
assert_eq!(b, d);

// printing
assert_eq!(format!("{}", UBig::from(12u8)), "12");
assert_eq!(format!("{:#X}", UBig::from(0xabcdu16)), "0xABCD");
if Word::BITS == 64 {
    // number of digits to display depends on the word size
    assert_eq!(
        format!("{:?}", UBig::ONE << 1000),
        "1071508607186267320..4386837205668069376"
    );
}

Memory

Integers that fit in a DoubleWord will be inlined on stack and no heap allocation will be invoked. For large integers, they will be represented as an array of Words, and stored on heap.

Note that the UBig struct has a niche bit, therefore it can be used within simple enums with no memory overhead.

use core::mem::size_of;
assert_eq!(size_of::<UBig>(), size_of::<Option<UBig>>());

Implementations

impl UBig

pub fn bit(&self, n: usize) -> bool

Returns true if the n-th bit is set, n starts from 0.

Examples

assert_eq!(UBig::from(0b10010u16).bit(1), true);
assert_eq!(UBig::from(0b10010u16).bit(3), false);
assert_eq!(UBig::from(0b10010u16).bit(100), false);

pub fn set_bit(&mut self, n: usize)

Set the n-th bit, n starts from 0.

Examples

let mut a = UBig::from(0b100u8);
a.set_bit(0);
assert_eq!(a, UBig::from(0b101u8));
a.set_bit(10);
assert_eq!(a, UBig::from(0b10000000101u16));

pub fn clear_bit(&mut self, n: usize)

Clear the n-th bit, n starts from 0.

Examples

let mut a = UBig::from(0b101u8);
a.clear_bit(0);
assert_eq!(a, UBig::from(0b100u8));

pub fn trailing_zeros(&self) -> Option<usize>

Returns the number of trailing zeros in the binary representation.

In other words, it is the largest n such that 2 to the power of n divides the number.

For 0, it returns None.

Examples

assert_eq!(UBig::from(17u8).trailing_zeros(), Some(0));
assert_eq!(UBig::from(48u8).trailing_zeros(), Some(4));
assert_eq!(UBig::from(0b101000000u16).trailing_zeros(), Some(6));
assert_eq!(UBig::ZERO.trailing_zeros(), None);

pub fn bit_len(&self) -> usize

Bit length.

The length of the binary representation of the number.

For 0, the length is 0.

For non-zero numbers it is:

• in_radix(2).to_string().len()
• the index of the top 1 bit plus one
• the floor of the logarithm base 2 of the number plus one.

Examples

assert_eq!(UBig::from(17u8).bit_len(), 5);
assert_eq!(UBig::from(0b101000000u16).bit_len(), 9);
assert_eq!(UBig::ZERO.bit_len(), 0);
let x = UBig::from(0x90ffff3450897234u64);
assert_eq!(x.bit_len(), x.in_radix(2).to_string().len());

pub fn split_bits(self, n: usize) -> (UBig, UBig)

Split this integer into low bits and high bits.

Its returns are equal to (self & ((1 << n) - 1), self >> n).

Examples

let (lo, hi) = UBig::from(0b10100011u8).split_bits(4);
assert_eq!(hi, UBig::from(0b1010u8));
assert_eq!(lo, UBig::from(0b0011u8));

let x = UBig::from(0x90ffff3450897234u64);
let (lo, hi) = x.clone().split_bits(21);
assert_eq!(hi, (&x) >> 21);
assert_eq!(lo, x & ((UBig::ONE << 21) - 1u8));

pub fn clear_high_bits(&mut self, n: usize)

Clear the high bits from (n+1)-th bit.

This operation is equivalent to getting the lowest n bits on the integer i.e. self &= ((1 << n) - 1).

Examples

let mut x = UBig::from(0b10100011u8);
x.clear_high_bits(4);
assert_eq!(x, UBig::from(0b0011u8));

let mut x = UBig::from(0x90ffff3450897234u64);
let lo = (&x) & ((UBig::ONE << 21) - 1u8);
x.clear_high_bits(21);
assert_eq!(x, lo);

impl UBig

pub fn from_le_bytes(bytes: &[u8]) -> UBig

Construct from little-endian bytes.

Examples

assert_eq!(UBig::from_le_bytes(&[3, 2, 1]), 0x010203);

pub fn from_be_bytes(bytes: &[u8]) -> UBig

Construct from big-endian bytes.

Examples

assert_eq!(UBig::from_be_bytes(&[1, 2, 3]), 0x010203);

pub fn to_le_bytes(&self) -> Vec<u8>

Return little-endian bytes.

Examples

assert!(UBig::ZERO.to_le_bytes().is_empty());
assert_eq!(UBig::from(0x010203u32).to_le_bytes(), [3, 2, 1]);

pub fn to_be_bytes(&self) -> Vec<u8>

Return big-endian bytes.

Examples

assert!(UBig::ZERO.to_be_bytes().is_empty());
assert_eq!(UBig::from(0x010203u32).to_be_bytes(), [1, 2, 3]);

pub fn to_f32(&self) -> Approximation<f32, Sign>

Convert to f32.

Round to nearest, breaking ties to even last bit. The returned approximation is exact if the integer is exactly representable by f32, otherwise the error field of the approximation contains the sign of result - self.

Examples

assert_eq!(UBig::from(134u8).to_f32().value(), 134.0f32);

pub fn to_f64(&self) -> Approximation<f64, Sign>

Convert to f64.

Round to nearest, breaking ties to even last bit. The returned approximation is exact if the integer is exactly representable by f64, otherwise the error field of the approximation contains the sign of result - self.

Examples

assert_eq!(UBig::from(134u8).to_f64().value(), 134.0f64);

impl UBig

pub fn in_radix(&self, radix: u32) -> InRadix<'_>

Representation in a given radix.

Panics

Panics if radix is not between 2 and 36 inclusive.

Examples

assert_eq!(format!("{}", UBig::from(83u8).in_radix(3)), "10002");
assert_eq!(format!("{:+010}", UBig::from(35u8).in_radix(36)), "+00000000z");

impl UBig

pub fn ilog(&self, base: &UBig) -> usize

Calculate the (truncated) logarithm of the UBig

This function could takes a long time when the integer is very large. In applications where an exact result is not necessary, log2_bounds could be used.

Panics

Panics if the number is 0, or the base is 0 or 1

Examples

let base = UBig::from(3u8);
assert_eq!(UBig::from(81u8).ilog(&base), 4);
assert_eq!(UBig::from(1000u16).ilog(&base), 6);

impl UBig

pub fn square(&self) -> UBig

Calculate the square of the number (x * x).

Examples

assert_eq!(UBig::from(3u8).square(), 9);

impl UBig

pub fn from_str_radix(src: &str, radix: u32) -> Result<UBig, ParseError>

Convert a string in a given base to UBig.

src may contain an optional + prefix. Digits 10-35 are represented by a-z or A-Z.

Examples

assert_eq!(UBig::from_str_radix("+7ab", 32)?, 7499);

pub fn from_str_with_radix_prefix(src: &str) -> Result<(UBig, u32), ParseError>

Convert a string with an optional radix prefix to UBig, returns the parsed integer and radix.

src may contain an optional + after the radix prefix.

Allowed prefixes: 0b for binary, 0o for octal, 0x for hexadecimal.

Examples

assert_eq!(UBig::from_str_with_radix_prefix("+0o17")?, (UBig::from(0o17u8), 8));
assert_eq!(UBig::from_str_with_radix_prefix("0x1f")?.0, 0x1f);

impl UBig

pub fn pow(&self, exp: usize) -> UBig

Raises self to the power of exp.

Examples

assert_eq!(UBig::from(3u8).pow(3), 27);

impl UBig

pub fn remove(&mut self, factor: &UBig) -> Option<usize>

Divide out all multiples of the factor from the integer, returns the exponent of the removed factor.

For self = 0 or factor = 0 or 1, this method returns None.

impl UBig

pub fn sqrt(&self) -> UBig

Calculate the square root of the integer

pub fn sqrt_rem(&self) -> (UBig, UBig)

Calculate the square root and the remainder of the integer

pub fn nth_root(&self, n: usize) -> UBig

Calculate the nth-root of the integer

impl UBig

pub const ZERO: Self = _

UBig with value 0

pub const ONE: Self = _

UBig with value 1

pub fn as_words(&self) -> &[Word]

Get the raw representation in Words.

If the number is zero, then empty slice will be returned.

Examples

assert_eq!(UBig::ZERO.as_words(), &[] as &[Word]);
assert_eq!(UBig::ONE.as_words(), &[1]);

pub const fn from_word(word: Word) -> Self

Create a UBig from a single Word.

Examples

const ZERO: UBig = UBig::from_word(0);
assert_eq!(ZERO, UBig::ZERO);
const ONE: UBig = UBig::from_word(1);
assert_eq!(ONE, UBig::ONE);

pub const fn from_dword(dword: DoubleWord) -> Self

Create a UBig from a DoubleWord.

Examples

const ZERO: UBig = UBig::from_dword(0);
assert_eq!(ZERO, UBig::ZERO);
const ONE: UBig = UBig::from_dword(1);
assert_eq!(ONE, UBig::ONE);

pub fn from_words(words: &[Word]) -> Self

Convert a sequence of Words into a UBig

Examples

assert_eq!(UBig::from_words(&[] as &[Word]), UBig::ZERO);
assert_eq!(UBig::from_words(&[1]), UBig::ONE);
assert_eq!(UBig::from_words(&[1, 1]), (UBig::ONE << Word::BITS as usize) + UBig::ONE);

pub const fn is_zero(&self) -> bool

Check whether the value is 0

Examples

assert!(UBig::ZERO.is_zero());
assert!(!UBig::ONE.is_zero());

pub const fn is_one(&self) -> bool

Check whether the value is 1

Examples

assert!(!UBig::ZERO.is_one());
assert!(UBig::ONE.is_one());

Trait Implementations

impl<'l, 'r> Add<&'r IBig> for &'l UBig

type Output = IBig

The resulting type after applying the + operator.

fn add(self, rhs: &IBig) -> IBig

Performs the + operation.

impl<'r> Add<&'r IBig> for UBig

type Output = IBig

The resulting type after applying the + operator.

fn add(self, rhs: &IBig) -> IBig

Performs the + operation.

impl<'l, 'r> Add<&'r UBig> for &'l IBig

type Output = IBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> IBig

Performs the + operation.

impl<'l, 'r> Add<&'r UBig> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r UBig> for &'l u128

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r UBig> for &'l u16

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r UBig> for &'l u32

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r UBig> for &'l u64

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r UBig> for &'l u8

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r UBig> for &'l usize

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'r> Add<&'r UBig> for IBig

type Output = IBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> IBig

Performs the + operation.

impl<'r> Add<&'r UBig> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'r> Add<&'r UBig> for u128

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'r> Add<&'r UBig> for u16

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'r> Add<&'r UBig> for u32

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'r> Add<&'r UBig> for u64

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'r> Add<&'r UBig> for u8

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'r> Add<&'r UBig> for usize

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r u128> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> UBig

Performs the + operation.

impl<'r> Add<&'r u128> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &u128) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r u16> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> UBig

Performs the + operation.

impl<'r> Add<&'r u16> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r u32> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> UBig

Performs the + operation.

impl<'r> Add<&'r u32> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r u64> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> UBig

Performs the + operation.

impl<'r> Add<&'r u64> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r u8> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> UBig

Performs the + operation.

impl<'r> Add<&'r u8> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &u8) -> UBig

Performs the + operation.

impl<'l, 'r> Add<&'r usize> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> UBig

Performs the + operation.

impl<'r> Add<&'r usize> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: &usize) -> UBig

Performs the + operation.

impl<'l> Add<IBig> for &'l UBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for UBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<UBig> for &'l IBig

type Output = IBig

The resulting type after applying the + operator.

fn add(self, rhs: UBig) -> IBig

Performs the + operation.

impl<'l> Add<UBig> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<UBig> for &'l u128

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<UBig> for &'l u16

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<UBig> for &'l u32

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<UBig> for &'l u64

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<UBig> for &'l u8

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<UBig> for &'l usize

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for IBig

type Output = IBig

The resulting type after applying the + operator.

fn add(self, rhs: UBig) -> IBig

Performs the + operation.

impl Add<UBig> for UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for u128

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for u16

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for u32

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for u64

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for u8

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for usize

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<u128> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> UBig

Performs the + operation.

impl Add<u128> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> UBig

Performs the + operation.

impl<'l> Add<u16> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> UBig

Performs the + operation.

impl Add<u16> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> UBig

Performs the + operation.

impl<'l> Add<u32> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> UBig

Performs the + operation.

impl Add<u32> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> UBig

Performs the + operation.

impl<'l> Add<u64> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> UBig

Performs the + operation.

impl Add<u64> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> UBig

Performs the + operation.

impl<'l> Add<u8> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> UBig

Performs the + operation.

impl Add<u8> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> UBig

Performs the + operation.

impl<'l> Add<usize> for &'l UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> UBig

Performs the + operation.

impl Add<usize> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> UBig

Performs the + operation.

impl AddAssign<&UBig> for IBig

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

Performs the += operation.

impl AddAssign<&UBig> for UBig

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

Performs the += operation.

impl AddAssign<&u128> for UBig

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

Performs the += operation.

impl AddAssign<&u16> for UBig

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

Performs the += operation.

impl AddAssign<&u32> for UBig

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

Performs the += operation.

impl AddAssign<&u64> for UBig

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

Performs the += operation.

impl AddAssign<&u8> for UBig

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

Performs the += operation.

impl AddAssign<&usize> for UBig

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

Performs the += operation.

impl AddAssign<UBig> for IBig

fn add_assign(&mut self, rhs: UBig)

Performs the += operation.

impl AddAssign<UBig> for UBig

fn add_assign(&mut self, rhs: UBig)

Performs the += operation.

impl AddAssign<u128> for UBig

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl AddAssign<u16> for UBig

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl AddAssign<u32> for UBig

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AddAssign<u64> for UBig

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl AddAssign<u8> for UBig

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl AddAssign<usize> for UBig

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl Binary for UBig

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

Formats the value using the given formatter.

impl<'l, 'r> BitAnd<&'r UBig> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'l, 'r> BitAnd<&'r UBig> for &'l u128

type Output = u128

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> u128

Performs the & operation.

impl<'l, 'r> BitAnd<&'r UBig> for &'l u16

type Output = u16

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> u16

Performs the & operation.

impl<'l, 'r> BitAnd<&'r UBig> for &'l u32

type Output = u32

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> u32

Performs the & operation.

impl<'l, 'r> BitAnd<&'r UBig> for &'l u64

type Output = u64

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> u64

Performs the & operation.

impl<'l, 'r> BitAnd<&'r UBig> for &'l u8

type Output = u8

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> u8

Performs the & operation.

impl<'l, 'r> BitAnd<&'r UBig> for &'l usize

type Output = usize

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> usize

Performs the & operation.

impl<'r> BitAnd<&'r UBig> for UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'r> BitAnd<&'r UBig> for u128

type Output = u128

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> u128

Performs the & operation.

impl<'r> BitAnd<&'r UBig> for u16

type Output = u16

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> u16

Performs the & operation.

impl<'r> BitAnd<&'r UBig> for u32

type Output = u32

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> u32

Performs the & operation.

impl<'r> BitAnd<&'r UBig> for u64

type Output = u64

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> u64

Performs the & operation.

impl<'r> BitAnd<&'r UBig> for u8

type Output = u8

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> u8

Performs the & operation.

impl<'r> BitAnd<&'r UBig> for usize

type Output = usize

The resulting type after applying the & operator.

fn bitand(self, rhs: &UBig) -> usize

Performs the & operation.

impl<'l, 'r> BitAnd<&'r u128> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &u128) -> UBig

Performs the & operation.

impl<'r> BitAnd<&'r u128> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &u128) -> UBig

Performs the & operation.

impl<'l, 'r> BitAnd<&'r u16> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &u16) -> UBig

Performs the & operation.

impl<'r> BitAnd<&'r u16> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &u16) -> UBig

Performs the & operation.

impl<'l, 'r> BitAnd<&'r u32> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &u32) -> UBig

Performs the & operation.

impl<'r> BitAnd<&'r u32> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &u32) -> UBig

Performs the & operation.

impl<'l, 'r> BitAnd<&'r u64> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &u64) -> UBig

Performs the & operation.

impl<'r> BitAnd<&'r u64> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &u64) -> UBig

Performs the & operation.

impl<'l, 'r> BitAnd<&'r u8> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &u8) -> UBig

Performs the & operation.

impl<'r> BitAnd<&'r u8> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &u8) -> UBig

Performs the & operation.

impl<'l, 'r> BitAnd<&'r usize> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &usize) -> UBig

Performs the & operation.

impl<'r> BitAnd<&'r usize> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: &usize) -> UBig

Performs the & operation.

impl<'l> BitAnd<UBig> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'l> BitAnd<UBig> for &'l u128

type Output = u128

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> u128

Performs the & operation.

impl<'l> BitAnd<UBig> for &'l u16

type Output = u16

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> u16

Performs the & operation.

impl<'l> BitAnd<UBig> for &'l u32

type Output = u32

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> u32

Performs the & operation.

impl<'l> BitAnd<UBig> for &'l u64

type Output = u64

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> u64

Performs the & operation.

impl<'l> BitAnd<UBig> for &'l u8

type Output = u8

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> u8

Performs the & operation.

impl<'l> BitAnd<UBig> for &'l usize

type Output = usize

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> usize

Performs the & operation.

impl BitAnd<UBig> for UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for u128

type Output = u128

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> u128

Performs the & operation.

impl BitAnd<UBig> for u16

type Output = u16

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> u16

Performs the & operation.

impl BitAnd<UBig> for u32

type Output = u32

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> u32

Performs the & operation.

impl BitAnd<UBig> for u64

type Output = u64

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> u64

Performs the & operation.

impl BitAnd<UBig> for u8

type Output = u8

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> u8

Performs the & operation.

impl BitAnd<UBig> for usize

type Output = usize

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> usize

Performs the & operation.

impl<'l> BitAnd<u128> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: u128) -> UBig

Performs the & operation.

impl BitAnd<u128> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: u128) -> UBig

Performs the & operation.

impl<'l> BitAnd<u16> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: u16) -> UBig

Performs the & operation.

impl BitAnd<u16> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: u16) -> UBig

Performs the & operation.

impl<'l> BitAnd<u32> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: u32) -> UBig

Performs the & operation.

impl BitAnd<u32> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: u32) -> UBig

Performs the & operation.

impl<'l> BitAnd<u64> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: u64) -> UBig

Performs the & operation.

impl BitAnd<u64> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: u64) -> UBig

Performs the & operation.

impl<'l> BitAnd<u8> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: u8) -> UBig

Performs the & operation.

impl BitAnd<u8> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: u8) -> UBig

Performs the & operation.

impl<'l> BitAnd<usize> for &'l UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: usize) -> UBig

Performs the & operation.

impl BitAnd<usize> for UBig

type Output = UBig

The resulting type after applying the & operator.

fn bitand(self, rhs: usize) -> UBig

Performs the & operation.

impl BitAndAssign<&UBig> for UBig

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

Performs the &= operation.

impl BitAndAssign<&u128> for UBig

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

Performs the &= operation.

impl BitAndAssign<&u16> for UBig

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

Performs the &= operation.

impl BitAndAssign<&u32> for UBig

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

Performs the &= operation.

impl BitAndAssign<&u64> for UBig

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

Performs the &= operation.

impl BitAndAssign<&u8> for UBig

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

Performs the &= operation.

impl BitAndAssign<&usize> for UBig

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

Performs the &= operation.

impl BitAndAssign<UBig> for UBig

fn bitand_assign(&mut self, rhs: UBig)

Performs the &= operation.

impl BitAndAssign<u128> for UBig

fn bitand_assign(&mut self, rhs: u128)

Performs the &= operation.

impl BitAndAssign<u16> for UBig

fn bitand_assign(&mut self, rhs: u16)

Performs the &= operation.

impl BitAndAssign<u32> for UBig

fn bitand_assign(&mut self, rhs: u32)

Performs the &= operation.

impl BitAndAssign<u64> for UBig

fn bitand_assign(&mut self, rhs: u64)

Performs the &= operation.

impl BitAndAssign<u8> for UBig

fn bitand_assign(&mut self, rhs: u8)

Performs the &= operation.

impl BitAndAssign<usize> for UBig

fn bitand_assign(&mut self, rhs: usize)

Performs the &= operation.

impl<'l, 'r> BitOr<&'r UBig> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l, 'r> BitOr<&'r UBig> for &'l u128

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l, 'r> BitOr<&'r UBig> for &'l u16

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l, 'r> BitOr<&'r UBig> for &'l u32

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l, 'r> BitOr<&'r UBig> for &'l u64

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l, 'r> BitOr<&'r UBig> for &'l u8

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l, 'r> BitOr<&'r UBig> for &'l usize

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'r> BitOr<&'r UBig> for UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'r> BitOr<&'r UBig> for u128

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'r> BitOr<&'r UBig> for u16

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'r> BitOr<&'r UBig> for u32

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'r> BitOr<&'r UBig> for u64

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'r> BitOr<&'r UBig> for u8

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'r> BitOr<&'r UBig> for usize

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l, 'r> BitOr<&'r u128> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &u128) -> UBig

Performs the | operation.

impl<'r> BitOr<&'r u128> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &u128) -> UBig

Performs the | operation.

impl<'l, 'r> BitOr<&'r u16> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &u16) -> UBig

Performs the | operation.

impl<'r> BitOr<&'r u16> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &u16) -> UBig

Performs the | operation.

impl<'l, 'r> BitOr<&'r u32> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &u32) -> UBig

Performs the | operation.

impl<'r> BitOr<&'r u32> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &u32) -> UBig

Performs the | operation.

impl<'l, 'r> BitOr<&'r u64> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &u64) -> UBig

Performs the | operation.

impl<'r> BitOr<&'r u64> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &u64) -> UBig

Performs the | operation.

impl<'l, 'r> BitOr<&'r u8> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &u8) -> UBig

Performs the | operation.

impl<'r> BitOr<&'r u8> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &u8) -> UBig

Performs the | operation.

impl<'l, 'r> BitOr<&'r usize> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &usize) -> UBig

Performs the | operation.

impl<'r> BitOr<&'r usize> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: &usize) -> UBig

Performs the | operation.

impl<'l> BitOr<UBig> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l> BitOr<UBig> for &'l u128

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l> BitOr<UBig> for &'l u16

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l> BitOr<UBig> for &'l u32

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l> BitOr<UBig> for &'l u64

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l> BitOr<UBig> for &'l u8

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l> BitOr<UBig> for &'l usize

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for u128

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for u16

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for u32

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for u64

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for u8

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for usize

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'l> BitOr<u128> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u128) -> UBig

Performs the | operation.

impl BitOr<u128> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u128) -> UBig

Performs the | operation.

impl<'l> BitOr<u16> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u16) -> UBig

Performs the | operation.

impl BitOr<u16> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u16) -> UBig

Performs the | operation.

impl<'l> BitOr<u32> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> UBig

Performs the | operation.

impl BitOr<u32> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> UBig

Performs the | operation.

impl<'l> BitOr<u64> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u64) -> UBig

Performs the | operation.

impl BitOr<u64> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u64) -> UBig

Performs the | operation.

impl<'l> BitOr<u8> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u8) -> UBig

Performs the | operation.

impl BitOr<u8> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u8) -> UBig

Performs the | operation.

impl<'l> BitOr<usize> for &'l UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: usize) -> UBig

Performs the | operation.

impl BitOr<usize> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: usize) -> UBig

Performs the | operation.

impl BitOrAssign<&UBig> for UBig

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

Performs the |= operation.

impl BitOrAssign<&u128> for UBig

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

Performs the |= operation.

impl BitOrAssign<&u16> for UBig

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

Performs the |= operation.

impl BitOrAssign<&u32> for UBig

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

Performs the |= operation.

impl BitOrAssign<&u64> for UBig

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

Performs the |= operation.

impl BitOrAssign<&u8> for UBig

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

Performs the |= operation.

impl BitOrAssign<&usize> for UBig

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

Performs the |= operation.

impl BitOrAssign<UBig> for UBig

fn bitor_assign(&mut self, rhs: UBig)

Performs the |= operation.

impl BitOrAssign<u128> for UBig

fn bitor_assign(&mut self, rhs: u128)

Performs the |= operation.

impl BitOrAssign<u16> for UBig

fn bitor_assign(&mut self, rhs: u16)

Performs the |= operation.

impl BitOrAssign<u32> for UBig

fn bitor_assign(&mut self, rhs: u32)

Performs the |= operation.

impl BitOrAssign<u64> for UBig

fn bitor_assign(&mut self, rhs: u64)

Performs the |= operation.

impl BitOrAssign<u8> for UBig

fn bitor_assign(&mut self, rhs: u8)

Performs the |= operation.

impl BitOrAssign<usize> for UBig

fn bitor_assign(&mut self, rhs: usize)

Performs the |= operation.

impl<'l, 'r> BitXor<&'r UBig> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r UBig> for &'l u128

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r UBig> for &'l u16

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r UBig> for &'l u32

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r UBig> for &'l u64

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r UBig> for &'l u8

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r UBig> for &'l usize

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'r> BitXor<&'r UBig> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'r> BitXor<&'r UBig> for u128

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'r> BitXor<&'r UBig> for u16

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'r> BitXor<&'r UBig> for u32

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'r> BitXor<&'r UBig> for u64

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'r> BitXor<&'r UBig> for u8

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'r> BitXor<&'r UBig> for usize

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r u128> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u128) -> UBig

Performs the ^ operation.

impl<'r> BitXor<&'r u128> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u128) -> UBig

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r u16> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u16) -> UBig

Performs the ^ operation.

impl<'r> BitXor<&'r u16> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u16) -> UBig

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r u32> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u32) -> UBig

Performs the ^ operation.

impl<'r> BitXor<&'r u32> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u32) -> UBig

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r u64> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u64) -> UBig

Performs the ^ operation.

impl<'r> BitXor<&'r u64> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u64) -> UBig

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r u8> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u8) -> UBig

Performs the ^ operation.

impl<'r> BitXor<&'r u8> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &u8) -> UBig

Performs the ^ operation.

impl<'l, 'r> BitXor<&'r usize> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &usize) -> UBig

Performs the ^ operation.

impl<'r> BitXor<&'r usize> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &usize) -> UBig

Performs the ^ operation.

impl<'l> BitXor<UBig> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l> BitXor<UBig> for &'l u128

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l> BitXor<UBig> for &'l u16

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l> BitXor<UBig> for &'l u32

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l> BitXor<UBig> for &'l u64

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l> BitXor<UBig> for &'l u8

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l> BitXor<UBig> for &'l usize

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for u128

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for u16

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for u32

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for u64

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for u8

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for usize

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'l> BitXor<u128> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u128) -> UBig

Performs the ^ operation.

impl BitXor<u128> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u128) -> UBig

Performs the ^ operation.

impl<'l> BitXor<u16> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u16) -> UBig

Performs the ^ operation.

impl BitXor<u16> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u16) -> UBig

Performs the ^ operation.

impl<'l> BitXor<u32> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u32) -> UBig

Performs the ^ operation.

impl BitXor<u32> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u32) -> UBig

Performs the ^ operation.

impl<'l> BitXor<u64> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u64) -> UBig

Performs the ^ operation.

impl BitXor<u64> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u64) -> UBig

Performs the ^ operation.

impl<'l> BitXor<u8> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u8) -> UBig

Performs the ^ operation.

impl BitXor<u8> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u8) -> UBig

Performs the ^ operation.

impl<'l> BitXor<usize> for &'l UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: usize) -> UBig

Performs the ^ operation.

impl BitXor<usize> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: usize) -> UBig

Performs the ^ operation.

impl BitXorAssign<&UBig> for UBig

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

Performs the ^= operation.

impl BitXorAssign<&u128> for UBig

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

Performs the ^= operation.

impl BitXorAssign<&u16> for UBig

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

Performs the ^= operation.

impl BitXorAssign<&u32> for UBig

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

Performs the ^= operation.

impl BitXorAssign<&u64> for UBig

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

Performs the ^= operation.

impl BitXorAssign<&u8> for UBig

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

Performs the ^= operation.

impl BitXorAssign<&usize> for UBig

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

Performs the ^= operation.

impl BitXorAssign<UBig> for UBig

fn bitxor_assign(&mut self, rhs: UBig)

Performs the ^= operation.

impl BitXorAssign<u128> for UBig

fn bitxor_assign(&mut self, rhs: u128)

Performs the ^= operation.

impl BitXorAssign<u16> for UBig

fn bitxor_assign(&mut self, rhs: u16)

Performs the ^= operation.

impl BitXorAssign<u32> for UBig

fn bitxor_assign(&mut self, rhs: u32)

Performs the ^= operation.

impl BitXorAssign<u64> for UBig

fn bitxor_assign(&mut self, rhs: u64)

Performs the ^= operation.

impl BitXorAssign<u8> for UBig

fn bitxor_assign(&mut self, rhs: u8)

Performs the ^= operation.

impl BitXorAssign<usize> for UBig

fn bitxor_assign(&mut self, rhs: usize)

Performs the ^= operation.

impl Clone for UBig

fn clone(&self) -> UBig

Returns a copy of the value.

fn clone_from(&mut self, source: &UBig)

Performs copy-assignment from source.

impl Debug for UBig

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

Formats the value using the given formatter.

impl Default for UBig

fn default() -> UBig

Default value: 0.

impl<'de> Deserialize<'de> for UBig

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

Deserialize this value from the given Serde deserializer.

impl Display for UBig

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

Formats the value using the given formatter.

impl<'l, 'r> Div<&'r ConstDivisor> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &ConstDivisor) -> UBig

Performs the / operation.

impl<'r> Div<&'r ConstDivisor> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &ConstDivisor) -> UBig

Performs the / operation.

impl<'l, 'r> Div<&'r IBig> for &'l UBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: &IBig) -> IBig

Performs the / operation.

impl<'r> Div<&'r IBig> for UBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: &IBig) -> IBig

Performs the / operation.

impl<'l, 'r> Div<&'r UBig> for &'l IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> IBig

Performs the / operation.

impl<'l, 'r> Div<&'r UBig> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> UBig

Performs the / operation.

impl<'r> Div<&'r UBig> for IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> IBig

Performs the / operation.

impl<'r> Div<&'r UBig> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> UBig

Performs the / operation.

impl<'l, 'r> Div<&'r u128> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> UBig

Performs the / operation.

impl<'r> Div<&'r u128> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &u128) -> UBig

Performs the / operation.

impl<'l, 'r> Div<&'r u16> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> UBig

Performs the / operation.

impl<'r> Div<&'r u16> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> UBig

Performs the / operation.

impl<'l, 'r> Div<&'r u32> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> UBig

Performs the / operation.

impl<'r> Div<&'r u32> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> UBig

Performs the / operation.

impl<'l, 'r> Div<&'r u64> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> UBig

Performs the / operation.

impl<'r> Div<&'r u64> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> UBig

Performs the / operation.

impl<'l, 'r> Div<&'r u8> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> UBig

Performs the / operation.

impl<'r> Div<&'r u8> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &u8) -> UBig

Performs the / operation.

impl<'l, 'r> Div<&'r usize> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> UBig

Performs the / operation.

impl<'r> Div<&'r usize> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: &usize) -> UBig

Performs the / operation.

impl<'l> Div<IBig> for &'l UBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<IBig> for UBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l> Div<UBig> for &'l IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: UBig) -> IBig

Performs the / operation.

impl<'l> Div<UBig> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<UBig> for IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: UBig) -> IBig

Performs the / operation.

impl Div<UBig> for UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'l> Div<u128> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> UBig

Performs the / operation.

impl Div<u128> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> UBig

Performs the / operation.

impl<'l> Div<u16> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> UBig

Performs the / operation.

impl Div<u16> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> UBig

Performs the / operation.

impl<'l> Div<u32> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> UBig

Performs the / operation.

impl Div<u32> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> UBig

Performs the / operation.

impl<'l> Div<u64> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> UBig

Performs the / operation.

impl Div<u64> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> UBig

Performs the / operation.

impl<'l> Div<u8> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> UBig

Performs the / operation.

impl Div<u8> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> UBig

Performs the / operation.

impl<'l> Div<usize> for &'l UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> UBig

Performs the / operation.

impl Div<usize> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> UBig

Performs the / operation.

impl<'r> DivAssign<&'r ConstDivisor> for UBig

fn div_assign(&mut self, rhs: &'r ConstDivisor)

Performs the /= operation.

impl DivAssign<&UBig> for IBig

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

Performs the /= operation.

impl DivAssign<&UBig> for UBig

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

Performs the /= operation.

impl DivAssign<&u128> for UBig

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

Performs the /= operation.

impl DivAssign<&u16> for UBig

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

Performs the /= operation.

impl DivAssign<&u32> for UBig

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

Performs the /= operation.

impl DivAssign<&u64> for UBig

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

Performs the /= operation.

impl DivAssign<&u8> for UBig

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

Performs the /= operation.

impl DivAssign<&usize> for UBig

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

Performs the /= operation.

impl DivAssign<UBig> for IBig

fn div_assign(&mut self, rhs: UBig)

Performs the /= operation.

impl DivAssign<UBig> for UBig

fn div_assign(&mut self, rhs: UBig)

Performs the /= operation.

impl DivAssign<u128> for UBig

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl DivAssign<u16> for UBig

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl DivAssign<u32> for UBig

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl DivAssign<u64> for UBig

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl DivAssign<u8> for UBig

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl DivAssign<usize> for UBig

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl<'l, 'r> DivEuclid<&'r UBig> for &'l UBig

type Output = UBig

fn div_euclid(self, rhs: &UBig) -> UBig

impl<'r> DivEuclid<&'r UBig> for UBig

type Output = UBig

fn div_euclid(self, rhs: &UBig) -> UBig

impl<'l> DivEuclid<UBig> for &'l UBig

type Output = UBig

fn div_euclid(self, rhs: UBig) -> UBig

impl DivEuclid<UBig> for UBig

type Output = UBig

fn div_euclid(self, rhs: UBig) -> UBig

impl<'l, 'r> DivRem<&'r ConstDivisor> for &'l UBig

type OutputDiv = UBig

type OutputRem = UBig

fn div_rem(self, rhs: &ConstDivisor) -> (UBig, UBig)

impl<'r> DivRem<&'r ConstDivisor> for UBig

type OutputDiv = UBig

type OutputRem = UBig

fn div_rem(self, rhs: &ConstDivisor) -> (UBig, UBig)

impl<'l, 'r> DivRem<&'r UBig> for &'l UBig

type OutputDiv = UBig

type OutputRem = UBig

fn div_rem(self, rhs: &UBig) -> (UBig, UBig)

impl<'r> DivRem<&'r UBig> for UBig

type OutputDiv = UBig

type OutputRem = UBig

fn div_rem(self, rhs: &UBig) -> (UBig, UBig)

impl<'l, 'r> DivRem<&'r u128> for &'l UBig

type OutputDiv = UBig

type OutputRem = u128

fn div_rem(self, rhs: &u128) -> (UBig, u128)

impl<'r> DivRem<&'r u128> for UBig

type OutputDiv = UBig

type OutputRem = u128

fn div_rem(self, rhs: &u128) -> (UBig, u128)

impl<'l, 'r> DivRem<&'r u16> for &'l UBig

type OutputDiv = UBig

type OutputRem = u16

fn div_rem(self, rhs: &u16) -> (UBig, u16)

impl<'r> DivRem<&'r u16> for UBig

type OutputDiv = UBig

type OutputRem = u16

fn div_rem(self, rhs: &u16) -> (UBig, u16)

impl<'l, 'r> DivRem<&'r u32> for &'l UBig

type OutputDiv = UBig

type OutputRem = u32

fn div_rem(self, rhs: &u32) -> (UBig, u32)

impl<'r> DivRem<&'r u32> for UBig

type OutputDiv = UBig

type OutputRem = u32

fn div_rem(self, rhs: &u32) -> (UBig, u32)

impl<'l, 'r> DivRem<&'r u64> for &'l UBig

type OutputDiv = UBig

type OutputRem = u64

fn div_rem(self, rhs: &u64) -> (UBig, u64)

impl<'r> DivRem<&'r u64> for UBig

type OutputDiv = UBig

type OutputRem = u64

fn div_rem(self, rhs: &u64) -> (UBig, u64)

impl<'l, 'r> DivRem<&'r u8> for &'l UBig

type OutputDiv = UBig

type OutputRem = u8

fn div_rem(self, rhs: &u8) -> (UBig, u8)

impl<'r> DivRem<&'r u8> for UBig

type OutputDiv = UBig

type OutputRem = u8

fn div_rem(self, rhs: &u8) -> (UBig, u8)

impl<'l, 'r> DivRem<&'r usize> for &'l UBig

type OutputDiv = UBig

type OutputRem = usize

fn div_rem(self, rhs: &usize) -> (UBig, usize)

impl<'r> DivRem<&'r usize> for UBig

type OutputDiv = UBig

type OutputRem = usize

fn div_rem(self, rhs: &usize) -> (UBig, usize)

impl<'l> DivRem<UBig> for &'l UBig

type OutputDiv = UBig

type OutputRem = UBig

fn div_rem(self, rhs: UBig) -> (UBig, UBig)

impl DivRem<UBig> for UBig

type OutputDiv = UBig

type OutputRem = UBig

fn div_rem(self, rhs: UBig) -> (UBig, UBig)

impl<'l> DivRem<u128> for &'l UBig

type OutputDiv = UBig

type OutputRem = u128

fn div_rem(self, rhs: u128) -> (UBig, u128)

impl DivRem<u128> for UBig

type OutputDiv = UBig

type OutputRem = u128

fn div_rem(self, rhs: u128) -> (UBig, u128)

impl<'l> DivRem<u16> for &'l UBig

type OutputDiv = UBig

type OutputRem = u16

fn div_rem(self, rhs: u16) -> (UBig, u16)

impl DivRem<u16> for UBig

type OutputDiv = UBig

type OutputRem = u16

fn div_rem(self, rhs: u16) -> (UBig, u16)

impl<'l> DivRem<u32> for &'l UBig

type OutputDiv = UBig

type OutputRem = u32

fn div_rem(self, rhs: u32) -> (UBig, u32)

impl DivRem<u32> for UBig

type OutputDiv = UBig

type OutputRem = u32

fn div_rem(self, rhs: u32) -> (UBig, u32)

impl<'l> DivRem<u64> for &'l UBig

type OutputDiv = UBig

type OutputRem = u64

fn div_rem(self, rhs: u64) -> (UBig, u64)

impl DivRem<u64> for UBig

type OutputDiv = UBig

type OutputRem = u64

fn div_rem(self, rhs: u64) -> (UBig, u64)

impl<'l> DivRem<u8> for &'l UBig

type OutputDiv = UBig

type OutputRem = u8

fn div_rem(self, rhs: u8) -> (UBig, u8)

impl DivRem<u8> for UBig

type OutputDiv = UBig

type OutputRem = u8

fn div_rem(self, rhs: u8) -> (UBig, u8)

impl<'l> DivRem<usize> for &'l UBig

type OutputDiv = UBig

type OutputRem = usize

fn div_rem(self, rhs: usize) -> (UBig, usize)

impl DivRem<usize> for UBig

type OutputDiv = UBig

type OutputRem = usize

fn div_rem(self, rhs: usize) -> (UBig, usize)

impl<'r> DivRemAssign<&'r ConstDivisor> for UBig

type OutputRem = UBig

fn div_rem_assign(&mut self, rhs: &ConstDivisor) -> UBig

impl DivRemAssign<&UBig> for UBig

type OutputRem = UBig

fn div_rem_assign(&mut self, rhs: &UBig) -> UBig

impl DivRemAssign<&u128> for UBig

type OutputRem = u128

fn div_rem_assign(&mut self, rhs: &u128) -> u128

impl DivRemAssign<&u16> for UBig

type OutputRem = u16

fn div_rem_assign(&mut self, rhs: &u16) -> u16

impl DivRemAssign<&u32> for UBig

type OutputRem = u32

fn div_rem_assign(&mut self, rhs: &u32) -> u32

impl DivRemAssign<&u64> for UBig

type OutputRem = u64

fn div_rem_assign(&mut self, rhs: &u64) -> u64

impl DivRemAssign<&u8> for UBig

type OutputRem = u8

fn div_rem_assign(&mut self, rhs: &u8) -> u8

impl DivRemAssign<&usize> for UBig

type OutputRem = usize

fn div_rem_assign(&mut self, rhs: &usize) -> usize

impl DivRemAssign<UBig> for UBig

type OutputRem = UBig

fn div_rem_assign(&mut self, rhs: UBig) -> UBig

impl DivRemAssign<u128> for UBig

type OutputRem = u128

fn div_rem_assign(&mut self, rhs: u128) -> u128

impl DivRemAssign<u16> for UBig

type OutputRem = u16

fn div_rem_assign(&mut self, rhs: u16) -> u16

impl DivRemAssign<u32> for UBig

type OutputRem = u32

fn div_rem_assign(&mut self, rhs: u32) -> u32

impl DivRemAssign<u64> for UBig

type OutputRem = u64

fn div_rem_assign(&mut self, rhs: u64) -> u64

impl DivRemAssign<u8> for UBig

type OutputRem = u8

fn div_rem_assign(&mut self, rhs: u8) -> u8

impl DivRemAssign<usize> for UBig

type OutputRem = usize

fn div_rem_assign(&mut self, rhs: usize) -> usize

impl<'l, 'r> DivRemEuclid<&'r UBig> for &'l UBig

type OutputDiv = UBig

type OutputRem = UBig

fn div_rem_euclid(self, rhs: &UBig) -> (UBig, UBig)

impl<'r> DivRemEuclid<&'r UBig> for UBig

type OutputDiv = UBig

type OutputRem = UBig

fn div_rem_euclid(self, rhs: &UBig) -> (UBig, UBig)

impl<'l> DivRemEuclid<UBig> for &'l UBig

type OutputDiv = UBig

type OutputRem = UBig

fn div_rem_euclid(self, rhs: UBig) -> (UBig, UBig)

impl DivRemEuclid<UBig> for UBig

type OutputDiv = UBig

type OutputRem = UBig

fn div_rem_euclid(self, rhs: UBig) -> (UBig, UBig)

impl EstimatedLog2 for UBig

fn log2_bounds(&self) -> (f32, f32)

Estimate the bounds of the binary logarithm.

fn log2_est(&self) -> f32

Estimate the value of the binary logarithm. It’s calculated as the average of log2_bounds by default.

impl Euclid for UBig

fn div_euclid(&self, v: &Self) -> Self

Calculates Euclidean division, the matching method for rem_euclid.

fn rem_euclid(&self, v: &Self) -> Self

Calculates the least nonnegative remainder of self (mod v).

impl<'l, 'r> ExtendedGcd<&'r UBig> for &'l UBig

type OutputGcd = UBig

type OutputCoeff = IBig

fn gcd_ext(self, rhs: &UBig) -> (UBig, IBig, IBig)

Calculate the greatest common divisor between the two operands, returns the common divisor g and the Bézout coefficients respectively.

impl<'r> ExtendedGcd<&'r UBig> for UBig

type OutputGcd = UBig

type OutputCoeff = IBig

fn gcd_ext(self, rhs: &UBig) -> (UBig, IBig, IBig)

Calculate the greatest common divisor between the two operands, returns the common divisor g and the Bézout coefficients respectively.

impl<'l> ExtendedGcd<UBig> for &'l UBig

type OutputGcd = UBig

type OutputCoeff = IBig

fn gcd_ext(self, rhs: UBig) -> (UBig, IBig, IBig)

Calculate the greatest common divisor between the two operands, returns the common divisor g and the Bézout coefficients respectively.

impl ExtendedGcd<UBig> for UBig

type OutputGcd = UBig

type OutputCoeff = IBig

fn gcd_ext(self, rhs: UBig) -> (UBig, IBig, IBig)

Calculate the greatest common divisor between the two operands, returns the common divisor g and the Bézout coefficients respectively.

impl From<&UBig> for IBig

fn from(x: &UBig) -> IBig

Converts to this type from the input type.

impl From<UBig> for IBig

fn from(x: UBig) -> IBig

Converts to this type from the input type.

impl From<bool> for UBig

fn from(b: bool) -> UBig

Converts to this type from the input type.

impl From<u128> for UBig

fn from(value: u128) -> UBig

Converts to this type from the input type.

impl From<u16> for UBig

fn from(value: u16) -> UBig

Converts to this type from the input type.

impl From<u32> for UBig

fn from(value: u32) -> UBig

Converts to this type from the input type.

impl From<u64> for UBig

fn from(value: u64) -> UBig

Converts to this type from the input type.

impl From<u8> for UBig

fn from(value: u8) -> UBig

Converts to this type from the input type.

impl From<usize> for UBig

fn from(value: usize) -> UBig

Converts to this type from the input type.

impl FromPrimitive for UBig

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl FromStr for UBig

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<UBig, ParseError>

Parses a string s to return a value of this type.

impl<'l, 'r> Gcd<&'r UBig> for &'l UBig

type Output = UBig

fn gcd(self, rhs: &UBig) -> UBig

Compute the greatest common divisor between the two operands.

impl<'r> Gcd<&'r UBig> for UBig

type Output = UBig

fn gcd(self, rhs: &UBig) -> UBig

Compute the greatest common divisor between the two operands.

impl<'l> Gcd<UBig> for &'l UBig

type Output = UBig

fn gcd(self, rhs: UBig) -> UBig

Compute the greatest common divisor between the two operands.

impl Gcd<UBig> for UBig

type Output = UBig

fn gcd(self, rhs: UBig) -> UBig

Compute the greatest common divisor between the two operands.

impl Hash for UBig

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,

Feeds a slice of this type into the given Hasher.

impl Integer for UBig

fn div_floor(&self, other: &Self) -> Self

Floored integer division.

fn div_rem(&self, other: &Self) -> (Self, Self)

Simultaneous truncated integer division and modulus. Returns (quotient, remainder).

fn mod_floor(&self, other: &Self) -> Self

Floored integer modulo, satisfying:

fn divides(&self, other: &Self) -> bool

Deprecated, use is_multiple_of instead.

fn is_multiple_of(&self, other: &Self) -> bool

Returns true if self is a multiple of other.

fn is_even(&self) -> bool

Returns true if the number is even.

fn is_odd(&self) -> bool

Returns true if the number is odd.

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

Greatest Common Divisor (GCD).

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

Lowest Common Multiple (LCM).

fn extended_gcd(&self, other: &Self) -> ExtendedGcd<Self>

Greatest common divisor and Bézout coefficients.

fn div_ceil(&self, other: &Self) -> Self

Ceiled integer division.

fn gcd_lcm(&self, other: &Self) -> (Self, Self)

Greatest Common Divisor (GCD) and Lowest Common Multiple (LCM) together.

fn div_mod_floor(&self, other: &Self) -> (Self, Self)

Simultaneous floored integer division and modulus. Returns (quotient, remainder).

fn next_multiple_of(&self, other: &Self) -> Selfwhere
    Self: Clone,

Rounds up to nearest multiple of argument.

fn prev_multiple_of(&self, other: &Self) -> Selfwhere
    Self: Clone,

Rounds down to nearest multiple of argument.

impl IntoModulo for &UBig

fn into_modulo(self, ring: &ModuloRing) -> Modulo<'_>

impl IntoModulo for UBig

fn into_modulo(self, ring: &ModuloRing) -> Modulo<'_>

impl LowerHex for UBig

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

Formats the value using the given formatter.

impl<'l, 'r> Mul<&'r IBig> for &'l UBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> IBig

Performs the * operation.

impl<'r> Mul<&'r IBig> for UBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> IBig

Performs the * operation.

impl<'l, 'r> Mul<&'r UBig> for &'l IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> IBig

Performs the * operation.

impl<'l, 'r> Mul<&'r UBig> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r UBig> for &'l u128

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r UBig> for &'l u16

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r UBig> for &'l u32

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r UBig> for &'l u64

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r UBig> for &'l u8

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r UBig> for &'l usize

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'r> Mul<&'r UBig> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> IBig

Performs the * operation.

impl<'r> Mul<&'r UBig> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'r> Mul<&'r UBig> for u128

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'r> Mul<&'r UBig> for u16

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'r> Mul<&'r UBig> for u32

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'r> Mul<&'r UBig> for u64

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'r> Mul<&'r UBig> for u8

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'r> Mul<&'r UBig> for usize

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r u128> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> UBig

Performs the * operation.

impl<'r> Mul<&'r u128> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &u128) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r u16> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> UBig

Performs the * operation.

impl<'r> Mul<&'r u16> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r u32> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> UBig

Performs the * operation.

impl<'r> Mul<&'r u32> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r u64> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> UBig

Performs the * operation.

impl<'r> Mul<&'r u64> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r u8> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> UBig

Performs the * operation.

impl<'r> Mul<&'r u8> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &u8) -> UBig

Performs the * operation.

impl<'l, 'r> Mul<&'r usize> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> UBig

Performs the * operation.

impl<'r> Mul<&'r usize> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> UBig

Performs the * operation.

impl<'l> Mul<IBig> for &'l UBig

type Output = IBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<IBig> for UBig

type Output = IBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Sign> for UBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: Sign) -> Self::Output

Performs the * operation.

impl<'l> Mul<UBig> for &'l IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> IBig

Performs the * operation.

impl<'l> Mul<UBig> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l> Mul<UBig> for &'l u128

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l> Mul<UBig> for &'l u16

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l> Mul<UBig> for &'l u32

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l> Mul<UBig> for &'l u64

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l> Mul<UBig> for &'l u8

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l> Mul<UBig> for &'l usize

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> IBig

Performs the * operation.

impl Mul<UBig> for Sign

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> Self::Output

Performs the * operation.

impl Mul<UBig> for UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for u128

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for u16

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for u32

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for u64

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for u8

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for usize

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l> Mul<u128> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> UBig

Performs the * operation.

impl Mul<u128> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> UBig

Performs the * operation.

impl<'l> Mul<u16> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> UBig

Performs the * operation.

impl Mul<u16> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> UBig

Performs the * operation.

impl<'l> Mul<u32> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> UBig

Performs the * operation.

impl Mul<u32> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> UBig

Performs the * operation.

impl<'l> Mul<u64> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> UBig

Performs the * operation.

impl Mul<u64> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> UBig

Performs the * operation.

impl<'l> Mul<u8> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> UBig

Performs the * operation.

impl Mul<u8> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> UBig

Performs the * operation.

impl<'l> Mul<usize> for &'l UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> UBig

Performs the * operation.

impl Mul<usize> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> UBig

Performs the * operation.

impl MulAssign<&UBig> for IBig

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

Performs the *= operation.

impl MulAssign<&UBig> for UBig

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

Performs the *= operation.

impl MulAssign<&u128> for UBig

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

Performs the *= operation.

impl MulAssign<&u16> for UBig

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

Performs the *= operation.

impl MulAssign<&u32> for UBig

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

Performs the *= operation.

impl MulAssign<&u64> for UBig

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

Performs the *= operation.

impl MulAssign<&u8> for UBig

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

Performs the *= operation.

impl MulAssign<&usize> for UBig

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

Performs the *= operation.

impl MulAssign<UBig> for IBig

fn mul_assign(&mut self, rhs: UBig)

Performs the *= operation.

impl MulAssign<UBig> for UBig

fn mul_assign(&mut self, rhs: UBig)

Performs the *= operation.

impl MulAssign<u128> for UBig

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl MulAssign<u16> for UBig

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl MulAssign<u32> for UBig

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl MulAssign<u64> for UBig

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl MulAssign<u8> for UBig

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl MulAssign<usize> for UBig

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl Neg for &UBig

type Output = IBig

The resulting type after applying the - operator.

fn neg(self) -> IBig

Performs the unary - operation.

impl Neg for UBig

type Output = IBig

The resulting type after applying the - operator.

fn neg(self) -> IBig

Performs the unary - operation.

impl Num for UBig

type FromStrRadixErr = ParseError

fn from_str_radix(s: &str, radix: u32) -> Result<Self, ParseError>

Convert from a string and radix (typically 2..=36).

impl NumHash for UBig

fn num_hash<H: Hasher>(&self, state: &mut H)

Consistent Hash::hash on different numeric types.

impl NumOrd<UBig> for i128

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<UBig> for i16

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<UBig> for i32

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<UBig> for i64

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<UBig> for i8

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<UBig> for isize

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<UBig> for u128

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<UBig> for u16

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<UBig> for u32

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<UBig> for u64

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<UBig> for u8

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<UBig> for usize

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<i128> for UBig

fn num_partial_cmp(&self, other: &i128) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<i16> for UBig

fn num_partial_cmp(&self, other: &i16) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<i32> for UBig

fn num_partial_cmp(&self, other: &i32) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<i64> for UBig

fn num_partial_cmp(&self, other: &i64) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<i8> for UBig

fn num_partial_cmp(&self, other: &i8) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<isize> for UBig

fn num_partial_cmp(&self, other: &isize) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<u128> for UBig

fn num_partial_cmp(&self, other: &u128) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<u16> for UBig

fn num_partial_cmp(&self, other: &u16) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<u32> for UBig

fn num_partial_cmp(&self, other: &u32) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<u64> for UBig

fn num_partial_cmp(&self, other: &u64) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<u8> for UBig

fn num_partial_cmp(&self, other: &u8) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl NumOrd<usize> for UBig

fn num_partial_cmp(&self, other: &usize) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

fn num_cmp(&self, other: &Other) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

impl Octal for UBig

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

Formats the value using the given formatter.

impl One for UBig

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl Ord for UBig

fn cmp(&self, other: &UBig) -> Ordering

This method returns an Ordering between self and other.

const fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

const fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<IBig> for UBig

fn eq(&self, other: &IBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for IBig

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for UBig

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for i128

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for i16

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for i32

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for i64

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for i8

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for isize

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for u128

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for u16

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for u32

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for u64

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for u8

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<UBig> for usize

fn eq(&self, other: &UBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i128> for UBig

fn eq(&self, other: &i128) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i16> for UBig

fn eq(&self, other: &i16) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i32> for UBig

fn eq(&self, other: &i32) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i64> for UBig

fn eq(&self, other: &i64) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i8> for UBig

fn eq(&self, other: &i8) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<isize> for UBig

fn eq(&self, other: &isize) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u128> for UBig

fn eq(&self, other: &u128) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u16> for UBig

fn eq(&self, other: &u16) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u32> for UBig

fn eq(&self, other: &u32) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u64> for UBig

fn eq(&self, other: &u64) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u8> for UBig

fn eq(&self, other: &u8) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<usize> for UBig

fn eq(&self, other: &usize) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<IBig> for UBig

fn partial_cmp(&self, other: &IBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for IBig

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for UBig

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for i128

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for i16

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for i32

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for i64

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for i8

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for isize

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for u128

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for u16

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for u32

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for u64

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for u8

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<UBig> for usize

fn partial_cmp(&self, other: &UBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i128> for UBig

fn partial_cmp(&self, other: &i128) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i16> for UBig

fn partial_cmp(&self, other: &i16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i32> for UBig

fn partial_cmp(&self, other: &i32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i64> for UBig

fn partial_cmp(&self, other: &i64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i8> for UBig

fn partial_cmp(&self, other: &i8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<isize> for UBig

fn partial_cmp(&self, other: &isize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u128> for UBig

fn partial_cmp(&self, other: &u128) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u16> for UBig

fn partial_cmp(&self, other: &u16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u32> for UBig

fn partial_cmp(&self, other: &u32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u64> for UBig

fn partial_cmp(&self, other: &u64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u8> for UBig

fn partial_cmp(&self, other: &u8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<usize> for UBig

fn partial_cmp(&self, other: &usize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

const fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

const fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

const fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

const fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Pow<usize> for &UBig

type Output = UBig

The result after applying the operator.

fn pow(self, rhs: usize) -> UBig

Returns self to the power rhs.

impl Pow<usize> for UBig

type Output = UBig

The result after applying the operator.

fn pow(self, rhs: usize) -> UBig

Returns self to the power rhs.

impl PowerOfTwo for UBig

fn is_power_of_two(&self) -> bool

Test if self is a power of two (2^k)

fn next_power_of_two(self) -> UBig

Get the smallest power of two greater than or equal to self.

impl<T> Product<T> for UBigwhere
    UBig: Mul<T, Output = UBig>,

fn product<I: Iterator<Item = T>>(iter: I) -> Self

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

impl<'l, 'r> Rem<&'r ConstDivisor> for &'l UBig

type Output = UBig

The resulting type after applying the % operator.

fn rem(self, rhs: &ConstDivisor) -> UBig

Performs the % operation.

impl<'r> Rem<&'r ConstDivisor> for UBig

type Output = UBig

The resulting type after applying the % operator.

fn rem(self, rhs: &ConstDivisor) -> UBig

Performs the % operation.

impl<'l, 'r> Rem<&'r IBig> for &'l UBig

type Output = UBig

The resulting type after applying the % operator.

fn rem(self, rhs: &IBig) -> UBig

Performs the % operation.

impl<'r> Rem<&'r IBig> for UBig

type Output = UBig

The resulting type after applying the % operator.

fn rem(self, rhs: &IBig) -> UBig

Performs the % operation.

impl<'l, 'r> Rem<&'r UBig> for &'l IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: &UBig) -> IBig

Performs the % operation.

impl<'l, 'r> Rem<&'r UBig> for &'l UBig

type Output = UBig

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'r> Rem<&'r UBig> for IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: &UBig) -> IBig

Performs the % operation.

impl<'r> Rem<&'r UBig> for UBig

type Output = UBig

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l, 'r> Rem<&'r u128> for &'l UBig

type Output = u128

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'r> Rem<&'r u128> for UBig

type Output = u128

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l, 'r> Rem<&'r u16> for &'l UBig

type Output = u16

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'r> Rem<&'r u16> for UBig

type Output = u16

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l, 'r> Rem<&'r u32> for &'l UBig

type Output = u32

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'r> Rem<&'r u32> for UBig

type Output = u32

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l, 'r> Rem<&'r u64> for &'l UBig

type Output = u64

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'r> Rem<&'r u64> for UBig

type Output = u64

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l, 'r> Rem<&'r u8> for &'l UBig

type Output = u8

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'r> Rem<&'r u8> for UBig

type Output = u8

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l, 'r> Rem<&'r usize> for &'l UBig

type Output = usize

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'r> Rem<&'r usize> for UBig

type Output = usize

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l> Rem<IBig> for &'l UBig

type Output = UBig

The resulting type after applying the % operator.

fn rem(self, rhs: IBig) -> UBig

Performs the % operation.

impl Rem<IBig> for UBig

type Output = UBig

The resulting type after applying the % operator.

fn rem(self, rhs: IBig) -> UBig

Performs the % operation.

impl<'l> Rem<UBig> for &'l IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: UBig) -> IBig

Performs the % operation.

impl<'l> Rem<UBig> for &'l UBig

type Output = UBig

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<UBig> for IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: UBig) -> IBig

Performs the % operation.

impl Rem<UBig> for UBig

type Output = UBig

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l> Rem<u128> for &'l UBig

type Output = u128

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<u128> for UBig

type Output = u128

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l> Rem<u16> for &'l UBig

type Output = u16

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<u16> for UBig

type Output = u16

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l> Rem<u32> for &'l UBig

type Output = u32

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<u32> for UBig

type Output = u32

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l> Rem<u64> for &'l UBig

type Output = u64

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<u64> for UBig

type Output = u64

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l> Rem<u8> for &'l UBig

type Output = u8

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<u8> for UBig

type Output = u8

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'l> Rem<usize> for &'l UBig

type Output = usize

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<usize> for UBig

type Output = usize

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'r> RemAssign<&'r ConstDivisor> for UBig

fn rem_assign(&mut self, rhs: &'r ConstDivisor)

Performs the %= operation.

impl RemAssign<&IBig> for UBig

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

Performs the %= operation.

impl RemAssign<&UBig> for IBig

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

Performs the %= operation.

impl RemAssign<&UBig> for UBig

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

Performs the %= operation.

impl RemAssign<IBig> for UBig

fn rem_assign(&mut self, rhs: IBig)

Performs the %= operation.

impl RemAssign<UBig> for IBig

fn rem_assign(&mut self, rhs: UBig)

Performs the %= operation.

impl RemAssign<UBig> for UBig

fn rem_assign(&mut self, rhs: UBig)

Performs the %= operation.

impl<'l, 'r> RemEuclid<&'r UBig> for &'l UBig

type Output = UBig

fn rem_euclid(self, rhs: &UBig) -> UBig

impl<'r> RemEuclid<&'r UBig> for UBig

type Output = UBig

fn rem_euclid(self, rhs: &UBig) -> UBig

impl<'l> RemEuclid<UBig> for &'l UBig

type Output = UBig

fn rem_euclid(self, rhs: UBig) -> UBig

impl RemEuclid<UBig> for UBig

type Output = UBig

fn rem_euclid(self, rhs: UBig) -> UBig

impl Roots for UBig

fn sqrt(&self) -> Self

Returns the truncated principal square root of an integer – ⌊√x⌋

fn nth_root(&self, n: u32) -> Self

Returns the truncated principal nth root of an integer – if x >= 0 { ⌊ⁿ√x⌋ } else { ⌈ⁿ√x⌉ }

fn cbrt(&self) -> Self

Returns the truncated principal cube root of an integer – if x >= 0 { ⌊∛x⌋ } else { ⌈∛x⌉ }

impl SampleUniform for UBig

type Sampler = UniformUBig

The UniformSampler implementation supporting type X.

impl Serialize for UBig

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

Serialize this value into the given Serde serializer.

impl Shl<&usize> for &UBig

type Output = UBig

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> UBig

Performs the << operation.

impl Shl<&usize> for UBig

type Output = UBig

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> UBig

Performs the << operation.

impl Shl<usize> for &UBig

type Output = UBig

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> UBig

Performs the << operation.

impl Shl<usize> for UBig

type Output = UBig

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> UBig

Performs the << operation.

impl ShlAssign<&usize> for UBig

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

Performs the <<= operation.

impl ShlAssign<usize> for UBig

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl Shr<&usize> for &UBig

type Output = UBig

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> UBig

Performs the >> operation.

impl Shr<&usize> for UBig

type Output = UBig

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> UBig

Performs the >> operation.

impl Shr<usize> for &UBig

type Output = UBig

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> UBig

Performs the >> operation.

impl Shr<usize> for UBig

type Output = UBig

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> UBig

Performs the >> operation.

impl ShrAssign<&usize> for UBig

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

Performs the >>= operation.

impl ShrAssign<usize> for UBig

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl<'l, 'r> Sub<&'r IBig> for &'l UBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl<'r> Sub<&'r IBig> for UBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl<'l, 'r> Sub<&'r UBig> for &'l IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> IBig

Performs the - operation.

impl<'l, 'r> Sub<&'r UBig> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r UBig> for &'l u128

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r UBig> for &'l u16

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r UBig> for &'l u32

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r UBig> for &'l u64

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r UBig> for &'l u8

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r UBig> for &'l usize

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'r> Sub<&'r UBig> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> IBig

Performs the - operation.

impl<'r> Sub<&'r UBig> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'r> Sub<&'r UBig> for u128

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'r> Sub<&'r UBig> for u16

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'r> Sub<&'r UBig> for u32

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'r> Sub<&'r UBig> for u64

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'r> Sub<&'r UBig> for u8

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'r> Sub<&'r UBig> for usize

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r u128> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> UBig

Performs the - operation.

impl<'r> Sub<&'r u128> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r u16> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> UBig

Performs the - operation.

impl<'r> Sub<&'r u16> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r u32> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> UBig

Performs the - operation.

impl<'r> Sub<&'r u32> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r u64> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> UBig

Performs the - operation.

impl<'r> Sub<&'r u64> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r u8> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> UBig

Performs the - operation.

impl<'r> Sub<&'r u8> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> UBig

Performs the - operation.

impl<'l, 'r> Sub<&'r usize> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> UBig

Performs the - operation.

impl<'r> Sub<&'r usize> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> UBig

Performs the - operation.

impl<'l> Sub<IBig> for &'l UBig

type Output = IBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<IBig> for UBig

type Output = IBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l> Sub<UBig> for &'l IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> IBig

Performs the - operation.

impl<'l> Sub<UBig> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l> Sub<UBig> for &'l u128

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l> Sub<UBig> for &'l u16

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l> Sub<UBig> for &'l u32

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l> Sub<UBig> for &'l u64

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l> Sub<UBig> for &'l u8

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l> Sub<UBig> for &'l usize

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<UBig> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> IBig

Performs the - operation.

impl Sub<UBig> for UBig

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<UBig> for u128

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<UBig> for u16

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<UBig> for u32

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<UBig> for u64

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<UBig> for u8

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<UBig> for usize

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l> Sub<u128> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> UBig

Performs the - operation.

impl Sub<u128> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> UBig

Performs the - operation.

impl<'l> Sub<u16> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> UBig

Performs the - operation.

impl Sub<u16> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> UBig

Performs the - operation.

impl<'l> Sub<u32> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> UBig

Performs the - operation.

impl Sub<u32> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> UBig

Performs the - operation.

impl<'l> Sub<u64> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> UBig

Performs the - operation.

impl Sub<u64> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> UBig

Performs the - operation.

impl<'l> Sub<u8> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> UBig

Performs the - operation.

impl Sub<u8> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> UBig

Performs the - operation.

impl<'l> Sub<usize> for &'l UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> UBig

Performs the - operation.

impl Sub<usize> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> UBig

Performs the - operation.

impl SubAssign<&UBig> for IBig

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

Performs the -= operation.

impl SubAssign<&UBig> for UBig

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

Performs the -= operation.

impl SubAssign<&u128> for UBig

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

Performs the -= operation.

impl SubAssign<&u16> for UBig

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

Performs the -= operation.

impl SubAssign<&u32> for UBig

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

Performs the -= operation.

impl SubAssign<&u64> for UBig

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

Performs the -= operation.

impl SubAssign<&u8> for UBig

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

Performs the -= operation.

impl SubAssign<&usize> for UBig

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

Performs the -= operation.

impl SubAssign<UBig> for IBig

fn sub_assign(&mut self, rhs: UBig)

Performs the -= operation.

impl SubAssign<UBig> for UBig

fn sub_assign(&mut self, rhs: UBig)

Performs the -= operation.

impl SubAssign<u128> for UBig

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl SubAssign<u16> for UBig

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl SubAssign<u32> for UBig

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl SubAssign<u64> for UBig

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl SubAssign<u8> for UBig

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl SubAssign<usize> for UBig

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl<T> Sum<T> for UBigwhere
    UBig: Add<T, Output = UBig>,

fn sum<I: Iterator<Item = T>>(iter: I) -> Self

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

impl ToPrimitive for UBig

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.

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.

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.

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.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

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.

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.

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.

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.

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.

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.

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.

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.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

impl TryFrom<&IBig> for UBig

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(x: &IBig) -> Result<UBig, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for i128

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<i128, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for i16

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<i16, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for i32

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<i32, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for i64

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<i64, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for i8

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<i8, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for isize

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<isize, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for u128

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<u128, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for u16

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<u16, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for u32

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<u32, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for u64

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<u64, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for u8

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<u8, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&UBig> for usize

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &UBig) -> Result<usize, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for UBig

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(x: IBig) -> Result<UBig, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for i128

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<i128, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for i16

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<i16, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for i32

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<i32, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for i64

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<i64, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for i8

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<i8, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for isize

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<isize, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for u128

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<u128, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for u16

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<u16, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for u32

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<u32, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for u64

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<u64, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for u8

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<u8, OutOfBoundsError>

Performs the conversion.

impl TryFrom<UBig> for usize

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: UBig) -> Result<usize, OutOfBoundsError>

Performs the conversion.

impl TryFrom<i128> for UBig

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: i128) -> Result<UBig, OutOfBoundsError>

Performs the conversion.

impl TryFrom<i16> for UBig

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: i16) -> Result<UBig, OutOfBoundsError>

Performs the conversion.

impl TryFrom<i32> for UBig

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<UBig, OutOfBoundsError>

Performs the conversion.

impl TryFrom<i64> for UBig

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: i64) -> Result<UBig, OutOfBoundsError>

Performs the conversion.

impl TryFrom<i8> for UBig

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: i8) -> Result<UBig, OutOfBoundsError>

Performs the conversion.

impl TryFrom<isize> for UBig

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: isize) -> Result<UBig, OutOfBoundsError>

Performs the conversion.

impl UpperHex for UBig

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

Formats the value using the given formatter.

impl Zero for UBig

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Zeroize for UBig

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Eq for UBig

impl StructuralEq for UBig

impl StructuralPartialEq for UBig

impl Unsigned for UBig