Struct dashu_int::UBig

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

Unsigned big integer.

Arbitrarily large unsigned integer.

Examples

let a = ubig!(a2a123bbb127779cccc123123ccc base 32);
let b = ubig!(0x1231abcd4134);
let c = UBig::from_str_radix("a2a123bbb127779cccc123123ccc", 32)?;
let d = UBig::from_str_radix("1231abcd4134", 16)?;
assert_eq!(a, c);
assert_eq!(b, d);

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!(0b10010).bit(1), true);
assert_eq!(ubig!(0b10010).bit(3), false);
assert_eq!(ubig!(0b10010).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!(0b100);
a.set_bit(0);
assert_eq!(a, ubig!(0b101));
a.set_bit(10);
assert_eq!(a, ubig!(0b10000000101));

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

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

Examples

let mut a = ubig!(0b101);
a.clear_bit(0);
assert_eq!(a, ubig!(0b100));

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!(17).trailing_zeros(), Some(0));
assert_eq!(ubig!(48).trailing_zeros(), Some(4));
assert_eq!(ubig!(0b101000000).trailing_zeros(), Some(6));
assert_eq!(ubig!(0).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!(17).bit_len(), 5);
assert_eq!(ubig!(0b101000000).bit_len(), 9);
assert_eq!(ubig!(0).bit_len(), 0);
let x = ubig!(_0x90ffff3450897234);
assert_eq!(x.bit_len(), x.in_radix(2).to_string().len());

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]), ubig!(0x010203));

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

Construct from big-endian bytes.

Examples

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

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

Return little-endian bytes.

Examples

assert!(ubig!(0).to_le_bytes().is_empty());
assert_eq!(ubig!(0x010203).to_le_bytes(), [3, 2, 1]);

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

Return big-endian bytes.

Examples

assert!(ubig!(0).to_be_bytes().is_empty());
assert_eq!(ubig!(0x010203).to_be_bytes(), [1, 2, 3]);

pub fn to_f32(&self) -> f32

Convert to f32.

Round to nearest, breaking ties to even last bit.

Examples

assert_eq!(ubig!(134).to_f32(), 134.0f32);

pub fn to_f64(&self) -> f64

Convert to f64.

Round to nearest, breaking ties to even last bit.

Examples

assert_eq!(ubig!(134).to_f64(), 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!(83).in_radix(3)), "10002");
assert_eq!(format!("{:+010}", ubig!(35).in_radix(36)), "+00000000z");

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.

Panics

Panics if radix is not between 2 and 36 inclusive.

Examples

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

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

Convert a string with an optional radix prefix to UBig.

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!(0o17));
assert_eq!(UBig::from_str_with_radix_prefix("0x1f")?, ubig!(0x1f));

impl UBig

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

Raises self to the power of exp.

Example

assert_eq!(ubig!(3).pow(3), ubig!(27));

impl UBig

pub const fn zero() -> Self

Create a UBig with value 0

pub const fn is_zero(&self) -> bool

Check whether the value of UBig is 0

pub const fn one() -> Self

Create a UBig with value 1

pub const fn is_one(&self) -> bool

Check whether the value of UBig is 1

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

Representation in Words.

Trait Implementations

impl<'a, 'b> Add<&'a UBig> for &'b u128

type Output = <&'a UBig as Add<&'b u128>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b> Add<&'a UBig> for &'b u16

type Output = <&'a UBig as Add<&'b u16>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b> Add<&'a UBig> for &'b u32

type Output = <&'a UBig as Add<&'b u32>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b> Add<&'a UBig> for &'b u64

type Output = <&'a UBig as Add<&'b u64>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b> Add<&'a UBig> for &'b u8

type Output = <&'a UBig as Add<&'b u8>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b> Add<&'a UBig> for &'b usize

type Output = <&'a UBig as Add<&'b usize>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<u128>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<u16>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<u32>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<u64>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<u8>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<usize>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = IBig

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> 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 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 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<'a> Add<&u128> for &'a UBig

type Output = <&'a UBig as Add<u128>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u128> for UBig

type Output = <UBig as Add<u128>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<u16>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u16> for UBig

type Output = <UBig as Add<u16>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<u32>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u32> for UBig

type Output = <UBig as Add<u32>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<u64>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u64> for UBig

type Output = <UBig as Add<u64>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<u8>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&u8> for UBig

