Struct ibig::UBig

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.

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.

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.

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());

pub fn is_power_of_two(&self) -> bool

True if the number is a power of 2.

Examples

assert_eq!(ubig!(0).is_power_of_two(), false);
assert_eq!(ubig!(8).is_power_of_two(), true);
assert_eq!(ubig!(9).is_power_of_two(), false);

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 gcd(&self, rhs: &UBig) -> UBig

Greatest common divisor.

Example

assert_eq!(ubig!(12).gcd(&ubig!(18)), ubig!(6));

Panics

ubig!(0).gcd(&ubig!(0)) panics.

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

Greatest common divisors and the Bézout coefficients.

If a.extended_gcd(&b) == (g, x, y) then:

• x * a + y * b == g
• abs(x) <= max(b, 1)
• abs(y) <= max(a, 1)

Example

let a = ubig!(12);
let b = ubig!(18);
let (g, x, y) = a.extended_gcd(&b);
assert_eq!(&a % &g, ubig!(0));
assert_eq!(&b % &g, ubig!(0));
assert_eq!(&x * IBig::from(&a) + &y * IBig::from(&b), IBig::from(g));
assert!(x.unsigned_abs() <= b);
assert!(y.unsigned_abs() <= a);

Panics

ubig!(0).extended_gcd(&ubig!(0)) panics.

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 MAX_BIT_LEN: usize = 4_294_967_232usize

Maximum length in bits.

UBigs up to this length are supported. Creating a longer number will panic.

This does not guarantee that there is sufficient memory to store numbers up to this length. Memory allocation may fail even for smaller numbers.

The fact that this limit fits in usize guarantees that all bit addressing operations can be performed using usize.

It is typically close to usize::MAX, but the exact value is platform-dependent.

Trait Implementations

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

type Output = <&'a UBig as Add<&'b i128>>::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 i16

type Output = <&'a UBig as Add<&'b i16>>::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 i32

type Output = <&'a UBig as Add<&'b i32>>::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 i64

type Output = <&'a UBig as Add<&'b i64>>::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 i8

type Output = <&'a UBig as Add<&'b i8>>::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 isize

type Output = <&'a UBig as Add<&'b isize>>::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 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 i128

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a UBig as Add<isize>>::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 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 UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i128> for UBig

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i16> for UBig

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i32> for UBig

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i64> for UBig

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&i8> for UBig

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&isize> for UBig

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

The resulting type after applying the + operator.

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

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

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 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 UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for i128

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for i16

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for i32

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for i64

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for i8

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<UBig> for isize

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

The resulting type after applying the + operator.

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

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<i128> for &UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i128> for UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16> for &UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16> for UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i32> for &UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i32> for UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i64> for &UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i64> for UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for &UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<isize> for &UBig

type Output = UBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<isize> for UBig

type Output = UBig

The resulting type after applying the + operator.

fn add(self, rhs: isize) -> 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<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 UBig

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

Performs the += operation.

impl AddAssign<&i128> for UBig

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

Performs the += operation.

impl AddAssign<&i16> for UBig

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

Performs the += operation.

impl AddAssign<&i32> for UBig

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

Performs the += operation.

impl AddAssign<&i64> for UBig

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

Performs the += operation.

impl AddAssign<&i8> for UBig

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

Performs the += operation.

impl AddAssign<&isize> for UBig

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

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 UBig

fn add_assign(&mut self, rhs: UBig)

Performs the += operation.

impl AddAssign<i128> for UBig

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

impl AddAssign<i16> for UBig

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl AddAssign<i32> for UBig

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl AddAssign<i64> for UBig

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl AddAssign<i8> for UBig

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl AddAssign<isize> for UBig

fn add_assign(&mut self, rhs: isize)

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 AndNot<&UBig> for &UBig

type Output = UBig

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

impl AndNot<&UBig> for UBig

type Output = UBig

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

impl<'a> AndNot<&i128> for &'a UBig

type Output = <&'a UBig as AndNot<i128>>::Output

fn and_not(self, rhs: &i128) -> Self::Output

impl AndNot<&i128> for UBig

type Output = <UBig as AndNot<i128>>::Output

fn and_not(self, rhs: &i128) -> Self::Output

impl<'a> AndNot<&i16> for &'a UBig

type Output = <&'a UBig as AndNot<i16>>::Output

fn and_not(self, rhs: &i16) -> Self::Output

impl AndNot<&i16> for UBig

type Output = <UBig as AndNot<i16>>::Output