type Output = <UBig as Add<u8>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<usize>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&usize> for UBig

type Output = <UBig as Add<usize>>::Output

The resulting type after applying the + operator.

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

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<'a> Add<UBig> for &'a u128

type Output = <UBig as Add<&'a u128>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <UBig as Add<&'a u16>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <UBig as Add<&'a u32>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <UBig as Add<&'a u64>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <UBig as Add<&'a u8>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <UBig as Add<&'a usize>>::Output

The resulting type after applying the + operator.

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

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 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 as Add<u128>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for u16

type Output = <UBig as Add<u16>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for u32

type Output = <UBig as Add<u32>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for u64

type Output = <UBig as Add<u64>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for u8

type Output = <UBig as Add<u8>>::Output

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for usize

type Output = <UBig as Add<usize>>::Output

The resulting type after applying the + operator.

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

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 Add<u128> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> 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 Add<u16> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> 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 Add<u32> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> 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 Add<u64> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> 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 Add<u8> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> 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 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<'a, 'b> BitAnd<&'a UBig> for &'b u128

type Output = <&'a UBig as BitAnd<&'b u128>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b> BitAnd<&'a UBig> for &'b u16

type Output = <&'a UBig as BitAnd<&'b u16>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b> BitAnd<&'a UBig> for &'b u32

type Output = <&'a UBig as BitAnd<&'b u32>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b> BitAnd<&'a UBig> for &'b u64

type Output = <&'a UBig as BitAnd<&'b u64>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b> BitAnd<&'a UBig> for &'b u8

type Output = <&'a UBig as BitAnd<&'b u8>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b> BitAnd<&'a UBig> for &'b usize

type Output = <&'a UBig as BitAnd<&'b usize>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<u128>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<u16>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<u32>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<u64>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<u8>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<usize>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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<'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<'a> BitAnd<&u128> for &'a UBig

type Output = <&'a UBig as BitAnd<u128>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u128> for UBig

type Output = <UBig as BitAnd<u128>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<u16>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u16> for UBig

type Output = <UBig as BitAnd<u16>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<u32>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u32> for UBig

type Output = <UBig as BitAnd<u32>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<u64>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u64> for UBig

type Output = <UBig as BitAnd<u64>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<u8>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&u8> for UBig

type Output = <UBig as BitAnd<u8>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<usize>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&usize> for UBig

type Output = <UBig as BitAnd<usize>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <UBig as BitAnd<&'a u128>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <UBig as BitAnd<&'a u16>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <UBig as BitAnd<&'a u32>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <UBig as BitAnd<&'a u64>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <UBig as BitAnd<&'a u8>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <UBig as BitAnd<&'a usize>>::Output

The resulting type after applying the & operator.

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

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 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 = <UBig as BitAnd<u128>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for u16

type Output = <UBig as BitAnd<u16>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for u32

type Output = <UBig as BitAnd<u32>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for u64

type Output = <UBig as BitAnd<u64>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for u8

type Output = <UBig as BitAnd<u8>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for usize

type Output = <UBig as BitAnd<usize>>::Output

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u128> for &UBig

type Output = u128

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u128> for UBig

type Output = u128

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u16> for &UBig

type Output = u16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u16> for UBig

type Output = u16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u32> for &UBig

type Output = u32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u32> for UBig

type Output = u32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u64> for &UBig

type Output = u64

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u64> for UBig

type Output = u64

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u8> for &UBig

type Output = u8

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u8> for UBig

type Output = u8

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<usize> for &UBig

type Output = usize

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<usize> for UBig

type Output = usize

The resulting type after applying the & operator.

fn bitand(self, rhs: usize) -> 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 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<'a, 'b> BitOr<&'a UBig> for &'b u128

type Output = <&'a UBig as BitOr<&'b u128>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b> BitOr<&'a UBig> for &'b u16

type Output = <&'a UBig as BitOr<&'b u16>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b> BitOr<&'a UBig> for &'b u32

type Output = <&'a UBig as BitOr<&'b u32>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b> BitOr<&'a UBig> for &'b u64

type Output = <&'a UBig as BitOr<&'b u64>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b> BitOr<&'a UBig> for &'b u8

type Output = <&'a UBig as BitOr<&'b u8>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b> BitOr<&'a UBig> for &'b usize

type Output = <&'a UBig as BitOr<&'b usize>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<u128>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<u16>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<u32>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<u64>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<u8>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<usize>>::Output