fn and_not(self, rhs: &i16) -> Self::Output

impl<'a> AndNot<&i32> for &'a UBig

type Output = <&'a UBig as AndNot<i32>>::Output

fn and_not(self, rhs: &i32) -> Self::Output

impl AndNot<&i32> for UBig

type Output = <UBig as AndNot<i32>>::Output

fn and_not(self, rhs: &i32) -> Self::Output

impl<'a> AndNot<&i64> for &'a UBig

type Output = <&'a UBig as AndNot<i64>>::Output

fn and_not(self, rhs: &i64) -> Self::Output

impl AndNot<&i64> for UBig

type Output = <UBig as AndNot<i64>>::Output

fn and_not(self, rhs: &i64) -> Self::Output

impl<'a> AndNot<&i8> for &'a UBig

type Output = <&'a UBig as AndNot<i8>>::Output

fn and_not(self, rhs: &i8) -> Self::Output

impl AndNot<&i8> for UBig

type Output = <UBig as AndNot<i8>>::Output

fn and_not(self, rhs: &i8) -> Self::Output

impl<'a> AndNot<&isize> for &'a UBig

type Output = <&'a UBig as AndNot<isize>>::Output

fn and_not(self, rhs: &isize) -> Self::Output

impl AndNot<&isize> for UBig

type Output = <UBig as AndNot<isize>>::Output

fn and_not(self, rhs: &isize) -> Self::Output

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

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

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

impl AndNot<&u128> for UBig

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

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

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

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

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

impl AndNot<&u16> for UBig

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

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

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

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

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

impl AndNot<&u32> for UBig

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

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

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

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

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

impl AndNot<&u64> for UBig

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

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

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

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

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

impl AndNot<&u8> for UBig

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

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

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

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

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

impl AndNot<&usize> for UBig

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

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

impl AndNot<UBig> for &UBig

type Output = UBig

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

impl AndNot<UBig> for UBig

type Output = UBig

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

impl AndNot<i128> for &UBig

type Output = UBig

fn and_not(self, rhs: i128) -> UBig

impl AndNot<i128> for UBig

type Output = UBig

fn and_not(self, rhs: i128) -> UBig

impl AndNot<i16> for &UBig

type Output = UBig

fn and_not(self, rhs: i16) -> UBig

impl AndNot<i16> for UBig

type Output = UBig

fn and_not(self, rhs: i16) -> UBig

impl AndNot<i32> for &UBig

type Output = UBig

fn and_not(self, rhs: i32) -> UBig

impl AndNot<i32> for UBig

type Output = UBig

fn and_not(self, rhs: i32) -> UBig

impl AndNot<i64> for &UBig

type Output = UBig

fn and_not(self, rhs: i64) -> UBig

impl AndNot<i64> for UBig

type Output = UBig

fn and_not(self, rhs: i64) -> UBig

impl AndNot<i8> for &UBig

type Output = UBig

fn and_not(self, rhs: i8) -> UBig

impl AndNot<i8> for UBig

type Output = UBig

fn and_not(self, rhs: i8) -> UBig

impl AndNot<isize> for &UBig

type Output = UBig

fn and_not(self, rhs: isize) -> UBig

impl AndNot<isize> for UBig

type Output = UBig

fn and_not(self, rhs: isize) -> UBig

impl AndNot<u128> for &UBig

type Output = UBig

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

impl AndNot<u128> for UBig

type Output = UBig

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

impl AndNot<u16> for &UBig

type Output = UBig

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

impl AndNot<u16> for UBig

type Output = UBig

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

impl AndNot<u32> for &UBig

type Output = UBig

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

impl AndNot<u32> for UBig

type Output = UBig

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

impl AndNot<u64> for &UBig

type Output = UBig

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

impl AndNot<u64> for UBig

type Output = UBig

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

impl AndNot<u8> for &UBig

type Output = UBig

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

impl AndNot<u8> for UBig

type Output = UBig

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

impl AndNot<usize> for &UBig

type Output = UBig

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

impl AndNot<usize> for UBig

type Output = UBig

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

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 i128

type Output = <&'a UBig as BitAnd<&'b i128>>::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 i16

type Output = <&'a UBig as BitAnd<&'b i16>>::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 i32

type Output = <&'a UBig as BitAnd<&'b i32>>::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 i64

type Output = <&'a UBig as BitAnd<&'b i64>>::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 i8

type Output = <&'a UBig as BitAnd<&'b i8>>::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 isize