The resulting type after applying the | operator.

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

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<'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<'a> BitOr<&u128> for &'a UBig

type Output = <&'a UBig as BitOr<u128>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u128> for UBig

type Output = <UBig as BitOr<u128>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<u16>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u16> for UBig

type Output = <UBig as BitOr<u16>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<u32>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u32> for UBig

type Output = <UBig as BitOr<u32>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<u64>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u64> for UBig

type Output = <UBig as BitOr<u64>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<u8>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&u8> for UBig

type Output = <UBig as BitOr<u8>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<usize>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&usize> for UBig

type Output = <UBig as BitOr<usize>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <UBig as BitOr<&'a u128>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <UBig as BitOr<&'a u16>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <UBig as BitOr<&'a u32>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <UBig as BitOr<&'a u64>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <UBig as BitOr<&'a u8>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <UBig as BitOr<&'a usize>>::Output

The resulting type after applying the | operator.

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

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 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 as BitOr<u128>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for u16

type Output = <UBig as BitOr<u16>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for u32

type Output = <UBig as BitOr<u32>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for u64

type Output = <UBig as BitOr<u64>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for u8

type Output = <UBig as BitOr<u8>>::Output

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for usize

type Output = <UBig as BitOr<usize>>::Output

The resulting type after applying the | operator.

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

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 BitOr<u128> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u128) -> 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 BitOr<u16> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u16) -> 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 BitOr<u32> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> 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 BitOr<u64> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u64) -> 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 BitOr<u8> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: u8) -> 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 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<'a, 'b> BitXor<&'a UBig> for &'b u128

type Output = <&'a UBig as BitXor<&'b u128>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a UBig> for &'b u16

type Output = <&'a UBig as BitXor<&'b u16>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a UBig> for &'b u32

type Output = <&'a UBig as BitXor<&'b u32>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a UBig> for &'b u64

type Output = <&'a UBig as BitXor<&'b u64>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a UBig> for &'b u8

type Output = <&'a UBig as BitXor<&'b u8>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a UBig> for &'b usize

type Output = <&'a UBig as BitXor<&'b usize>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<u128>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<u16>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<u32>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<u64>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<u8>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<usize>>::Output

The resulting type after applying the ^ operator.

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

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<'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<'a> BitXor<&u128> for &'a UBig

type Output = <&'a UBig as BitXor<u128>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u128> for UBig

type Output = <UBig as BitXor<u128>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<u16>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u16> for UBig

type Output = <UBig as BitXor<u16>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<u32>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u32> for UBig

type Output = <UBig as BitXor<u32>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<u64>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u64> for UBig

type Output = <UBig as BitXor<u64>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<u8>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&u8> for UBig

type Output = <UBig as BitXor<u8>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<usize>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&usize> for UBig

type Output = <UBig as BitXor<usize>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <UBig as BitXor<&'a u128>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <UBig as BitXor<&'a u16>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <UBig as BitXor<&'a u32>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <UBig as BitXor<&'a u64>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <UBig as BitXor<&'a u8>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <UBig as BitXor<&'a usize>>::Output

The resulting type after applying the ^ operator.

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

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 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 as BitXor<u128>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for u16

type Output = <UBig as BitXor<u16>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for u32

type Output = <UBig as BitXor<u32>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for u64

type Output = <UBig as BitXor<u64>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for u8

type Output = <UBig as BitXor<u8>>::Output

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for usize

type Output = <UBig as BitXor<usize>>::Output

The resulting type after applying the ^ operator.

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

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 BitXor<u128> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u128) -> 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 BitXor<u16> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u16) -> 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 BitXor<u32> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u32) -> 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 BitXor<u64> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u64) -> 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 BitXor<u8> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: u8) -> 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 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<&'l IBig> for &'l UBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> 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 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<'a> Div<&u128> for &'a UBig

type Output = <&'a UBig as Div<u128>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&u128> for UBig

type Output = <UBig as Div<u128>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = <&'a UBig as Div<u16>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&u16> for UBig

type Output = <UBig as Div<u16>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = <&'a UBig as Div<u32>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&u32> for UBig

type Output = <UBig as Div<u32>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = <&'a UBig as Div<u64>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&u64> for UBig

type Output = <UBig as Div<u64>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = <&'a UBig as Div<u8>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&u8> for UBig