type Output = <&'a UBig as BitAnd<&'b isize>>::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 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 i128

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a UBig as BitAnd<isize>>::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 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 UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i128> for UBig

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i16> for UBig

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i32> for UBig

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i64> for UBig

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&i8> for UBig

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&isize> for UBig

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

The resulting type after applying the & operator.

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

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 i128

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

fn bitand(self, rhs: UBig) -> 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 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 UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for i128

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for i16

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for i32

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for i64

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for i8

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<UBig> for isize

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

The resulting type after applying the & operator.

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

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<i128> for &UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i128> for UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i16> for &UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i16> for UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i32> for &UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i32> for UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i64> for &UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i64> for UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i8> for &UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i8> for UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<isize> for &UBig

type Output = UBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<isize> for UBig

type Output = UBig

The resulting type after applying the & operator.

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

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<&i128> for UBig

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

Performs the &= operation.

impl BitAndAssign<&i16> for UBig

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

Performs the &= operation.

impl BitAndAssign<&i32> for UBig

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

Performs the &= operation.

impl BitAndAssign<&i64> for UBig

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

Performs the &= operation.

impl BitAndAssign<&i8> for UBig

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

Performs the &= operation.

impl BitAndAssign<&isize> for UBig

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

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<i128> for UBig

fn bitand_assign(&mut self, rhs: i128)

Performs the &= operation.

impl BitAndAssign<i16> for UBig

fn bitand_assign(&mut self, rhs: i16)

Performs the &= operation.

impl BitAndAssign<i32> for UBig

fn bitand_assign(&mut self, rhs: i32)

Performs the &= operation.

impl BitAndAssign<i64> for UBig

fn bitand_assign(&mut self, rhs: i64)

Performs the &= operation.

impl BitAndAssign<i8> for UBig

fn bitand_assign(&mut self, rhs: i8)

Performs the &= operation.

impl BitAndAssign<isize> for UBig

fn bitand_assign(&mut self, rhs: isize)

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 i128

type Output = <&'a UBig as BitOr<&'b i128>>::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 i16

type Output = <&'a UBig as BitOr<&'b i16>>::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 i32

type Output = <&'a UBig as BitOr<&'b i32>>::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 i64

type Output = <&'a UBig as BitOr<&'b i64>>::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 i8

type Output = <&'a UBig as BitOr<&'b i8>>::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 isize

type Output = <&'a UBig as BitOr<&'b isize>>::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 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 i128

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a UBig as BitOr<isize>>::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 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 UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i128> for UBig

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i16> for UBig

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i32> for UBig

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i64> for UBig

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&i8> for UBig

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&isize> for UBig

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

The resulting type after applying the | operator.

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

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 i128

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for i128

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for i16

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for i32

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for i64

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for i8

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<UBig> for isize

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

The resulting type after applying the | operator.

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

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<i128> for &UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i128> for UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i16> for &UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i16> for UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i32> for &UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i32> for UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i64> for &UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i64> for UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i8> for &UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i8> for UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<isize> for &UBig

type Output = UBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<isize> for UBig

type Output = UBig

The resulting type after applying the | operator.

fn bitor(self, rhs: isize) -> 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<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<&i128> for UBig

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

Performs the |= operation.

impl BitOrAssign<&i16> for UBig

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

Performs the |= operation.

impl BitOrAssign<&i32> for UBig

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

Performs the |= operation.

impl BitOrAssign<&i64> for UBig

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

Performs the |= operation.

impl BitOrAssign<&i8> for UBig

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

Performs the |= operation.

impl BitOrAssign<&isize> for UBig

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

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<i128> for UBig

fn bitor_assign(&mut self, rhs: i128)

Performs the |= operation.

impl BitOrAssign<i16> for UBig

fn bitor_assign(&mut self, rhs: i16)

Performs the |= operation.

impl BitOrAssign<i32> for UBig

fn bitor_assign(&mut self, rhs: i32)

Performs the |= operation.

impl BitOrAssign<i64> for UBig

fn bitor_assign(&mut self, rhs: i64)

Performs the |= operation.

impl BitOrAssign<i8> for UBig

fn bitor_assign(&mut self, rhs: i8)

Performs the |= operation.

impl BitOrAssign<isize> for UBig

fn bitor_assign(&mut self, rhs: isize)

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 i128

type Output = <&'a UBig as BitXor<&'b i128>>::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 i16

type Output = <&'a UBig as BitXor<&'b i16>>::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 i32

type Output = <&'a UBig as BitXor<&'b i32>>::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 i64