type Output = <UBig as Div<u8>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = <&'a UBig as Div<usize>>::Output

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&usize> for UBig

type Output = <UBig as Div<usize>>::Output

The resulting type after applying the / operator.

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

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 Div<u128> for &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 Div<u16> for &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 Div<u32> for &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 Div<u64> for &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 Div<u8> for &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 Div<usize> for &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 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<'a> DivEuclid<&u128> for &'a UBig

type Output = <&'a UBig as DivEuclid<u128>>::Output

fn div_euclid(self, rhs: &u128) -> Self::Output

impl DivEuclid<&u128> for UBig

type Output = <UBig as DivEuclid<u128>>::Output

fn div_euclid(self, rhs: &u128) -> Self::Output

impl<'a> DivEuclid<&u16> for &'a UBig

type Output = <&'a UBig as DivEuclid<u16>>::Output

fn div_euclid(self, rhs: &u16) -> Self::Output

impl DivEuclid<&u16> for UBig

type Output = <UBig as DivEuclid<u16>>::Output

fn div_euclid(self, rhs: &u16) -> Self::Output

impl<'a> DivEuclid<&u32> for &'a UBig

type Output = <&'a UBig as DivEuclid<u32>>::Output

fn div_euclid(self, rhs: &u32) -> Self::Output

impl DivEuclid<&u32> for UBig

type Output = <UBig as DivEuclid<u32>>::Output

fn div_euclid(self, rhs: &u32) -> Self::Output

impl<'a> DivEuclid<&u64> for &'a UBig

type Output = <&'a UBig as DivEuclid<u64>>::Output

fn div_euclid(self, rhs: &u64) -> Self::Output

impl DivEuclid<&u64> for UBig

type Output = <UBig as DivEuclid<u64>>::Output

fn div_euclid(self, rhs: &u64) -> Self::Output

impl<'a> DivEuclid<&u8> for &'a UBig

type Output = <&'a UBig as DivEuclid<u8>>::Output

fn div_euclid(self, rhs: &u8) -> Self::Output

impl DivEuclid<&u8> for UBig

type Output = <UBig as DivEuclid<u8>>::Output

fn div_euclid(self, rhs: &u8) -> Self::Output

impl<'a> DivEuclid<&usize> for &'a UBig

type Output = <&'a UBig as DivEuclid<usize>>::Output

fn div_euclid(self, rhs: &usize) -> Self::Output

impl DivEuclid<&usize> for UBig

type Output = <UBig as DivEuclid<usize>>::Output

fn div_euclid(self, rhs: &usize) -> Self::Output

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 DivEuclid<u128> for &UBig

type Output = UBig

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

impl DivEuclid<u128> for UBig

type Output = UBig

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

impl DivEuclid<u16> for &UBig

type Output = UBig

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

impl DivEuclid<u16> for UBig

type Output = UBig

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

impl DivEuclid<u32> for &UBig

type Output = UBig

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

impl DivEuclid<u32> for UBig

type Output = UBig

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

impl DivEuclid<u64> for &UBig

type Output = UBig

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

impl DivEuclid<u64> for UBig

type Output = UBig

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

impl DivEuclid<u8> for &UBig

type Output = UBig

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

impl DivEuclid<u8> for UBig

type Output = UBig

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

impl DivEuclid<usize> for &UBig

type Output = UBig

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

impl DivEuclid<usize> for UBig

type Output = UBig

fn div_euclid(self, rhs: usize) -> 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<'a> DivRem<&u128> for &'a UBig

type OutputDiv = <&'a UBig as DivRem<u128>>::OutputDiv

type OutputRem = <&'a UBig as DivRem<u128>>::OutputRem

fn div_rem(self, rhs: &u128) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&u128> for UBig

type OutputDiv = <UBig as DivRem<u128>>::OutputDiv

type OutputRem = <UBig as DivRem<u128>>::OutputRem

fn div_rem(self, rhs: &u128) -> (Self::OutputDiv, Self::OutputRem)

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

type OutputDiv = <&'a UBig as DivRem<u16>>::OutputDiv

type OutputRem = <&'a UBig as DivRem<u16>>::OutputRem

fn div_rem(self, rhs: &u16) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&u16> for UBig

type OutputDiv = <UBig as DivRem<u16>>::OutputDiv

type OutputRem = <UBig as DivRem<u16>>::OutputRem

fn div_rem(self, rhs: &u16) -> (Self::OutputDiv, Self::OutputRem)

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

type OutputDiv = <&'a UBig as DivRem<u32>>::OutputDiv

type OutputRem = <&'a UBig as DivRem<u32>>::OutputRem

fn div_rem(self, rhs: &u32) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&u32> for UBig

type OutputDiv = <UBig as DivRem<u32>>::OutputDiv

type OutputRem = <UBig as DivRem<u32>>::OutputRem

fn div_rem(self, rhs: &u32) -> (Self::OutputDiv, Self::OutputRem)

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

type OutputDiv = <&'a UBig as DivRem<u64>>::OutputDiv

type OutputRem = <&'a UBig as DivRem<u64>>::OutputRem

fn div_rem(self, rhs: &u64) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&u64> for UBig

type OutputDiv = <UBig as DivRem<u64>>::OutputDiv

type OutputRem = <UBig as DivRem<u64>>::OutputRem

fn div_rem(self, rhs: &u64) -> (Self::OutputDiv, Self::OutputRem)

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

type OutputDiv = <&'a UBig as DivRem<u8>>::OutputDiv

type OutputRem = <&'a UBig as DivRem<u8>>::OutputRem

fn div_rem(self, rhs: &u8) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&u8> for UBig

type OutputDiv = <UBig as DivRem<u8>>::OutputDiv

type OutputRem = <UBig as DivRem<u8>>::OutputRem

fn div_rem(self, rhs: &u8) -> (Self::OutputDiv, Self::OutputRem)

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

type OutputDiv = <&'a UBig as DivRem<usize>>::OutputDiv

type OutputRem = <&'a UBig as DivRem<usize>>::OutputRem

fn div_rem(self, rhs: &usize) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&usize> for UBig

type OutputDiv = <UBig as DivRem<usize>>::OutputDiv

type OutputRem = <UBig as DivRem<usize>>::OutputRem

fn div_rem(self, rhs: &usize) -> (Self::OutputDiv, Self::OutputRem)

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 DivRem<u128> for &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 DivRem<u16> for &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 DivRem<u32> for &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 DivRem<u64> for &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 DivRem<u8> for &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 DivRem<usize> for &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<'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<'a> DivRemEuclid<&u128> for &'a UBig

type OutputDiv = <&'a UBig as DivRemEuclid<u128>>::OutputDiv

type OutputRem = <&'a UBig as DivRemEuclid<u128>>::OutputRem

fn div_rem_euclid(self, rhs: &u128) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&u128> for UBig

type OutputDiv = <UBig as DivRemEuclid<u128>>::OutputDiv

type OutputRem = <UBig as DivRemEuclid<u128>>::OutputRem

fn div_rem_euclid(self, rhs: &u128) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&u16> for &'a UBig

type OutputDiv = <&'a UBig as DivRemEuclid<u16>>::OutputDiv

type OutputRem = <&'a UBig as DivRemEuclid<u16>>::OutputRem

fn div_rem_euclid(self, rhs: &u16) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&u16> for UBig

type OutputDiv = <UBig as DivRemEuclid<u16>>::OutputDiv

type OutputRem = <UBig as DivRemEuclid<u16>>::OutputRem

fn div_rem_euclid(self, rhs: &u16) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&u32> for &'a UBig

type OutputDiv = <&'a UBig as DivRemEuclid<u32>>::OutputDiv

type OutputRem = <&'a UBig as DivRemEuclid<u32>>::OutputRem

fn div_rem_euclid(self, rhs: &u32) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&u32> for UBig

type OutputDiv = <UBig as DivRemEuclid<u32>>::OutputDiv

type OutputRem = <UBig as DivRemEuclid<u32>>::OutputRem

fn div_rem_euclid(self, rhs: &u32) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&u64> for &'a UBig

type OutputDiv = <&'a UBig as DivRemEuclid<u64>>::OutputDiv

type OutputRem = <&'a UBig as DivRemEuclid<u64>>::OutputRem

fn div_rem_euclid(self, rhs: &u64) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&u64> for UBig

type OutputDiv = <UBig as DivRemEuclid<u64>>::OutputDiv

type OutputRem = <UBig as DivRemEuclid<u64>>::OutputRem

fn div_rem_euclid(self, rhs: &u64) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&u8> for &'a UBig