type Output = <&'a UBig as BitXor<&'b i64>>::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 i8

type Output = <&'a UBig as BitXor<&'b i8>>::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 isize

type Output = <&'a UBig as BitXor<&'b isize>>::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 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 i128

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a UBig as BitXor<isize>>::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 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 UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i128> for UBig

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i16> for UBig

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i32> for UBig

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i64> for UBig

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&i8> for UBig

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&isize> for UBig

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

The resulting type after applying the ^ operator.

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

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 i128

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for i128

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for i16

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for i32

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for i64

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for i8

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<UBig> for isize

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

The resulting type after applying the ^ operator.

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

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<i128> for &UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i128> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i16> for &UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i16> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i32> for &UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i32> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i64> for &UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i64> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i8> for &UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i8> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<isize> for &UBig

type Output = UBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<isize> for UBig

type Output = UBig

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: isize) -> 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<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<&i128> for UBig

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

Performs the ^= operation.

impl BitXorAssign<&i16> for UBig

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

Performs the ^= operation.

impl BitXorAssign<&i32> for UBig

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

Performs the ^= operation.

impl BitXorAssign<&i64> for UBig

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

Performs the ^= operation.

impl BitXorAssign<&i8> for UBig

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

Performs the ^= operation.

impl BitXorAssign<&isize> for UBig

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

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<i128> for UBig

fn bitxor_assign(&mut self, rhs: i128)

Performs the ^= operation.

impl BitXorAssign<i16> for UBig

fn bitxor_assign(&mut self, rhs: i16)

Performs the ^= operation.

impl BitXorAssign<i32> for UBig

fn bitxor_assign(&mut self, rhs: i32)

Performs the ^= operation.

impl BitXorAssign<i64> for UBig

fn bitxor_assign(&mut self, rhs: i64)

Performs the ^= operation.

impl BitXorAssign<i8> for UBig

fn bitxor_assign(&mut self, rhs: i8)

Performs the ^= operation.

impl BitXorAssign<isize> for UBig

fn bitxor_assign(&mut self, rhs: isize)

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&i128> for UBig

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&i16> for UBig

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&i32> for UBig

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&i64> for UBig

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&i8> for UBig

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&isize> for UBig

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

The resulting type after applying the / operator.

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

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

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i128> for &UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i128> for UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i16> for &UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i16> for UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i32> for &UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i32> for UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i64> for &UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i64> for UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i8> for &UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i8> for UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<isize> for &UBig

type Output = UBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<isize> for UBig

type Output = UBig

The resulting type after applying the / operator.

fn div(self, rhs: isize) -> 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 UBig

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

Performs the /= operation.

impl DivAssign<&i128> for UBig

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

Performs the /= operation.

impl DivAssign<&i16> for UBig

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

Performs the /= operation.

impl DivAssign<&i32> for UBig

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

Performs the /= operation.

impl DivAssign<&i64> for UBig

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

Performs the /= operation.

impl DivAssign<&i8> for UBig

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

Performs the /= operation.

impl DivAssign<&isize> for UBig

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

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 UBig

fn div_assign(&mut self, rhs: UBig)

Performs the /= operation.

impl DivAssign<i128> for UBig

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl DivAssign<i16> for UBig

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl DivAssign<i32> for UBig

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl DivAssign<i64> for UBig

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl DivAssign<i8> for UBig

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl DivAssign<isize> for UBig

fn div_assign(&mut self, rhs: isize)

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 DivEuclid<&UBig> for &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<'a> DivEuclid<&i128> for &'a UBig

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

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

impl DivEuclid<&i128> for UBig

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

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

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

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

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

impl DivEuclid<&i16> for UBig

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

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

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

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

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

impl DivEuclid<&i32> for UBig

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

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

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

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

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

impl DivEuclid<&i64> for UBig

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

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

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

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

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

impl DivEuclid<&i8> for UBig

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

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

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

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

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

impl DivEuclid<&isize> for UBig

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

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

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

type Output = UBig

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

impl DivEuclid<i128> for UBig

type Output = UBig

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

impl DivEuclid<i16> for &UBig

type Output = UBig

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

impl DivEuclid<i16> for UBig

type Output = UBig

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

impl DivEuclid<i32> for &UBig

type Output = UBig

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

impl DivEuclid<i32> for UBig

type Output = UBig

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

impl DivEuclid<i64> for &UBig

type Output = UBig

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

impl DivEuclid<i64> for UBig

type Output = UBig

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

impl DivEuclid<i8> for &UBig

type Output = UBig

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

impl DivEuclid<i8> for UBig

type Output = UBig

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

impl DivEuclid<isize> for &UBig

type Output = UBig

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

impl DivEuclid<isize> for UBig

type Output = UBig

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

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

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

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

impl DivRem<&i128> for UBig

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

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

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

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

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

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

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

impl DivRem<&i16> for UBig

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

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

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

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

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

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

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

impl DivRem<&i32> for UBig

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

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

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

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

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

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

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

impl DivRem<&i64> for UBig

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

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

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

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

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

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

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

impl DivRem<&i8> for UBig

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

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

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

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

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

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

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

impl DivRem<&isize> for UBig

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

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

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

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 DivRem<UBig> for &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<i128> for &UBig

type OutputDiv = UBig

type OutputRem = i128

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

impl DivRem<i128> for UBig

type OutputDiv = UBig

type OutputRem = i128

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

impl DivRem<i16> for &UBig

type OutputDiv = UBig

type OutputRem = i16

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

impl DivRem<i16> for UBig

type OutputDiv = UBig

type OutputRem = i16

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

impl DivRem<i32> for &UBig

type OutputDiv = UBig

type OutputRem = i32

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

impl DivRem<i32> for UBig

type OutputDiv = UBig

type OutputRem = i32

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

impl DivRem<i64> for &UBig

type OutputDiv = UBig

type OutputRem = i64

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

impl DivRem<i64> for UBig

type OutputDiv = UBig

type OutputRem = i64

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

impl DivRem<i8> for &UBig

type OutputDiv = UBig

type OutputRem = i8

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

impl DivRem<i8> for UBig

type OutputDiv = UBig

type OutputRem = i8

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

impl DivRem<isize> for &UBig

type OutputDiv = UBig

type OutputRem = isize

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

impl DivRem<isize> for UBig

type OutputDiv = UBig

type OutputRem = isize

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

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 DivRemEuclid<&UBig> for &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<'a> DivRemEuclid<&i128> for &'a UBig

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

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

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

impl DivRemEuclid<&i128> for UBig

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

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

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

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

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

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

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

impl DivRemEuclid<&i16> for UBig

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

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

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

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

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

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

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

impl DivRemEuclid<&i32> for UBig

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

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

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

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

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

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

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

impl DivRemEuclid<&i64> for UBig

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

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

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

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

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

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

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

impl DivRemEuclid<&i8> for UBig

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

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

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

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

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

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

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

impl DivRemEuclid<&isize> for UBig

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

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

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

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

type OutputDiv = UBig

type OutputRem = i128

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

impl DivRemEuclid<i128> for UBig

type OutputDiv = UBig

type OutputRem = i128

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

impl DivRemEuclid<i16> for &UBig

type OutputDiv = UBig

type OutputRem = i16

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

impl DivRemEuclid<i16> for UBig

type OutputDiv = UBig

type OutputRem = i16

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

impl DivRemEuclid<i32> for &UBig

type OutputDiv = UBig

type OutputRem = i32

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

impl DivRemEuclid<i32> for UBig

type OutputDiv = UBig

type OutputRem = i32

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

impl DivRemEuclid<i64> for &UBig

type OutputDiv = UBig

type OutputRem = i64

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

impl DivRemEuclid<i64> for UBig

type OutputDiv = UBig

type OutputRem = i64

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

impl DivRemEuclid<i8> for &UBig

type OutputDiv = UBig

type OutputRem = i8

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

impl DivRemEuclid<i8> for UBig

type OutputDiv = UBig

type OutputRem = i8

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

impl DivRemEuclid<isize> for &UBig

type OutputDiv = UBig

type OutputRem = isize

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

impl DivRemEuclid<isize> for UBig

type OutputDiv = UBig

type OutputRem = isize

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

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 i128

type Output = <&'a UBig as Mul<&'b i128>>::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 i16

type Output = <&'a UBig as Mul<&'b i16>>::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 i32

type Output = <&'a UBig as Mul<&'b i32>>::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 i64

type Output = <&'a UBig as Mul<&'b i64>>::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 i8

type Output = <&'a UBig as Mul<&'b i8>>::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 isize

type Output = <&'a UBig as Mul<&'b isize>>::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 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 i128

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = <&'a UBig as Mul<isize>>::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 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 UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i128> for UBig

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i16> for UBig

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i32> for UBig

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i64> for UBig

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&i8> for UBig

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&isize> for UBig

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