type OutputDiv = <&'a UBig as DivRemEuclid<u8>>::OutputDiv

type OutputRem = <&'a UBig as DivRemEuclid<u8>>::OutputRem

fn div_rem_euclid(self, rhs: &u8) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&u8> for UBig

type OutputDiv = <UBig as DivRemEuclid<u8>>::OutputDiv

type OutputRem = <UBig as DivRemEuclid<u8>>::OutputRem

fn div_rem_euclid(self, rhs: &u8) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&usize> for &'a UBig

type OutputDiv = <&'a UBig as DivRemEuclid<usize>>::OutputDiv

type OutputRem = <&'a UBig as DivRemEuclid<usize>>::OutputRem

fn div_rem_euclid(self, rhs: &usize) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&usize> for UBig

type OutputDiv = <UBig as DivRemEuclid<usize>>::OutputDiv

type OutputRem = <UBig as DivRemEuclid<usize>>::OutputRem

fn div_rem_euclid(self, rhs: &usize) -> (Self::OutputDiv, Self::OutputRem)

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 DivRemEuclid<u128> for &UBig

type OutputDiv = UBig

type OutputRem = u128

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

impl DivRemEuclid<u128> for UBig

type OutputDiv = UBig

type OutputRem = u128

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

impl DivRemEuclid<u16> for &UBig

type OutputDiv = UBig

type OutputRem = u16

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

impl DivRemEuclid<u16> for UBig

type OutputDiv = UBig

type OutputRem = u16

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

impl DivRemEuclid<u32> for &UBig

type OutputDiv = UBig

type OutputRem = u32

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

impl DivRemEuclid<u32> for UBig

type OutputDiv = UBig

type OutputRem = u32

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

impl DivRemEuclid<u64> for &UBig

type OutputDiv = UBig

type OutputRem = u64

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

impl DivRemEuclid<u64> for UBig

type OutputDiv = UBig

type OutputRem = u64

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

impl DivRemEuclid<u8> for &UBig

type OutputDiv = UBig

type OutputRem = u8

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

impl DivRemEuclid<u8> for UBig

type OutputDiv = UBig

type OutputRem = u8

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

impl DivRemEuclid<usize> for &UBig

type OutputDiv = UBig

type OutputRem = usize

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

impl DivRemEuclid<usize> for UBig

type OutputDiv = UBig

type OutputRem = usize

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

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 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 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 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<'a, 'b> Mul<&'a UBig> for &'b u128

type Output = <&'a UBig as Mul<&'b u128>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'a UBig> for &'b u16

type Output = <&'a UBig as Mul<&'b u16>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'a UBig> for &'b u32

type Output = <&'a UBig as Mul<&'b u32>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'a UBig> for &'b u64

type Output = <&'a UBig as Mul<&'b u64>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'a UBig> for &'b u8

type Output = <&'a UBig as Mul<&'b u8>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, 'b> Mul<&'a UBig> for &'b usize

type Output = <&'a UBig as Mul<&'b usize>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<u128>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<u16>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<u32>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<u64>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<u8>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<usize>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = IBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> 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 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 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<'a> Mul<&u128> for &'a UBig

type Output = <&'a UBig as Mul<u128>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u128> for UBig

type Output = <UBig as Mul<u128>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<u16>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u16> for UBig

type Output = <UBig as Mul<u16>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<u32>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u32> for UBig

type Output = <UBig as Mul<u32>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<u64>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u64> for UBig

type Output = <UBig as Mul<u64>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<u8>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&u8> for UBig

type Output = <UBig as Mul<u8>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<usize>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&usize> for UBig

type Output = <UBig as Mul<usize>>::Output

The resulting type after applying the * operator.

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

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<'a> Mul<UBig> for &'a u128

type Output = <UBig as Mul<&'a u128>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <UBig as Mul<&'a u16>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <UBig as Mul<&'a u32>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <UBig as Mul<&'a u64>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <UBig as Mul<&'a u8>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <UBig as Mul<&'a usize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> 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 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 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 as Mul<u128>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for u16

type Output = <UBig as Mul<u16>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for u32

type Output = <UBig as Mul<u32>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for u64

type Output = <UBig as Mul<u64>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for u8

type Output = <UBig as Mul<u8>>::Output

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for usize

type Output = <UBig as Mul<usize>>::Output

The resulting type after applying the * operator.

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

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 Mul<u128> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> 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 Mul<u16> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> 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 Mul<u32> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> 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 Mul<u64> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> 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 Mul<u8> for UBig

type Output = UBig

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> 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 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 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 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.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> 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 ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &UBig) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl 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

fn next_power_of_two(self) -> UBig

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

type Output = UBig

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = IBig

The resulting type after applying the % operator.

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

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 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<'a> Rem<&u128> for &'a UBig

type Output = <&'a UBig as Rem<u128>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u128) -> Self::Output

Performs the % operation.

impl Rem<&u128> for UBig

type Output = <UBig as Rem<u128>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u128) -> Self::Output

Performs the % operation.

impl<'a> Rem<&u16> for &'a UBig

type Output = <&'a UBig as Rem<u16>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> Self::Output

Performs the % operation.

impl Rem<&u16> for UBig

type Output = <UBig as Rem<u16>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> Self::Output

Performs the % operation.

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

type Output = <&'a UBig as Rem<u32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> Self::Output

Performs the % operation.

impl Rem<&u32> for UBig

type Output = <UBig as Rem<u32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> Self::Output

Performs the % operation.

impl<'a> Rem<&u64> for &'a UBig

type Output = <&'a UBig as Rem<u64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> Self::Output

Performs the % operation.

impl Rem<&u64> for UBig

type Output = <UBig as Rem<u64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> Self::Output

Performs the % operation.

impl<'a> Rem<&u8> for &'a UBig

type Output = <&'a UBig as Rem<u8>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u8) -> Self::Output

Performs the % operation.

impl Rem<&u8> for UBig

type Output = <UBig as Rem<u8>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &u8) -> Self::Output

Performs the % operation.

impl<'a> Rem<&usize> for &'a UBig

type Output = <&'a UBig as Rem<usize>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &usize) -> Self::Output

Performs the % operation.

impl Rem<&usize> for UBig

type Output = <UBig as Rem<usize>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &usize) -> Self::Output

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 Rem<u128> for &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 Rem<u16> for &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 Rem<u32> for &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 Rem<u64> for &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 Rem<u8> for &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 Rem<usize> for &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 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<&u128> for UBig

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

Performs the %= operation.

impl RemAssign<&u16> for UBig

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

Performs the %= operation.

impl RemAssign<&u32> for UBig

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

Performs the %= operation.

impl RemAssign<&u64> for UBig

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

Performs the %= operation.

impl RemAssign<&u8> for UBig

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

Performs the %= operation.

impl RemAssign<&usize> for UBig

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

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<u128> for UBig

fn rem_assign(&mut self, rhs: u128)

Performs the %= operation.

impl RemAssign<u16> for UBig

fn rem_assign(&mut self, rhs: u16)

Performs the %= operation.

impl RemAssign<u32> for UBig

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl RemAssign<u64> for UBig

fn rem_assign(&mut self, rhs: u64)

Performs the %= operation.

impl RemAssign<u8> for UBig

fn rem_assign(&mut self, rhs: u8)

Performs the %= operation.

impl RemAssign<usize> for UBig

fn rem_assign(&mut self, rhs: usize)

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<'a> RemEuclid<&u128> for &'a UBig

type Output = <&'a UBig as RemEuclid<u128>>::Output

fn rem_euclid(self, rhs: &u128) -> Self::Output

impl RemEuclid<&u128> for UBig

type Output = <UBig as RemEuclid<u128>>::Output

fn rem_euclid(self, rhs: &u128) -> Self::Output

impl<'a> RemEuclid<&u16> for &'a UBig

type Output = <&'a UBig as RemEuclid<u16>>::Output

fn rem_euclid(self, rhs: &u16) -> Self::Output

impl RemEuclid<&u16> for UBig

type Output = <UBig as RemEuclid<u16>>::Output

fn rem_euclid(self, rhs: &u16) -> Self::Output

impl<'a> RemEuclid<&u32> for &'a UBig

type Output = <&'a UBig as RemEuclid<u32>>::Output

fn rem_euclid(self, rhs: &u32) -> Self::Output

impl RemEuclid<&u32> for UBig

type Output = <UBig as RemEuclid<u32>>::Output

fn rem_euclid(self, rhs: &u32) -> Self::Output

impl<'a> RemEuclid<&u64> for &'a UBig

type Output = <&'a UBig as RemEuclid<u64>>::Output