The resulting type after applying the * operator.

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

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

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 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 UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for i128

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for i16

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for i32

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for i64

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for i8

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

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<UBig> for isize

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

The resulting type after applying the * operator.

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

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<i128> for &UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i128> for UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i16> for &UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i16> for UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i32> for &UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i32> for UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i64> for &UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i64> for UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i8> for &UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i8> for UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<isize> for &UBig

type Output = UBig

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<isize> for UBig

type Output = UBig

The resulting type after applying the * operator.

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

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

Performs the *= operation.

impl MulAssign<&i128> for UBig

fn mul_assign(&mut self, rhs: &i128)

Performs the *= operation.

impl MulAssign<&i16> for UBig

fn mul_assign(&mut self, rhs: &i16)

Performs the *= operation.

impl MulAssign<&i32> for UBig

fn mul_assign(&mut self, rhs: &i32)

Performs the *= operation.

impl MulAssign<&i64> for UBig

fn mul_assign(&mut self, rhs: &i64)

Performs the *= operation.

impl MulAssign<&i8> for UBig

fn mul_assign(&mut self, rhs: &i8)

Performs the *= operation.

impl MulAssign<&isize> for UBig

fn mul_assign(&mut self, rhs: &isize)

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 UBig

fn mul_assign(&mut self, rhs: UBig)

Performs the *= operation.

impl MulAssign<i128> for UBig

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl MulAssign<i16> for UBig

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl MulAssign<i32> for UBig

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign<i64> for UBig

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl MulAssign<i8> for UBig

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl MulAssign<isize> for UBig

fn mul_assign(&mut self, rhs: isize)

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 NextPowerOfTwo for &UBig

type Output = UBig

fn next_power_of_two(self) -> UBig

impl NextPowerOfTwo for UBig

type Output = UBig

fn next_power_of_two(self) -> UBig

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 set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> boolwhere
    Self: PartialEq<Self>,

Returns true if self is equal to the multiplicative identity.

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) -> Selfwhere
    Self: PartialOrd<Self>,

Restrict a value to a certain interval.

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: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

type Output = <&'a UBig as Rem<i128>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i128) -> Self::Output

Performs the % operation.

impl Rem<&i128> for UBig

type Output = <UBig as Rem<i128>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i128) -> Self::Output

Performs the % operation.

impl<'a> Rem<&i16> for &'a UBig

type Output = <&'a UBig as Rem<i16>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> Self::Output

Performs the % operation.

impl Rem<&i16> for UBig

type Output = <UBig as Rem<i16>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> Self::Output

Performs the % operation.

impl<'a> Rem<&i32> for &'a UBig

type Output = <&'a UBig as Rem<i32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> Self::Output

Performs the % operation.

impl Rem<&i32> for UBig

type Output = <UBig as Rem<i32>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> Self::Output

Performs the % operation.

impl<'a> Rem<&i64> for &'a UBig

type Output = <&'a UBig as Rem<i64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> Self::Output

Performs the % operation.

impl Rem<&i64> for UBig

type Output = <UBig as Rem<i64>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> Self::Output

Performs the % operation.

impl<'a> Rem<&i8> for &'a UBig

type Output = <&'a UBig as Rem<i8>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> Self::Output

Performs the % operation.

impl Rem<&i8> for UBig

type Output = <UBig as Rem<i8>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &i8) -> Self::Output

Performs the % operation.

impl<'a> Rem<&isize> for &'a UBig

type Output = <&'a UBig as Rem<isize>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> Self::Output

Performs the % operation.

impl Rem<&isize> for UBig

type Output = <UBig as Rem<isize>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &isize) -> Self::Output

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

type Output = UBig

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem<i128> for &UBig

type Output = i128

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> i128

Performs the % operation.

impl Rem<i128> for UBig

type Output = i128

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> i128

Performs the % operation.

impl Rem<i16> for &UBig

type Output = i16

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> i16

Performs the % operation.

impl Rem<i16> for UBig

type Output = i16

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> i16

Performs the % operation.

impl Rem<i32> for &UBig

type Output = i32

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> i32

Performs the % operation.

impl Rem<i32> for UBig

type Output = i32

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> i32

Performs the % operation.

impl Rem<i64> for &UBig

type Output = i64

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> i64

Performs the % operation.

impl Rem<i64> for UBig

type Output = i64

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> i64

Performs the % operation.

impl Rem<i8> for &UBig

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> i8

Performs the % operation.

impl Rem<i8> for UBig

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> i8

Performs the % operation.

impl Rem<isize> for &UBig

type Output = isize

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> isize

Performs the % operation.

impl Rem<isize> for UBig

type Output = isize

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> isize

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 UBig

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

Performs the %= operation.

impl RemAssign<&i128> for UBig

fn rem_assign(&mut self, rhs: &i128)

Performs the %= operation.

impl RemAssign<&i16> for UBig

fn rem_assign(&mut self, rhs: &i16)

Performs the %= operation.

impl RemAssign<&i32> for UBig

fn rem_assign(&mut self, rhs: &i32)

Performs the %= operation.

impl RemAssign<&i64> for UBig

fn rem_assign(&mut self, rhs: &i64)

Performs the %= operation.

impl RemAssign<&i8> for UBig

fn rem_assign(&mut self, rhs: &i8)

Performs the %= operation.

impl RemAssign<&isize> for UBig

fn rem_assign(&mut self, rhs: &isize)

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 UBig

fn rem_assign(&mut self, rhs: UBig)

Performs the %= operation.

impl RemAssign<i128> for UBig

fn rem_assign(&mut self, rhs: i128)

Performs the %= operation.

impl RemAssign<i16> for UBig

fn rem_assign(&mut self, rhs: i16)

Performs the %= operation.

impl RemAssign<i32> for UBig

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl RemAssign<i64> for UBig

fn rem_assign(&mut self, rhs: i64)

Performs the %= operation.

impl RemAssign<i8> for UBig

fn rem_assign(&mut self, rhs: i8)

Performs the %= operation.

impl RemAssign<isize> for UBig

fn rem_assign(&mut self, rhs: isize)

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 RemEuclid<&UBig> for &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<'a> RemEuclid<&i128> for &'a UBig

type Output = <&'a UBig as RemEuclid<i128>>::Output

fn rem_euclid(self, rhs: &i128) -> Self::Output

impl RemEuclid<&i128> for UBig

type Output = <UBig as RemEuclid<i128>>::Output

fn rem_euclid(self, rhs: &i128) -> Self::Output

impl<'a> RemEuclid<&i16> for &'a UBig

type Output = <&'a UBig as RemEuclid<i16>>::Output

fn rem_euclid(self, rhs: &i16) -> Self::Output

impl RemEuclid<&i16> for UBig

type Output = <UBig as RemEuclid<i16>>::Output

fn rem_euclid(self, rhs: &i16) -> Self::Output

impl<'a> RemEuclid<&i32> for &'a UBig

type Output = <&'a UBig as RemEuclid<i32>>::Output

fn rem_euclid(self, rhs: &i32) -> Self::Output

impl RemEuclid<&i32> for UBig

type Output = <UBig as RemEuclid<i32>>::Output

fn rem_euclid(self, rhs: &i32) -> Self::Output

impl<'a> RemEuclid<&i64> for &'a UBig

type Output = <&'a UBig as RemEuclid<i64>>::Output

fn rem_euclid(self, rhs: &i64) -> Self::Output

impl RemEuclid<&i64> for UBig

type Output = <UBig as RemEuclid<i64>>::Output

fn rem_euclid(self, rhs: &i64) -> Self::Output

impl<'a> RemEuclid<&i8> for &'a UBig

type Output = <&'a UBig as RemEuclid<i8>>::Output

fn rem_euclid(self, rhs: &i8) -> Self::Output

impl RemEuclid<&i8> for UBig

type Output = <UBig as RemEuclid<i8>>::Output

fn rem_euclid(self, rhs: &i8) -> Self::Output

impl<'a> RemEuclid<&isize> for &'a UBig

type Output = <&'a UBig as RemEuclid<isize>>::Output

fn rem_euclid(self, rhs: &isize) -> Self::Output

impl RemEuclid<&isize> for UBig

type Output = <UBig as RemEuclid<isize>>::Output

fn rem_euclid(self, rhs: &isize) -> Self::Output

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 RemEuclid<UBig> for &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<i128> for &UBig

type Output = i128

fn rem_euclid(self, rhs: i128) -> i128

impl RemEuclid<i128> for UBig

type Output = i128

fn rem_euclid(self, rhs: i128) -> i128

impl RemEuclid<i16> for &UBig

type Output = i16

fn rem_euclid(self, rhs: i16) -> i16

impl RemEuclid<i16> for UBig

type Output = i16

fn rem_euclid(self, rhs: i16) -> i16

impl RemEuclid<i32> for &UBig

type Output = i32