fn rem_euclid(self, rhs: &u64) -> Self::Output

impl RemEuclid<&u64> for UBig

type Output = <UBig as RemEuclid<u64>>::Output

fn rem_euclid(self, rhs: &u64) -> Self::Output

impl<'a> RemEuclid<&u8> for &'a UBig

type Output = <&'a UBig as RemEuclid<u8>>::Output

fn rem_euclid(self, rhs: &u8) -> Self::Output

impl RemEuclid<&u8> for UBig

type Output = <UBig as RemEuclid<u8>>::Output

fn rem_euclid(self, rhs: &u8) -> Self::Output

impl<'a> RemEuclid<&usize> for &'a UBig

type Output = <&'a UBig as RemEuclid<usize>>::Output

fn rem_euclid(self, rhs: &usize) -> Self::Output

impl RemEuclid<&usize> for UBig

type Output = <UBig as RemEuclid<usize>>::Output

fn rem_euclid(self, rhs: &usize) -> Self::Output

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 RemEuclid<u128> for &UBig

type Output = u128

fn rem_euclid(self, rhs: u128) -> u128

impl RemEuclid<u128> for UBig

type Output = u128

fn rem_euclid(self, rhs: u128) -> u128

impl RemEuclid<u16> for &UBig

type Output = u16

fn rem_euclid(self, rhs: u16) -> u16

impl RemEuclid<u16> for UBig

type Output = u16

fn rem_euclid(self, rhs: u16) -> u16

impl RemEuclid<u32> for &UBig

type Output = u32

fn rem_euclid(self, rhs: u32) -> u32

impl RemEuclid<u32> for UBig

type Output = u32

fn rem_euclid(self, rhs: u32) -> u32

impl RemEuclid<u64> for &UBig

type Output = u64

fn rem_euclid(self, rhs: u64) -> u64

impl RemEuclid<u64> for UBig

type Output = u64

fn rem_euclid(self, rhs: u64) -> u64

impl RemEuclid<u8> for &UBig

type Output = u8

fn rem_euclid(self, rhs: u8) -> u8

impl RemEuclid<u8> for UBig

type Output = u8

fn rem_euclid(self, rhs: u8) -> u8

impl RemEuclid<usize> for &UBig

type Output = usize

fn rem_euclid(self, rhs: usize) -> usize

impl RemEuclid<usize> for UBig

type Output = usize

fn rem_euclid(self, rhs: usize) -> usize

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<&'l IBig> for &'l UBig

type Output = IBig

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> 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 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 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<'a> Sub<&u128> for &'a UBig

type Output = <&'a UBig as Sub<u128>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> Self::Output

Performs the - operation.

impl Sub<&u128> for UBig

type Output = <UBig as Sub<u128>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u128) -> Self::Output

Performs the - operation.

impl<'a> Sub<&u16> for &'a UBig

type Output = <&'a UBig as Sub<u16>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Self::Output

Performs the - operation.

impl Sub<&u16> for UBig

type Output = <UBig as Sub<u16>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Self::Output

Performs the - operation.

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

type Output = <&'a UBig as Sub<u32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Self::Output

Performs the - operation.

impl Sub<&u32> for UBig

type Output = <UBig as Sub<u32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Self::Output

Performs the - operation.

impl<'a> Sub<&u64> for &'a UBig

type Output = <&'a UBig as Sub<u64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Self::Output

Performs the - operation.

impl Sub<&u64> for UBig

type Output = <UBig as Sub<u64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Self::Output

Performs the - operation.

impl<'a> Sub<&u8> for &'a UBig

type Output = <&'a UBig as Sub<u8>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> Self::Output

Performs the - operation.

impl Sub<&u8> for UBig

type Output = <UBig as Sub<u8>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &u8) -> Self::Output

Performs the - operation.

impl<'a> Sub<&usize> for &'a UBig

type Output = <&'a UBig as Sub<usize>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> Self::Output

Performs the - operation.

impl Sub<&usize> for UBig

type Output = <UBig as Sub<usize>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> Self::Output

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 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<u128> for &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 Sub<u16> for &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 Sub<u32> for &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 Sub<u64> for &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 Sub<u8> for &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 Sub<usize> for &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 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 Eq for UBig

impl StructuralEq for UBig

impl StructuralPartialEq for UBig

impl Unsigned for UBig