fn rem_euclid(self, rhs: i32) -> i32

impl RemEuclid<i32> for UBig

type Output = i32

fn rem_euclid(self, rhs: i32) -> i32

impl RemEuclid<i64> for &UBig

type Output = i64

fn rem_euclid(self, rhs: i64) -> i64

impl RemEuclid<i64> for UBig

type Output = i64

fn rem_euclid(self, rhs: i64) -> i64

impl RemEuclid<i8> for &UBig

type Output = i8

fn rem_euclid(self, rhs: i8) -> i8

impl RemEuclid<i8> for UBig

type Output = i8

fn rem_euclid(self, rhs: i8) -> i8

impl RemEuclid<isize> for &UBig

type Output = isize

fn rem_euclid(self, rhs: isize) -> isize

impl RemEuclid<isize> for UBig

type Output = isize

fn rem_euclid(self, rhs: isize) -> isize

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 Sub<&UBig> for &UBig

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&UBig> for UBig

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub<&i128> for &'a UBig

type Output = <&'a UBig as Sub<i128>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> Self::Output

Performs the - operation.

impl Sub<&i128> for UBig

type Output = <UBig as Sub<i128>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i128) -> Self::Output

Performs the - operation.

impl<'a> Sub<&i16> for &'a UBig

type Output = <&'a UBig as Sub<i16>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Self::Output

Performs the - operation.

impl Sub<&i16> for UBig

type Output = <UBig as Sub<i16>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Self::Output

Performs the - operation.

impl<'a> Sub<&i32> for &'a UBig

type Output = <&'a UBig as Sub<i32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Self::Output

Performs the - operation.

impl Sub<&i32> for UBig

type Output = <UBig as Sub<i32>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<&i64> for &'a UBig

type Output = <&'a UBig as Sub<i64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Self::Output

Performs the - operation.

impl Sub<&i64> for UBig

type Output = <UBig as Sub<i64>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Self::Output

Performs the - operation.

impl<'a> Sub<&i8> for &'a UBig

type Output = <&'a UBig as Sub<i8>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> Self::Output

Performs the - operation.

impl Sub<&i8> for UBig

type Output = <UBig as Sub<i8>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &i8) -> Self::Output

Performs the - operation.

impl<'a> Sub<&isize> for &'a UBig

type Output = <&'a UBig as Sub<isize>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Self::Output

Performs the - operation.

impl Sub<&isize> for UBig

type Output = <UBig as Sub<isize>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &isize) -> Self::Output

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 Sub<UBig> for &UBig

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<UBig> for UBig

type Output = UBig

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<i128> for &UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> UBig

Performs the - operation.

impl Sub<i128> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> UBig

Performs the - operation.

impl Sub<i16> for &UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> UBig

Performs the - operation.

impl Sub<i16> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> UBig

Performs the - operation.

impl Sub<i32> for &UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> UBig

Performs the - operation.

impl Sub<i32> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> UBig

Performs the - operation.

impl Sub<i64> for &UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> UBig

Performs the - operation.

impl Sub<i64> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> UBig

Performs the - operation.

impl Sub<i8> for &UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> UBig

Performs the - operation.

impl Sub<i8> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> UBig

Performs the - operation.

impl Sub<isize> for &UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> UBig

Performs the - operation.

impl Sub<isize> for UBig

type Output = UBig

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> 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 UBig

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

Performs the -= operation.

impl SubAssign<&i128> for UBig

fn sub_assign(&mut self, rhs: &i128)

Performs the -= operation.

impl SubAssign<&i16> for UBig

fn sub_assign(&mut self, rhs: &i16)

Performs the -= operation.

impl SubAssign<&i32> for UBig

fn sub_assign(&mut self, rhs: &i32)

Performs the -= operation.

impl SubAssign<&i64> for UBig

fn sub_assign(&mut self, rhs: &i64)

Performs the -= operation.

impl SubAssign<&i8> for UBig

fn sub_assign(&mut self, rhs: &i8)

Performs the -= operation.

impl SubAssign<&isize> for UBig

fn sub_assign(&mut self, rhs: &isize)

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 UBig

fn sub_assign(&mut self, rhs: UBig)

Performs the -= operation.

impl SubAssign<i128> for UBig

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl SubAssign<i16> for UBig

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl SubAssign<i32> for UBig

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign<i64> for UBig

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl SubAssign<i8> for UBig

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl SubAssign<isize> for UBig

fn sub_assign(&mut self, rhs: isize)

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