Struct ibig::IBig

pub struct IBig { /* private fields */ }

Signed big integer.

Arbitrarily large signed integer.

Examples

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

Implementations

impl IBig

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

Returns the number of trailing zeros in the two’s complement 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!(ibig!(17).trailing_zeros(), Some(0));
assert_eq!(ibig!(-48).trailing_zeros(), Some(4));
assert_eq!(ibig!(-0b101000000).trailing_zeros(), Some(6));
assert_eq!(ibig!(0).trailing_zeros(), None);

impl IBig

pub fn to_f32(&self) -> f32

Convert to f32.

Round to nearest, breaking ties to even last bit.

Examples

assert_eq!(ibig!(-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!(ibig!(-134).to_f64(), -134.0f64);

impl IBig

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

impl IBig

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

Greatest common divisor.

Example

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

Panics

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

pub fn extended_gcd(&self, rhs: &IBig) -> (IBig, 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(abs(b), 1)
• abs(y) <= max(abs(a), 1)

Example

let a = ibig!(-12);
let b = ibig!(18);
let (g, x, y) = a.extended_gcd(&b);
assert_eq!(&a % &g, ibig!(0));
assert_eq!(&b % &g, ibig!(0));
assert_eq!(&x * &a + &y * &b, g);
assert!(x.abs() <= b.abs());
assert!(y.abs() <= a.abs());

Panics

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

impl IBig

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

Convert a string in a given base to IBig.

The string may contain a + or - 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!(IBig::from_str_radix("-7ab", 32)?, ibig!(-7499));

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

Convert a string with an optional radix prefix to IBig.

src may contain an ‘+’ or - prefix after the radix prefix.

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

Examples

assert_eq!(IBig::from_str_with_radix_prefix("+0o17")?, ibig!(0o17));
assert_eq!(IBig::from_str_with_radix_prefix("-0x1f")?, ibig!(-0x1f));

impl IBig

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

Raises self to the power of exp.

Example

assert_eq!(ibig!(-3).pow(3), ibig!(-27));

impl IBig

pub fn signum(&self) -> IBig

A number representing the sign of self.

• -1 if the number is negative
• 0 if the number is zero
• 1 if the number is positive

Examples

assert_eq!(ibig!(-500).signum(), ibig!(-1));

Trait Implementations

impl Abs for &IBig

type Output = IBig

fn abs(self) -> IBig

impl Abs for IBig

type Output = IBig

fn abs(self) -> IBig

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b> Add<&'a IBig> for &'b i16

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b> Add<&'a IBig> for &'b i32

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b> Add<&'a IBig> for &'b i64

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b> Add<&'a IBig> for &'b i8

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, 'b> Add<&'a IBig> for &'b isize

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&IBig> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&IBig> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for i128

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for i16

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for i32

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for i64

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for i8

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for isize

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for u128

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for u16

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for u32

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for u64

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for u8

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<IBig> for usize

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

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i128> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i128> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i16> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i32> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i32> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i64> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i64> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<i8> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<isize> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<isize> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u128> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u128> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u16> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u16> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u32> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u64> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u64> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u8> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<u8> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<usize> for &IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<usize> for IBig

type Output = IBig

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&IBig> for IBig

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

Performs the += operation.

impl AddAssign<&i128> for IBig

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

Performs the += operation.

impl AddAssign<&i16> for IBig

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

Performs the += operation.

impl AddAssign<&i32> for IBig

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

Performs the += operation.

impl AddAssign<&i64> for IBig

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

Performs the += operation.

impl AddAssign<&i8> for IBig

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

Performs the += operation.

impl AddAssign<&isize> for IBig

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

Performs the += operation.

impl AddAssign<&u128> for IBig

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

Performs the += operation.

impl AddAssign<&u16> for IBig

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

Performs the += operation.

impl AddAssign<&u32> for IBig

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

Performs the += operation.

impl AddAssign<&u64> for IBig

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

Performs the += operation.

impl AddAssign<&u8> for IBig

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

Performs the += operation.

impl AddAssign<&usize> for IBig

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

Performs the += operation.

impl AddAssign<IBig> for IBig

fn add_assign(&mut self, rhs: IBig)

Performs the += operation.

impl AddAssign<i128> for IBig

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

impl AddAssign<i16> for IBig

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl AddAssign<i32> for IBig

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl AddAssign<i64> for IBig

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl AddAssign<i8> for IBig

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl AddAssign<isize> for IBig

fn add_assign(&mut self, rhs: isize)

Performs the += operation.

impl AddAssign<u128> for IBig

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl AddAssign<u16> for IBig

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl AddAssign<u32> for IBig

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AddAssign<u64> for IBig

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl AddAssign<u8> for IBig

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl AddAssign<usize> for IBig

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl AndNot<&IBig> for &IBig

type Output = IBig

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

impl AndNot<&IBig> for IBig

type Output = IBig

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

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

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

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

impl AndNot<&i128> for IBig

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

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

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

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

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

impl AndNot<&i16> for IBig

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

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

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

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

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

impl AndNot<&i32> for IBig

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

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

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

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

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

impl AndNot<&i64> for IBig

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

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

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

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

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

impl AndNot<&i8> for IBig

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

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

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

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

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

impl AndNot<&isize> for IBig

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

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

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

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

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

impl AndNot<&u128> for IBig

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

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

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

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

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

impl AndNot<&u16> for IBig

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

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

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

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

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

impl AndNot<&u32> for IBig

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

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

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

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

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

impl AndNot<&u64> for IBig

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

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

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

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

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

impl AndNot<&u8> for IBig

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

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

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

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

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

impl AndNot<&usize> for IBig

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

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

impl AndNot<IBig> for &IBig

type Output = IBig

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

impl AndNot<IBig> for IBig

type Output = IBig

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

impl AndNot<i128> for &IBig

type Output = IBig

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

impl AndNot<i128> for IBig

type Output = IBig

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

impl AndNot<i16> for &IBig

type Output = IBig

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

impl AndNot<i16> for IBig

type Output = IBig

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

impl AndNot<i32> for &IBig

type Output = IBig

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

impl AndNot<i32> for IBig

type Output = IBig

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

impl AndNot<i64> for &IBig

type Output = IBig

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

impl AndNot<i64> for IBig

type Output = IBig

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

impl AndNot<i8> for &IBig

type Output = IBig

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

impl AndNot<i8> for IBig

type Output = IBig

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

impl AndNot<isize> for &IBig

type Output = IBig

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

impl AndNot<isize> for IBig

type Output = IBig

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

impl AndNot<u128> for &IBig

type Output = IBig

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

impl AndNot<u128> for IBig

type Output = IBig

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

impl AndNot<u16> for &IBig

type Output = IBig

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

impl AndNot<u16> for IBig

type Output = IBig

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

impl AndNot<u32> for &IBig

type Output = IBig

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

impl AndNot<u32> for IBig

type Output = IBig

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

impl AndNot<u64> for &IBig

type Output = IBig

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

impl AndNot<u64> for IBig

type Output = IBig

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

impl AndNot<u8> for &IBig

type Output = IBig

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

impl AndNot<u8> for IBig

type Output = IBig

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

impl AndNot<usize> for &IBig

type Output = IBig

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

impl AndNot<usize> for IBig

type Output = IBig

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

impl Binary for IBig

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

Formats the value using the given formatter.

impl<'a, 'b> BitAnd<&'a IBig> for &'b i128

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b> BitAnd<&'a IBig> for &'b i16

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b> BitAnd<&'a IBig> for &'b i32

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b> BitAnd<&'a IBig> for &'b i64

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b> BitAnd<&'a IBig> for &'b i8

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b> BitAnd<&'a IBig> for &'b isize

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl<'a, 'b> BitAnd<&'a IBig> for &'b u128

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&IBig> for &IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<&IBig> for IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

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

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for &IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for i128

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for i16

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for i32

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for i64

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for i8

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for isize

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for u128

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for u16

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for u32

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for u64

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for u8

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<IBig> for usize

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

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i128> for &IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i128> for IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i16> for &IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i16> for IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i32> for &IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i32> for IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i64> for &IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i64> for IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i8> for &IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<i8> for IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<isize> for &IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<isize> for IBig

type Output = IBig

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u128> for &IBig

type Output = u128

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u128> for IBig

type Output = u128

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u16> for &IBig

type Output = u16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u16> for IBig

type Output = u16

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u32> for &IBig

type Output = u32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u32> for IBig

type Output = u32

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u64> for &IBig

type Output = u64

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u64> for IBig

type Output = u64

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u8> for &IBig

type Output = u8

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<u8> for IBig

type Output = u8

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<usize> for &IBig

type Output = usize

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<usize> for IBig

type Output = usize

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAndAssign<&IBig> for IBig

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

Performs the &= operation.

impl BitAndAssign<&i128> for IBig

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

Performs the &= operation.

impl BitAndAssign<&i16> for IBig

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

Performs the &= operation.

impl BitAndAssign<&i32> for IBig

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

Performs the &= operation.

impl BitAndAssign<&i64> for IBig

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

Performs the &= operation.

impl BitAndAssign<&i8> for IBig

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

Performs the &= operation.

impl BitAndAssign<&isize> for IBig

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

Performs the &= operation.

impl BitAndAssign<&u128> for IBig

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

Performs the &= operation.

impl BitAndAssign<&u16> for IBig

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

Performs the &= operation.

impl BitAndAssign<&u32> for IBig

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

Performs the &= operation.

impl BitAndAssign<&u64> for IBig

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

Performs the &= operation.

impl BitAndAssign<&u8> for IBig

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

Performs the &= operation.

impl BitAndAssign<&usize> for IBig

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

Performs the &= operation.

impl BitAndAssign<IBig> for IBig

fn bitand_assign(&mut self, rhs: IBig)

Performs the &= operation.

impl BitAndAssign<i128> for IBig

fn bitand_assign(&mut self, rhs: i128)

Performs the &= operation.

impl BitAndAssign<i16> for IBig

fn bitand_assign(&mut self, rhs: i16)

Performs the &= operation.

impl BitAndAssign<i32> for IBig

fn bitand_assign(&mut self, rhs: i32)

Performs the &= operation.

impl BitAndAssign<i64> for IBig

fn bitand_assign(&mut self, rhs: i64)

Performs the &= operation.

impl BitAndAssign<i8> for IBig

fn bitand_assign(&mut self, rhs: i8)

Performs the &= operation.

impl BitAndAssign<isize> for IBig

fn bitand_assign(&mut self, rhs: isize)

Performs the &= operation.

impl BitAndAssign<u128> for IBig

fn bitand_assign(&mut self, rhs: u128)

Performs the &= operation.

impl BitAndAssign<u16> for IBig

fn bitand_assign(&mut self, rhs: u16)

Performs the &= operation.

impl BitAndAssign<u32> for IBig

fn bitand_assign(&mut self, rhs: u32)

Performs the &= operation.

impl BitAndAssign<u64> for IBig

fn bitand_assign(&mut self, rhs: u64)

Performs the &= operation.

impl BitAndAssign<u8> for IBig

fn bitand_assign(&mut self, rhs: u8)

Performs the &= operation.

impl BitAndAssign<usize> for IBig

fn bitand_assign(&mut self, rhs: usize)

Performs the &= operation.

impl<'a, 'b> BitOr<&'a IBig> for &'b i128

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b> BitOr<&'a IBig> for &'b i16

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b> BitOr<&'a IBig> for &'b i32

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b> BitOr<&'a IBig> for &'b i64

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b> BitOr<&'a IBig> for &'b i8

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b> BitOr<&'a IBig> for &'b isize

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl<'a, 'b> BitOr<&'a IBig> for &'b u128

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&IBig> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<&IBig> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

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

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for i128

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for i16

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for i32

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for i64

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for i8

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for isize

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for u128

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for u16

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for u32

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for u64

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for u8

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<IBig> for usize

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

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i128> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i128> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i16> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i16> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i32> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i32> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i64> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i64> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i8> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<i8> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<isize> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<isize> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u128> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u128> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u16> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u16> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u32> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u32> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u64> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u64> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u8> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<u8> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<usize> for &IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<usize> for IBig

type Output = IBig

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOrAssign<&IBig> for IBig

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

Performs the |= operation.

impl BitOrAssign<&i128> for IBig

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

Performs the |= operation.

impl BitOrAssign<&i16> for IBig

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

Performs the |= operation.

impl BitOrAssign<&i32> for IBig

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

Performs the |= operation.

impl BitOrAssign<&i64> for IBig

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

Performs the |= operation.

impl BitOrAssign<&i8> for IBig

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

Performs the |= operation.

impl BitOrAssign<&isize> for IBig

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

Performs the |= operation.

impl BitOrAssign<&u128> for IBig

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

Performs the |= operation.

impl BitOrAssign<&u16> for IBig

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

Performs the |= operation.

impl BitOrAssign<&u32> for IBig

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

Performs the |= operation.

impl BitOrAssign<&u64> for IBig

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

Performs the |= operation.

impl BitOrAssign<&u8> for IBig

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

Performs the |= operation.

impl BitOrAssign<&usize> for IBig

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

Performs the |= operation.

impl BitOrAssign<IBig> for IBig

fn bitor_assign(&mut self, rhs: IBig)

Performs the |= operation.

impl BitOrAssign<i128> for IBig

fn bitor_assign(&mut self, rhs: i128)

Performs the |= operation.

impl BitOrAssign<i16> for IBig

fn bitor_assign(&mut self, rhs: i16)

Performs the |= operation.

impl BitOrAssign<i32> for IBig

fn bitor_assign(&mut self, rhs: i32)

Performs the |= operation.

impl BitOrAssign<i64> for IBig

fn bitor_assign(&mut self, rhs: i64)

Performs the |= operation.

impl BitOrAssign<i8> for IBig

fn bitor_assign(&mut self, rhs: i8)

Performs the |= operation.

impl BitOrAssign<isize> for IBig

fn bitor_assign(&mut self, rhs: isize)

Performs the |= operation.

impl BitOrAssign<u128> for IBig

fn bitor_assign(&mut self, rhs: u128)

Performs the |= operation.

impl BitOrAssign<u16> for IBig

fn bitor_assign(&mut self, rhs: u16)

Performs the |= operation.

impl BitOrAssign<u32> for IBig

fn bitor_assign(&mut self, rhs: u32)

Performs the |= operation.

impl BitOrAssign<u64> for IBig

fn bitor_assign(&mut self, rhs: u64)

Performs the |= operation.

impl BitOrAssign<u8> for IBig

fn bitor_assign(&mut self, rhs: u8)

Performs the |= operation.

impl BitOrAssign<usize> for IBig

fn bitor_assign(&mut self, rhs: usize)

Performs the |= operation.

impl<'a, 'b> BitXor<&'a IBig> for &'b i128

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a IBig> for &'b i16

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a IBig> for &'b i32

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a IBig> for &'b i64

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a IBig> for &'b i8

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a IBig> for &'b isize

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<'a, 'b> BitXor<&'a IBig> for &'b u128

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&IBig> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<&IBig> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for i128

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for i16

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for i32

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for i64

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for i8

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for isize

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for u128

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for u16

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for u32

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for u64

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for u8

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<IBig> for usize

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

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i128> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i128> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i16> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i16> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i32> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i32> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i64> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i64> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i8> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<i8> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<isize> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<isize> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u128> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u128> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u16> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u16> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u32> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u32> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u64> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u64> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u8> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<u8> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<usize> for &IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXor<usize> for IBig

type Output = IBig

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl BitXorAssign<&IBig> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&i128> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&i16> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&i32> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&i64> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&i8> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&isize> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&u128> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&u16> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&u32> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&u64> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&u8> for IBig

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

Performs the ^= operation.

impl BitXorAssign<&usize> for IBig

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

Performs the ^= operation.

impl BitXorAssign<IBig> for IBig

fn bitxor_assign(&mut self, rhs: IBig)

Performs the ^= operation.

impl BitXorAssign<i128> for IBig

fn bitxor_assign(&mut self, rhs: i128)

Performs the ^= operation.

impl BitXorAssign<i16> for IBig

fn bitxor_assign(&mut self, rhs: i16)

Performs the ^= operation.

impl BitXorAssign<i32> for IBig

fn bitxor_assign(&mut self, rhs: i32)

Performs the ^= operation.

impl BitXorAssign<i64> for IBig

fn bitxor_assign(&mut self, rhs: i64)

Performs the ^= operation.

impl BitXorAssign<i8> for IBig

fn bitxor_assign(&mut self, rhs: i8)

Performs the ^= operation.

impl BitXorAssign<isize> for IBig

fn bitxor_assign(&mut self, rhs: isize)

Performs the ^= operation.

impl BitXorAssign<u128> for IBig

fn bitxor_assign(&mut self, rhs: u128)

Performs the ^= operation.

impl BitXorAssign<u16> for IBig

fn bitxor_assign(&mut self, rhs: u16)

Performs the ^= operation.

impl BitXorAssign<u32> for IBig

fn bitxor_assign(&mut self, rhs: u32)

Performs the ^= operation.

impl BitXorAssign<u64> for IBig

fn bitxor_assign(&mut self, rhs: u64)

Performs the ^= operation.

impl BitXorAssign<u8> for IBig

fn bitxor_assign(&mut self, rhs: u8)

Performs the ^= operation.

impl BitXorAssign<usize> for IBig

fn bitxor_assign(&mut self, rhs: usize)

Performs the ^= operation.

impl Clone for IBig

fn clone(&self) -> IBig

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for IBig

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

Formats the value using the given formatter.

impl Default for IBig

fn default() -> IBig

Default value: 0.

impl<'de> Deserialize<'de> for IBig

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

Deserialize this value from the given Serde deserializer.

impl Display for IBig

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

Formats the value using the given formatter.

impl Div<&IBig> for &IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&IBig> for IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> Div<&i128> for &'a IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

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

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<IBig> for &IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<IBig> for IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i128> for &IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i128> for IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i16> for &IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i16> for IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i32> for &IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i32> for IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i64> for &IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i64> for IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i8> for &IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i8> for IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<isize> for &IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<isize> for IBig

type Output = IBig

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<u128> for &IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> IBig

Performs the / operation.

impl Div<u128> for IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> IBig

Performs the / operation.

impl Div<u16> for &IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> IBig

Performs the / operation.

impl Div<u16> for IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> IBig

Performs the / operation.

impl Div<u32> for &IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> IBig

Performs the / operation.

impl Div<u32> for IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> IBig

Performs the / operation.

impl Div<u64> for &IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> IBig

Performs the / operation.

impl Div<u64> for IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> IBig

Performs the / operation.

impl Div<u8> for &IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> IBig

Performs the / operation.

impl Div<u8> for IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> IBig

Performs the / operation.

impl Div<usize> for &IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> IBig

Performs the / operation.

impl Div<usize> for IBig

type Output = IBig

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> IBig

Performs the / operation.

impl DivAssign<&IBig> for IBig

fn div_assign(&mut self, rhs: &IBig)

Performs the /= operation.

impl DivAssign<&i128> for IBig

fn div_assign(&mut self, rhs: &i128)

Performs the /= operation.

impl DivAssign<&i16> for IBig

fn div_assign(&mut self, rhs: &i16)

Performs the /= operation.

impl DivAssign<&i32> for IBig

fn div_assign(&mut self, rhs: &i32)

Performs the /= operation.

impl DivAssign<&i64> for IBig

fn div_assign(&mut self, rhs: &i64)

Performs the /= operation.

impl DivAssign<&i8> for IBig

fn div_assign(&mut self, rhs: &i8)

Performs the /= operation.

impl DivAssign<&isize> for IBig

fn div_assign(&mut self, rhs: &isize)

Performs the /= operation.

impl DivAssign<&u128> for IBig

fn div_assign(&mut self, rhs: &u128)

Performs the /= operation.

impl DivAssign<&u16> for IBig

fn div_assign(&mut self, rhs: &u16)

Performs the /= operation.

impl DivAssign<&u32> for IBig

fn div_assign(&mut self, rhs: &u32)

Performs the /= operation.

impl DivAssign<&u64> for IBig

fn div_assign(&mut self, rhs: &u64)

Performs the /= operation.

impl DivAssign<&u8> for IBig

fn div_assign(&mut self, rhs: &u8)

Performs the /= operation.

impl DivAssign<&usize> for IBig

fn div_assign(&mut self, rhs: &usize)

Performs the /= operation.

impl DivAssign<IBig> for IBig

fn div_assign(&mut self, rhs: IBig)

Performs the /= operation.

impl DivAssign<i128> for IBig

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl DivAssign<i16> for IBig

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl DivAssign<i32> for IBig

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl DivAssign<i64> for IBig

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl DivAssign<i8> for IBig

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl DivAssign<isize> for IBig

fn div_assign(&mut self, rhs: isize)

Performs the /= operation.

impl DivAssign<u128> for IBig

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl DivAssign<u16> for IBig

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl DivAssign<u32> for IBig

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl DivAssign<u64> for IBig

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl DivAssign<u8> for IBig

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl DivAssign<usize> for IBig

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl DivEuclid<&IBig> for &IBig

type Output = IBig

fn div_euclid(self, rhs: &IBig) -> IBig

impl DivEuclid<&IBig> for IBig

type Output = IBig

fn div_euclid(self, rhs: &IBig) -> IBig

impl<'a> DivEuclid<&i128> for &'a IBig

type Output = <&'a IBig as DivEuclid<i128>>::Output

fn div_euclid(self, rhs: &i128) -> Self::Output

impl DivEuclid<&i128> for IBig

type Output = <IBig as DivEuclid<i128>>::Output

fn div_euclid(self, rhs: &i128) -> Self::Output

impl<'a> DivEuclid<&i16> for &'a IBig

type Output = <&'a IBig as DivEuclid<i16>>::Output

fn div_euclid(self, rhs: &i16) -> Self::Output

impl DivEuclid<&i16> for IBig

type Output = <IBig as DivEuclid<i16>>::Output

fn div_euclid(self, rhs: &i16) -> Self::Output

impl<'a> DivEuclid<&i32> for &'a IBig

type Output = <&'a IBig as DivEuclid<i32>>::Output

fn div_euclid(self, rhs: &i32) -> Self::Output

impl DivEuclid<&i32> for IBig

type Output = <IBig as DivEuclid<i32>>::Output

fn div_euclid(self, rhs: &i32) -> Self::Output

impl<'a> DivEuclid<&i64> for &'a IBig

type Output = <&'a IBig as DivEuclid<i64>>::Output

fn div_euclid(self, rhs: &i64) -> Self::Output

impl DivEuclid<&i64> for IBig

type Output = <IBig as DivEuclid<i64>>::Output

fn div_euclid(self, rhs: &i64) -> Self::Output

impl<'a> DivEuclid<&i8> for &'a IBig

type Output = <&'a IBig as DivEuclid<i8>>::Output

fn div_euclid(self, rhs: &i8) -> Self::Output

impl DivEuclid<&i8> for IBig

type Output = <IBig as DivEuclid<i8>>::Output

fn div_euclid(self, rhs: &i8) -> Self::Output

impl<'a> DivEuclid<&isize> for &'a IBig

type Output = <&'a IBig as DivEuclid<isize>>::Output

fn div_euclid(self, rhs: &isize) -> Self::Output

impl DivEuclid<&isize> for IBig

type Output = <IBig as DivEuclid<isize>>::Output

fn div_euclid(self, rhs: &isize) -> Self::Output

impl<'a> DivEuclid<&u128> for &'a IBig

type Output = <&'a IBig as DivEuclid<u128>>::Output

fn div_euclid(self, rhs: &u128) -> Self::Output

impl DivEuclid<&u128> for IBig

type Output = <IBig as DivEuclid<u128>>::Output

fn div_euclid(self, rhs: &u128) -> Self::Output

impl<'a> DivEuclid<&u16> for &'a IBig

type Output = <&'a IBig as DivEuclid<u16>>::Output

fn div_euclid(self, rhs: &u16) -> Self::Output

impl DivEuclid<&u16> for IBig

type Output = <IBig as DivEuclid<u16>>::Output

fn div_euclid(self, rhs: &u16) -> Self::Output

impl<'a> DivEuclid<&u32> for &'a IBig

type Output = <&'a IBig as DivEuclid<u32>>::Output

fn div_euclid(self, rhs: &u32) -> Self::Output

impl DivEuclid<&u32> for IBig

type Output = <IBig as DivEuclid<u32>>::Output

fn div_euclid(self, rhs: &u32) -> Self::Output

impl<'a> DivEuclid<&u64> for &'a IBig

type Output = <&'a IBig as DivEuclid<u64>>::Output

fn div_euclid(self, rhs: &u64) -> Self::Output

impl DivEuclid<&u64> for IBig

type Output = <IBig as DivEuclid<u64>>::Output

fn div_euclid(self, rhs: &u64) -> Self::Output

impl<'a> DivEuclid<&u8> for &'a IBig

type Output = <&'a IBig as DivEuclid<u8>>::Output

fn div_euclid(self, rhs: &u8) -> Self::Output

impl DivEuclid<&u8> for IBig

type Output = <IBig as DivEuclid<u8>>::Output

fn div_euclid(self, rhs: &u8) -> Self::Output

impl<'a> DivEuclid<&usize> for &'a IBig

type Output = <&'a IBig as DivEuclid<usize>>::Output

fn div_euclid(self, rhs: &usize) -> Self::Output

impl DivEuclid<&usize> for IBig

type Output = <IBig as DivEuclid<usize>>::Output

fn div_euclid(self, rhs: &usize) -> Self::Output

impl DivEuclid<IBig> for &IBig

type Output = IBig

fn div_euclid(self, rhs: IBig) -> IBig

impl DivEuclid<IBig> for IBig

type Output = IBig

fn div_euclid(self, rhs: IBig) -> IBig

impl DivEuclid<i128> for &IBig

type Output = IBig

fn div_euclid(self, rhs: i128) -> IBig

impl DivEuclid<i128> for IBig

type Output = IBig

fn div_euclid(self, rhs: i128) -> IBig

impl DivEuclid<i16> for &IBig

type Output = IBig

fn div_euclid(self, rhs: i16) -> IBig

impl DivEuclid<i16> for IBig

type Output = IBig

fn div_euclid(self, rhs: i16) -> IBig

impl DivEuclid<i32> for &IBig

type Output = IBig

fn div_euclid(self, rhs: i32) -> IBig

impl DivEuclid<i32> for IBig

type Output = IBig

fn div_euclid(self, rhs: i32) -> IBig

impl DivEuclid<i64> for &IBig

type Output = IBig

fn div_euclid(self, rhs: i64) -> IBig

impl DivEuclid<i64> for IBig

type Output = IBig

fn div_euclid(self, rhs: i64) -> IBig

impl DivEuclid<i8> for &IBig

type Output = IBig

fn div_euclid(self, rhs: i8) -> IBig

impl DivEuclid<i8> for IBig

type Output = IBig

fn div_euclid(self, rhs: i8) -> IBig

impl DivEuclid<isize> for &IBig

type Output = IBig

fn div_euclid(self, rhs: isize) -> IBig

impl DivEuclid<isize> for IBig

type Output = IBig

fn div_euclid(self, rhs: isize) -> IBig

impl DivEuclid<u128> for &IBig

type Output = IBig

fn div_euclid(self, rhs: u128) -> IBig

impl DivEuclid<u128> for IBig

type Output = IBig

fn div_euclid(self, rhs: u128) -> IBig

impl DivEuclid<u16> for &IBig

type Output = IBig

fn div_euclid(self, rhs: u16) -> IBig

impl DivEuclid<u16> for IBig

type Output = IBig

fn div_euclid(self, rhs: u16) -> IBig

impl DivEuclid<u32> for &IBig

type Output = IBig

fn div_euclid(self, rhs: u32) -> IBig

impl DivEuclid<u32> for IBig

type Output = IBig

fn div_euclid(self, rhs: u32) -> IBig

impl DivEuclid<u64> for &IBig

type Output = IBig

fn div_euclid(self, rhs: u64) -> IBig

impl DivEuclid<u64> for IBig

type Output = IBig

fn div_euclid(self, rhs: u64) -> IBig

impl DivEuclid<u8> for &IBig

type Output = IBig

fn div_euclid(self, rhs: u8) -> IBig

impl DivEuclid<u8> for IBig

type Output = IBig

fn div_euclid(self, rhs: u8) -> IBig

impl DivEuclid<usize> for &IBig

type Output = IBig

fn div_euclid(self, rhs: usize) -> IBig

impl DivEuclid<usize> for IBig

type Output = IBig

fn div_euclid(self, rhs: usize) -> IBig

impl DivRem<&IBig> for &IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: &IBig) -> (IBig, IBig)

impl DivRem<&IBig> for IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: &IBig) -> (IBig, IBig)

impl<'a> DivRem<&i128> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<i128>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<i128>>::OutputRem

fn div_rem(self, rhs: &i128) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&i128> for IBig

type OutputDiv = <IBig as DivRem<i128>>::OutputDiv

type OutputRem = <IBig as DivRem<i128>>::OutputRem

fn div_rem(self, rhs: &i128) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRem<&i16> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<i16>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<i16>>::OutputRem

fn div_rem(self, rhs: &i16) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&i16> for IBig

type OutputDiv = <IBig as DivRem<i16>>::OutputDiv

type OutputRem = <IBig as DivRem<i16>>::OutputRem

fn div_rem(self, rhs: &i16) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRem<&i32> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<i32>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<i32>>::OutputRem

fn div_rem(self, rhs: &i32) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&i32> for IBig

type OutputDiv = <IBig as DivRem<i32>>::OutputDiv

type OutputRem = <IBig as DivRem<i32>>::OutputRem

fn div_rem(self, rhs: &i32) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRem<&i64> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<i64>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<i64>>::OutputRem

fn div_rem(self, rhs: &i64) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&i64> for IBig

type OutputDiv = <IBig as DivRem<i64>>::OutputDiv

type OutputRem = <IBig as DivRem<i64>>::OutputRem

fn div_rem(self, rhs: &i64) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRem<&i8> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<i8>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<i8>>::OutputRem

fn div_rem(self, rhs: &i8) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&i8> for IBig

type OutputDiv = <IBig as DivRem<i8>>::OutputDiv

type OutputRem = <IBig as DivRem<i8>>::OutputRem

fn div_rem(self, rhs: &i8) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRem<&isize> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<isize>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<isize>>::OutputRem

fn div_rem(self, rhs: &isize) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&isize> for IBig

type OutputDiv = <IBig as DivRem<isize>>::OutputDiv

type OutputRem = <IBig as DivRem<isize>>::OutputRem

fn div_rem(self, rhs: &isize) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRem<&u128> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<u128>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<u128>>::OutputRem

fn div_rem(self, rhs: &u128) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&u128> for IBig

type OutputDiv = <IBig as DivRem<u128>>::OutputDiv

type OutputRem = <IBig as DivRem<u128>>::OutputRem

fn div_rem(self, rhs: &u128) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRem<&u16> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<u16>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<u16>>::OutputRem

fn div_rem(self, rhs: &u16) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&u16> for IBig

type OutputDiv = <IBig as DivRem<u16>>::OutputDiv

type OutputRem = <IBig as DivRem<u16>>::OutputRem

fn div_rem(self, rhs: &u16) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRem<&u32> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<u32>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<u32>>::OutputRem

fn div_rem(self, rhs: &u32) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&u32> for IBig

type OutputDiv = <IBig as DivRem<u32>>::OutputDiv

type OutputRem = <IBig as DivRem<u32>>::OutputRem

fn div_rem(self, rhs: &u32) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRem<&u64> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<u64>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<u64>>::OutputRem

fn div_rem(self, rhs: &u64) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&u64> for IBig

type OutputDiv = <IBig as DivRem<u64>>::OutputDiv

type OutputRem = <IBig as DivRem<u64>>::OutputRem

fn div_rem(self, rhs: &u64) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRem<&u8> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<u8>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<u8>>::OutputRem

fn div_rem(self, rhs: &u8) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&u8> for IBig

type OutputDiv = <IBig as DivRem<u8>>::OutputDiv

type OutputRem = <IBig as DivRem<u8>>::OutputRem

fn div_rem(self, rhs: &u8) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRem<&usize> for &'a IBig

type OutputDiv = <&'a IBig as DivRem<usize>>::OutputDiv

type OutputRem = <&'a IBig as DivRem<usize>>::OutputRem

fn div_rem(self, rhs: &usize) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<&usize> for IBig

type OutputDiv = <IBig as DivRem<usize>>::OutputDiv

type OutputRem = <IBig as DivRem<usize>>::OutputRem

fn div_rem(self, rhs: &usize) -> (Self::OutputDiv, Self::OutputRem)

impl DivRem<IBig> for &IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: IBig) -> (IBig, IBig)

impl DivRem<IBig> for IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: IBig) -> (IBig, IBig)

impl DivRem<i128> for &IBig

type OutputDiv = IBig

type OutputRem = i128

fn div_rem(self, rhs: i128) -> (IBig, i128)

impl DivRem<i128> for IBig

type OutputDiv = IBig

type OutputRem = i128

fn div_rem(self, rhs: i128) -> (IBig, i128)

impl DivRem<i16> for &IBig

type OutputDiv = IBig

type OutputRem = i16

fn div_rem(self, rhs: i16) -> (IBig, i16)

impl DivRem<i16> for IBig

type OutputDiv = IBig

type OutputRem = i16

fn div_rem(self, rhs: i16) -> (IBig, i16)

impl DivRem<i32> for &IBig

type OutputDiv = IBig

type OutputRem = i32

fn div_rem(self, rhs: i32) -> (IBig, i32)

impl DivRem<i32> for IBig

type OutputDiv = IBig

type OutputRem = i32

fn div_rem(self, rhs: i32) -> (IBig, i32)

impl DivRem<i64> for &IBig

type OutputDiv = IBig

type OutputRem = i64

fn div_rem(self, rhs: i64) -> (IBig, i64)

impl DivRem<i64> for IBig

type OutputDiv = IBig

type OutputRem = i64

fn div_rem(self, rhs: i64) -> (IBig, i64)

impl DivRem<i8> for &IBig

type OutputDiv = IBig

type OutputRem = i8

fn div_rem(self, rhs: i8) -> (IBig, i8)

impl DivRem<i8> for IBig

type OutputDiv = IBig

type OutputRem = i8

fn div_rem(self, rhs: i8) -> (IBig, i8)

impl DivRem<isize> for &IBig

type OutputDiv = IBig

type OutputRem = isize

fn div_rem(self, rhs: isize) -> (IBig, isize)

impl DivRem<isize> for IBig

type OutputDiv = IBig

type OutputRem = isize

fn div_rem(self, rhs: isize) -> (IBig, isize)

impl DivRem<u128> for &IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: u128) -> (IBig, IBig)

impl DivRem<u128> for IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: u128) -> (IBig, IBig)

impl DivRem<u16> for &IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: u16) -> (IBig, IBig)

impl DivRem<u16> for IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: u16) -> (IBig, IBig)

impl DivRem<u32> for &IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: u32) -> (IBig, IBig)

impl DivRem<u32> for IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: u32) -> (IBig, IBig)

impl DivRem<u64> for &IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: u64) -> (IBig, IBig)

impl DivRem<u64> for IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: u64) -> (IBig, IBig)

impl DivRem<u8> for &IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: u8) -> (IBig, IBig)

impl DivRem<u8> for IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: u8) -> (IBig, IBig)

impl DivRem<usize> for &IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: usize) -> (IBig, IBig)

impl DivRem<usize> for IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem(self, rhs: usize) -> (IBig, IBig)

impl DivRemEuclid<&IBig> for &IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem_euclid(self, rhs: &IBig) -> (IBig, IBig)

impl DivRemEuclid<&IBig> for IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem_euclid(self, rhs: &IBig) -> (IBig, IBig)

impl<'a> DivRemEuclid<&i128> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<i128>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<i128>>::OutputRem

fn div_rem_euclid(self, rhs: &i128) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&i128> for IBig

type OutputDiv = <IBig as DivRemEuclid<i128>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<i128>>::OutputRem

fn div_rem_euclid(self, rhs: &i128) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&i16> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<i16>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<i16>>::OutputRem

fn div_rem_euclid(self, rhs: &i16) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&i16> for IBig

type OutputDiv = <IBig as DivRemEuclid<i16>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<i16>>::OutputRem

fn div_rem_euclid(self, rhs: &i16) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&i32> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<i32>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<i32>>::OutputRem

fn div_rem_euclid(self, rhs: &i32) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&i32> for IBig

type OutputDiv = <IBig as DivRemEuclid<i32>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<i32>>::OutputRem

fn div_rem_euclid(self, rhs: &i32) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&i64> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<i64>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<i64>>::OutputRem

fn div_rem_euclid(self, rhs: &i64) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&i64> for IBig

type OutputDiv = <IBig as DivRemEuclid<i64>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<i64>>::OutputRem

fn div_rem_euclid(self, rhs: &i64) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&i8> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<i8>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<i8>>::OutputRem

fn div_rem_euclid(self, rhs: &i8) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&i8> for IBig

type OutputDiv = <IBig as DivRemEuclid<i8>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<i8>>::OutputRem

fn div_rem_euclid(self, rhs: &i8) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&isize> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<isize>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<isize>>::OutputRem

fn div_rem_euclid(self, rhs: &isize) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&isize> for IBig

type OutputDiv = <IBig as DivRemEuclid<isize>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<isize>>::OutputRem

fn div_rem_euclid(self, rhs: &isize) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&u128> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<u128>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<u128>>::OutputRem

fn div_rem_euclid(self, rhs: &u128) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&u128> for IBig

type OutputDiv = <IBig as DivRemEuclid<u128>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<u128>>::OutputRem

fn div_rem_euclid(self, rhs: &u128) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&u16> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<u16>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<u16>>::OutputRem

fn div_rem_euclid(self, rhs: &u16) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&u16> for IBig

type OutputDiv = <IBig as DivRemEuclid<u16>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<u16>>::OutputRem

fn div_rem_euclid(self, rhs: &u16) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&u32> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<u32>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<u32>>::OutputRem

fn div_rem_euclid(self, rhs: &u32) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&u32> for IBig

type OutputDiv = <IBig as DivRemEuclid<u32>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<u32>>::OutputRem

fn div_rem_euclid(self, rhs: &u32) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&u64> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<u64>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<u64>>::OutputRem

fn div_rem_euclid(self, rhs: &u64) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&u64> for IBig

type OutputDiv = <IBig as DivRemEuclid<u64>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<u64>>::OutputRem

fn div_rem_euclid(self, rhs: &u64) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&u8> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<u8>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<u8>>::OutputRem

fn div_rem_euclid(self, rhs: &u8) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&u8> for IBig

type OutputDiv = <IBig as DivRemEuclid<u8>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<u8>>::OutputRem

fn div_rem_euclid(self, rhs: &u8) -> (Self::OutputDiv, Self::OutputRem)

impl<'a> DivRemEuclid<&usize> for &'a IBig

type OutputDiv = <&'a IBig as DivRemEuclid<usize>>::OutputDiv

type OutputRem = <&'a IBig as DivRemEuclid<usize>>::OutputRem

fn div_rem_euclid(self, rhs: &usize) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<&usize> for IBig

type OutputDiv = <IBig as DivRemEuclid<usize>>::OutputDiv

type OutputRem = <IBig as DivRemEuclid<usize>>::OutputRem

fn div_rem_euclid(self, rhs: &usize) -> (Self::OutputDiv, Self::OutputRem)

impl DivRemEuclid<IBig> for &IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem_euclid(self, rhs: IBig) -> (IBig, IBig)

impl DivRemEuclid<IBig> for IBig

type OutputDiv = IBig

type OutputRem = IBig

fn div_rem_euclid(self, rhs: IBig) -> (IBig, IBig)

impl DivRemEuclid<i128> for &IBig

type OutputDiv = IBig

type OutputRem = i128

fn div_rem_euclid(self, rhs: i128) -> (IBig, i128)

impl DivRemEuclid<i128> for IBig

type OutputDiv = IBig

type OutputRem = i128

fn div_rem_euclid(self, rhs: i128) -> (IBig, i128)

impl DivRemEuclid<i16> for &IBig

type OutputDiv = IBig

type OutputRem = i16

fn div_rem_euclid(self, rhs: i16) -> (IBig, i16)

impl DivRemEuclid<i16> for IBig

type OutputDiv = IBig

type OutputRem = i16

fn div_rem_euclid(self, rhs: i16) -> (IBig, i16)

impl DivRemEuclid<i32> for &IBig

type OutputDiv = IBig

type OutputRem = i32

fn div_rem_euclid(self, rhs: i32) -> (IBig, i32)

impl DivRemEuclid<i32> for IBig

type OutputDiv = IBig

type OutputRem = i32

fn div_rem_euclid(self, rhs: i32) -> (IBig, i32)

impl DivRemEuclid<i64> for &IBig

type OutputDiv = IBig

type OutputRem = i64

fn div_rem_euclid(self, rhs: i64) -> (IBig, i64)

impl DivRemEuclid<i64> for IBig

type OutputDiv = IBig

type OutputRem = i64

fn div_rem_euclid(self, rhs: i64) -> (IBig, i64)

impl DivRemEuclid<i8> for &IBig

type OutputDiv = IBig

type OutputRem = i8

fn div_rem_euclid(self, rhs: i8) -> (IBig, i8)

impl DivRemEuclid<i8> for IBig

type OutputDiv = IBig

type OutputRem = i8

fn div_rem_euclid(self, rhs: i8) -> (IBig, i8)

impl DivRemEuclid<isize> for &IBig

type OutputDiv = IBig

type OutputRem = isize

fn div_rem_euclid(self, rhs: isize) -> (IBig, isize)

impl DivRemEuclid<isize> for IBig

type OutputDiv = IBig

type OutputRem = isize

fn div_rem_euclid(self, rhs: isize) -> (IBig, isize)

impl DivRemEuclid<u128> for &IBig

type OutputDiv = IBig

type OutputRem = u128

fn div_rem_euclid(self, rhs: u128) -> (IBig, u128)

impl DivRemEuclid<u128> for IBig

type OutputDiv = IBig

type OutputRem = u128

fn div_rem_euclid(self, rhs: u128) -> (IBig, u128)

impl DivRemEuclid<u16> for &IBig

type OutputDiv = IBig

type OutputRem = u16

fn div_rem_euclid(self, rhs: u16) -> (IBig, u16)

impl DivRemEuclid<u16> for IBig

type OutputDiv = IBig

type OutputRem = u16

fn div_rem_euclid(self, rhs: u16) -> (IBig, u16)

impl DivRemEuclid<u32> for &IBig

type OutputDiv = IBig

type OutputRem = u32

fn div_rem_euclid(self, rhs: u32) -> (IBig, u32)

impl DivRemEuclid<u32> for IBig

type OutputDiv = IBig

type OutputRem = u32

fn div_rem_euclid(self, rhs: u32) -> (IBig, u32)

impl DivRemEuclid<u64> for &IBig

type OutputDiv = IBig

type OutputRem = u64

fn div_rem_euclid(self, rhs: u64) -> (IBig, u64)

impl DivRemEuclid<u64> for IBig

type OutputDiv = IBig

type OutputRem = u64

fn div_rem_euclid(self, rhs: u64) -> (IBig, u64)

impl DivRemEuclid<u8> for &IBig

type OutputDiv = IBig

type OutputRem = u8

fn div_rem_euclid(self, rhs: u8) -> (IBig, u8)

impl DivRemEuclid<u8> for IBig

type OutputDiv = IBig

type OutputRem = u8

fn div_rem_euclid(self, rhs: u8) -> (IBig, u8)

impl DivRemEuclid<usize> for &IBig

type OutputDiv = IBig

type OutputRem = usize

fn div_rem_euclid(self, rhs: usize) -> (IBig, usize)

impl DivRemEuclid<usize> for IBig

type OutputDiv = IBig

type OutputRem = usize

fn div_rem_euclid(self, rhs: usize) -> (IBig, 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 IBig

fn from(b: bool) -> IBig

Converts to this type from the input type.

impl From<i128> for IBig

fn from(value: i128) -> IBig

Converts to this type from the input type.

impl From<i16> for IBig

fn from(value: i16) -> IBig

Converts to this type from the input type.

impl From<i32> for IBig

fn from(value: i32) -> IBig

Converts to this type from the input type.

impl From<i64> for IBig

fn from(value: i64) -> IBig

Converts to this type from the input type.

impl From<i8> for IBig

fn from(value: i8) -> IBig

Converts to this type from the input type.

impl From<isize> for IBig

fn from(value: isize) -> IBig

Converts to this type from the input type.

impl From<u128> for IBig

fn from(value: u128) -> IBig

Converts to this type from the input type.

impl From<u16> for IBig

fn from(value: u16) -> IBig

Converts to this type from the input type.

impl From<u32> for IBig

fn from(value: u32) -> IBig

Converts to this type from the input type.

impl From<u64> for IBig

fn from(value: u64) -> IBig

Converts to this type from the input type.

impl From<u8> for IBig

fn from(value: u8) -> IBig

Converts to this type from the input type.

impl From<usize> for IBig

fn from(value: usize) -> IBig

Converts to this type from the input type.

impl FromStr for IBig

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<IBig, ParseError>

Parses a string s to return a value of this type.

impl Hash for IBig

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 &IBig

fn into_modulo(self, ring: &ModuloRing) -> Modulo<'_>

impl IntoModulo for IBig

fn into_modulo(self, ring: &ModuloRing) -> Modulo<'_>

impl LowerHex for IBig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, 'b> Mul<&'a IBig> for &'b i128

type Output = <&'a IBig as Mul<&'b i128>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a IBig> for &'b i16

type Output = <&'a IBig as Mul<&'b i16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a IBig> for &'b i32

type Output = <&'a IBig as Mul<&'b i32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a IBig> for &'b i64

type Output = <&'a IBig as Mul<&'b i64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a IBig> for &'b i8

type Output = <&'a IBig as Mul<&'b i8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a IBig> for &'b isize

type Output = <&'a IBig as Mul<&'b isize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a IBig> for &'b u128

type Output = <&'a IBig as Mul<&'b u128>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a IBig> for &'b u16

type Output = <&'a IBig as Mul<&'b u16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a IBig> for &'b u32

type Output = <&'a IBig as Mul<&'b u32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a IBig> for &'b u64

type Output = <&'a IBig as Mul<&'b u64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a IBig> for &'b u8

type Output = <&'a IBig as Mul<&'b u8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a IBig> for &'b usize

type Output = <&'a IBig as Mul<&'b usize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for i128

type Output = <&'a IBig as Mul<i128>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for i16

type Output = <&'a IBig as Mul<i16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for i32

type Output = <&'a IBig as Mul<i32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for i64

type Output = <&'a IBig as Mul<i64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for i8

type Output = <&'a IBig as Mul<i8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for isize

type Output = <&'a IBig as Mul<isize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for u128

type Output = <&'a IBig as Mul<u128>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for u16

type Output = <&'a IBig as Mul<u16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for u32

type Output = <&'a IBig as Mul<u32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for u64

type Output = <&'a IBig as Mul<u64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for u8

type Output = <&'a IBig as Mul<u8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<&'a IBig> for usize

type Output = <&'a IBig as Mul<usize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Self::Output

Performs the * operation.

impl Mul<&IBig> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> IBig

Performs the * operation.

impl Mul<&IBig> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> IBig

Performs the * operation.

impl<'a> Mul<&i128> for &'a IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig as Mul<usize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: &usize) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a i128

type Output = <IBig as Mul<&'a i128>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a i16

type Output = <IBig as Mul<&'a i16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a i32

type Output = <IBig as Mul<&'a i32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a i64

type Output = <IBig as Mul<&'a i64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a i8

type Output = <IBig as Mul<&'a i8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a isize

type Output = <IBig as Mul<&'a isize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a u128

type Output = <IBig as Mul<&'a u128>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a u16

type Output = <IBig as Mul<&'a u16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a u32

type Output = <IBig as Mul<&'a u32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a u64

type Output = <IBig as Mul<&'a u64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a u8

type Output = <IBig as Mul<&'a u8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl<'a> Mul<IBig> for &'a usize

type Output = <IBig as Mul<&'a usize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> IBig

Performs the * operation.

impl Mul<IBig> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> IBig

Performs the * operation.

impl Mul<IBig> for i128

type Output = <IBig as Mul<i128>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for i16

type Output = <IBig as Mul<i16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for i32

type Output = <IBig as Mul<i32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for i64

type Output = <IBig as Mul<i64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for i8

type Output = <IBig as Mul<i8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for isize

type Output = <IBig as Mul<isize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for u128

type Output = <IBig as Mul<u128>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for u16

type Output = <IBig as Mul<u16>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for u32

type Output = <IBig as Mul<u32>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for u64

type Output = <IBig as Mul<u64>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for u8

type Output = <IBig as Mul<u8>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<IBig> for usize

type Output = <IBig as Mul<usize>>::Output

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Self::Output

Performs the * operation.

impl Mul<i128> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> IBig

Performs the * operation.

impl Mul<i128> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> IBig

Performs the * operation.

impl Mul<i16> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> IBig

Performs the * operation.

impl Mul<i16> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> IBig

Performs the * operation.

impl Mul<i32> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> IBig

Performs the * operation.

impl Mul<i32> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> IBig

Performs the * operation.

impl Mul<i64> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> IBig

Performs the * operation.

impl Mul<i64> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> IBig

Performs the * operation.

impl Mul<i8> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> IBig

Performs the * operation.

impl Mul<i8> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> IBig

Performs the * operation.

impl Mul<isize> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> IBig

Performs the * operation.

impl Mul<isize> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: isize) -> IBig

Performs the * operation.

impl Mul<u128> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> IBig

Performs the * operation.

impl Mul<u128> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> IBig

Performs the * operation.

impl Mul<u16> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> IBig

Performs the * operation.

impl Mul<u16> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> IBig

Performs the * operation.

impl Mul<u32> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> IBig

Performs the * operation.

impl Mul<u32> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> IBig

Performs the * operation.

impl Mul<u64> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> IBig

Performs the * operation.

impl Mul<u64> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> IBig

Performs the * operation.

impl Mul<u8> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> IBig

Performs the * operation.

impl Mul<u8> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> IBig

Performs the * operation.

impl Mul<usize> for &IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> IBig

Performs the * operation.

impl Mul<usize> for IBig

type Output = IBig

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> IBig

Performs the * operation.

impl MulAssign<&IBig> for IBig

fn mul_assign(&mut self, rhs: &IBig)

Performs the *= operation.

impl MulAssign<&i128> for IBig

fn mul_assign(&mut self, rhs: &i128)

Performs the *= operation.

impl MulAssign<&i16> for IBig

fn mul_assign(&mut self, rhs: &i16)

Performs the *= operation.

impl MulAssign<&i32> for IBig

fn mul_assign(&mut self, rhs: &i32)

Performs the *= operation.

impl MulAssign<&i64> for IBig

fn mul_assign(&mut self, rhs: &i64)

Performs the *= operation.

impl MulAssign<&i8> for IBig

fn mul_assign(&mut self, rhs: &i8)

Performs the *= operation.

impl MulAssign<&isize> for IBig

fn mul_assign(&mut self, rhs: &isize)

Performs the *= operation.

impl MulAssign<&u128> for IBig

fn mul_assign(&mut self, rhs: &u128)

Performs the *= operation.

impl MulAssign<&u16> for IBig

fn mul_assign(&mut self, rhs: &u16)

Performs the *= operation.

impl MulAssign<&u32> for IBig

fn mul_assign(&mut self, rhs: &u32)

Performs the *= operation.

impl MulAssign<&u64> for IBig

fn mul_assign(&mut self, rhs: &u64)

Performs the *= operation.

impl MulAssign<&u8> for IBig

fn mul_assign(&mut self, rhs: &u8)

Performs the *= operation.

impl MulAssign<&usize> for IBig

fn mul_assign(&mut self, rhs: &usize)

Performs the *= operation.

impl MulAssign<IBig> for IBig

fn mul_assign(&mut self, rhs: IBig)

Performs the *= operation.

impl MulAssign<i128> for IBig

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl MulAssign<i16> for IBig

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl MulAssign<i32> for IBig

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign<i64> for IBig

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl MulAssign<i8> for IBig

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl MulAssign<isize> for IBig

fn mul_assign(&mut self, rhs: isize)

Performs the *= operation.

impl MulAssign<u128> for IBig

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl MulAssign<u16> for IBig

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl MulAssign<u32> for IBig

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl MulAssign<u64> for IBig

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl MulAssign<u8> for IBig

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl MulAssign<usize> for IBig

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl Neg for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn neg(self) -> IBig

Performs the unary - operation.

impl Neg for IBig

type Output = IBig

The resulting type after applying the - operator.

fn neg(self) -> IBig

Performs the unary - operation.

impl Not for &IBig

type Output = IBig

The resulting type after applying the ! operator.

fn not(self) -> IBig

Performs the unary ! operation.

impl Not for IBig

type Output = IBig

The resulting type after applying the ! operator.

fn not(self) -> IBig

Performs the unary ! operation.

impl Num for IBig

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 IBig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl One for IBig

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 IBig

fn cmp(&self, other: &IBig) -> 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<IBig> for IBig

fn eq(&self, other: &IBig) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<IBig> for IBig

fn partial_cmp(&self, other: &IBig) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Pow<usize> for &IBig

type Output = IBig

The result after applying the operator.

fn pow(self, rhs: usize) -> IBig

Returns self to the power rhs.

impl Pow<usize> for IBig

type Output = IBig

The result after applying the operator.

fn pow(self, rhs: usize) -> IBig

Returns self to the power rhs.

impl Rem<&IBig> for &IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: &IBig) -> IBig

Performs the % operation.

impl Rem<&IBig> for IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: &IBig) -> IBig

Performs the % operation.

impl<'a> Rem<&i128> for &'a IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig as Rem<usize>>::Output

The resulting type after applying the % operator.

fn rem(self, rhs: &usize) -> Self::Output

Performs the % operation.

impl Rem<IBig> for &IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: IBig) -> IBig

Performs the % operation.

impl Rem<IBig> for IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: IBig) -> IBig

Performs the % operation.

impl Rem<i128> for &IBig

type Output = i128

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> i128

Performs the % operation.

impl Rem<i128> for IBig

type Output = i128

The resulting type after applying the % operator.

fn rem(self, rhs: i128) -> i128

Performs the % operation.

impl Rem<i16> for &IBig

type Output = i16

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> i16

Performs the % operation.

impl Rem<i16> for IBig

type Output = i16

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> i16

Performs the % operation.

impl Rem<i32> for &IBig

type Output = i32

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> i32

Performs the % operation.

impl Rem<i32> for IBig

type Output = i32

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> i32

Performs the % operation.

impl Rem<i64> for &IBig

type Output = i64

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> i64

Performs the % operation.

impl Rem<i64> for IBig

type Output = i64

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> i64

Performs the % operation.

impl Rem<i8> for &IBig

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> i8

Performs the % operation.

impl Rem<i8> for IBig

type Output = i8

The resulting type after applying the % operator.

fn rem(self, rhs: i8) -> i8

Performs the % operation.

impl Rem<isize> for &IBig

type Output = isize

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> isize

Performs the % operation.

impl Rem<isize> for IBig

type Output = isize

The resulting type after applying the % operator.

fn rem(self, rhs: isize) -> isize

Performs the % operation.

impl Rem<u128> for &IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: u128) -> IBig

Performs the % operation.

impl Rem<u128> for IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: u128) -> IBig

Performs the % operation.

impl Rem<u16> for &IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> IBig

Performs the % operation.

impl Rem<u16> for IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> IBig

Performs the % operation.

impl Rem<u32> for &IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> IBig

Performs the % operation.

impl Rem<u32> for IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> IBig

Performs the % operation.

impl Rem<u64> for &IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> IBig

Performs the % operation.

impl Rem<u64> for IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> IBig

Performs the % operation.

impl Rem<u8> for &IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> IBig

Performs the % operation.

impl Rem<u8> for IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: u8) -> IBig

Performs the % operation.

impl Rem<usize> for &IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> IBig

Performs the % operation.

impl Rem<usize> for IBig

type Output = IBig

The resulting type after applying the % operator.

fn rem(self, rhs: usize) -> IBig

Performs the % operation.

impl RemAssign<&IBig> for IBig

fn rem_assign(&mut self, rhs: &IBig)

Performs the %= operation.

impl RemAssign<&i128> for IBig

fn rem_assign(&mut self, rhs: &i128)

Performs the %= operation.

impl RemAssign<&i16> for IBig

fn rem_assign(&mut self, rhs: &i16)

Performs the %= operation.

impl RemAssign<&i32> for IBig

fn rem_assign(&mut self, rhs: &i32)

Performs the %= operation.

impl RemAssign<&i64> for IBig

fn rem_assign(&mut self, rhs: &i64)

Performs the %= operation.

impl RemAssign<&i8> for IBig

fn rem_assign(&mut self, rhs: &i8)

Performs the %= operation.

impl RemAssign<&isize> for IBig

fn rem_assign(&mut self, rhs: &isize)

Performs the %= operation.

impl RemAssign<&u128> for IBig

fn rem_assign(&mut self, rhs: &u128)

Performs the %= operation.

impl RemAssign<&u16> for IBig

fn rem_assign(&mut self, rhs: &u16)

Performs the %= operation.

impl RemAssign<&u32> for IBig

fn rem_assign(&mut self, rhs: &u32)

Performs the %= operation.

impl RemAssign<&u64> for IBig

fn rem_assign(&mut self, rhs: &u64)

Performs the %= operation.

impl RemAssign<&u8> for IBig

fn rem_assign(&mut self, rhs: &u8)

Performs the %= operation.

impl RemAssign<&usize> for IBig

fn rem_assign(&mut self, rhs: &usize)

Performs the %= operation.

impl RemAssign<IBig> for IBig

fn rem_assign(&mut self, rhs: IBig)

Performs the %= operation.

impl RemAssign<i128> for IBig

fn rem_assign(&mut self, rhs: i128)

Performs the %= operation.

impl RemAssign<i16> for IBig

fn rem_assign(&mut self, rhs: i16)

Performs the %= operation.

impl RemAssign<i32> for IBig

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl RemAssign<i64> for IBig

fn rem_assign(&mut self, rhs: i64)

Performs the %= operation.

impl RemAssign<i8> for IBig

fn rem_assign(&mut self, rhs: i8)

Performs the %= operation.

impl RemAssign<isize> for IBig

fn rem_assign(&mut self, rhs: isize)

Performs the %= operation.

impl RemAssign<u128> for IBig

fn rem_assign(&mut self, rhs: u128)

Performs the %= operation.

impl RemAssign<u16> for IBig

fn rem_assign(&mut self, rhs: u16)

Performs the %= operation.

impl RemAssign<u32> for IBig

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl RemAssign<u64> for IBig

fn rem_assign(&mut self, rhs: u64)

Performs the %= operation.

impl RemAssign<u8> for IBig

fn rem_assign(&mut self, rhs: u8)

Performs the %= operation.

impl RemAssign<usize> for IBig

fn rem_assign(&mut self, rhs: usize)

Performs the %= operation.

impl RemEuclid<&IBig> for &IBig

type Output = IBig

fn rem_euclid(self, rhs: &IBig) -> IBig

impl RemEuclid<&IBig> for IBig

type Output = IBig

fn rem_euclid(self, rhs: &IBig) -> IBig

impl<'a> RemEuclid<&i128> for &'a IBig

type Output = <&'a IBig as RemEuclid<i128>>::Output

fn rem_euclid(self, rhs: &i128) -> Self::Output

impl RemEuclid<&i128> for IBig

type Output = <IBig as RemEuclid<i128>>::Output

fn rem_euclid(self, rhs: &i128) -> Self::Output

impl<'a> RemEuclid<&i16> for &'a IBig

type Output = <&'a IBig as RemEuclid<i16>>::Output

fn rem_euclid(self, rhs: &i16) -> Self::Output

impl RemEuclid<&i16> for IBig

type Output = <IBig as RemEuclid<i16>>::Output

fn rem_euclid(self, rhs: &i16) -> Self::Output

impl<'a> RemEuclid<&i32> for &'a IBig

type Output = <&'a IBig as RemEuclid<i32>>::Output

fn rem_euclid(self, rhs: &i32) -> Self::Output

impl RemEuclid<&i32> for IBig

type Output = <IBig as RemEuclid<i32>>::Output

fn rem_euclid(self, rhs: &i32) -> Self::Output

impl<'a> RemEuclid<&i64> for &'a IBig

type Output = <&'a IBig as RemEuclid<i64>>::Output

fn rem_euclid(self, rhs: &i64) -> Self::Output

impl RemEuclid<&i64> for IBig

type Output = <IBig as RemEuclid<i64>>::Output

fn rem_euclid(self, rhs: &i64) -> Self::Output

impl<'a> RemEuclid<&i8> for &'a IBig

type Output = <&'a IBig as RemEuclid<i8>>::Output

fn rem_euclid(self, rhs: &i8) -> Self::Output

impl RemEuclid<&i8> for IBig

type Output = <IBig as RemEuclid<i8>>::Output

fn rem_euclid(self, rhs: &i8) -> Self::Output

impl<'a> RemEuclid<&isize> for &'a IBig

type Output = <&'a IBig as RemEuclid<isize>>::Output

fn rem_euclid(self, rhs: &isize) -> Self::Output

impl RemEuclid<&isize> for IBig

type Output = <IBig as RemEuclid<isize>>::Output

fn rem_euclid(self, rhs: &isize) -> Self::Output

impl<'a> RemEuclid<&u128> for &'a IBig

type Output = <&'a IBig as RemEuclid<u128>>::Output

fn rem_euclid(self, rhs: &u128) -> Self::Output

impl RemEuclid<&u128> for IBig

type Output = <IBig as RemEuclid<u128>>::Output

fn rem_euclid(self, rhs: &u128) -> Self::Output

impl<'a> RemEuclid<&u16> for &'a IBig

type Output = <&'a IBig as RemEuclid<u16>>::Output

fn rem_euclid(self, rhs: &u16) -> Self::Output

impl RemEuclid<&u16> for IBig

type Output = <IBig as RemEuclid<u16>>::Output

fn rem_euclid(self, rhs: &u16) -> Self::Output

impl<'a> RemEuclid<&u32> for &'a IBig

type Output = <&'a IBig as RemEuclid<u32>>::Output

fn rem_euclid(self, rhs: &u32) -> Self::Output

impl RemEuclid<&u32> for IBig

type Output = <IBig as RemEuclid<u32>>::Output

fn rem_euclid(self, rhs: &u32) -> Self::Output

impl<'a> RemEuclid<&u64> for &'a IBig

type Output = <&'a IBig as RemEuclid<u64>>::Output

fn rem_euclid(self, rhs: &u64) -> Self::Output

impl RemEuclid<&u64> for IBig

type Output = <IBig as RemEuclid<u64>>::Output

fn rem_euclid(self, rhs: &u64) -> Self::Output

impl<'a> RemEuclid<&u8> for &'a IBig

type Output = <&'a IBig as RemEuclid<u8>>::Output

fn rem_euclid(self, rhs: &u8) -> Self::Output

impl RemEuclid<&u8> for IBig

type Output = <IBig as RemEuclid<u8>>::Output

fn rem_euclid(self, rhs: &u8) -> Self::Output

impl<'a> RemEuclid<&usize> for &'a IBig

type Output = <&'a IBig as RemEuclid<usize>>::Output

fn rem_euclid(self, rhs: &usize) -> Self::Output

impl RemEuclid<&usize> for IBig

type Output = <IBig as RemEuclid<usize>>::Output

fn rem_euclid(self, rhs: &usize) -> Self::Output

impl RemEuclid<IBig> for &IBig

type Output = IBig

fn rem_euclid(self, rhs: IBig) -> IBig

impl RemEuclid<IBig> for IBig

type Output = IBig

fn rem_euclid(self, rhs: IBig) -> IBig

impl RemEuclid<i128> for &IBig

type Output = i128

fn rem_euclid(self, rhs: i128) -> i128

impl RemEuclid<i128> for IBig

type Output = i128

fn rem_euclid(self, rhs: i128) -> i128

impl RemEuclid<i16> for &IBig

type Output = i16

fn rem_euclid(self, rhs: i16) -> i16

impl RemEuclid<i16> for IBig

type Output = i16

fn rem_euclid(self, rhs: i16) -> i16

impl RemEuclid<i32> for &IBig

type Output = i32

fn rem_euclid(self, rhs: i32) -> i32

impl RemEuclid<i32> for IBig

type Output = i32

fn rem_euclid(self, rhs: i32) -> i32

impl RemEuclid<i64> for &IBig

type Output = i64

fn rem_euclid(self, rhs: i64) -> i64

impl RemEuclid<i64> for IBig

type Output = i64

fn rem_euclid(self, rhs: i64) -> i64

impl RemEuclid<i8> for &IBig

type Output = i8

fn rem_euclid(self, rhs: i8) -> i8

impl RemEuclid<i8> for IBig

type Output = i8

fn rem_euclid(self, rhs: i8) -> i8

impl RemEuclid<isize> for &IBig

type Output = isize

fn rem_euclid(self, rhs: isize) -> isize

impl RemEuclid<isize> for IBig

type Output = isize

fn rem_euclid(self, rhs: isize) -> isize

impl RemEuclid<u128> for &IBig

type Output = u128

fn rem_euclid(self, rhs: u128) -> u128

impl RemEuclid<u128> for IBig

type Output = u128

fn rem_euclid(self, rhs: u128) -> u128

impl RemEuclid<u16> for &IBig

type Output = u16

fn rem_euclid(self, rhs: u16) -> u16

impl RemEuclid<u16> for IBig

type Output = u16

fn rem_euclid(self, rhs: u16) -> u16

impl RemEuclid<u32> for &IBig

type Output = u32

fn rem_euclid(self, rhs: u32) -> u32

impl RemEuclid<u32> for IBig

type Output = u32

fn rem_euclid(self, rhs: u32) -> u32

impl RemEuclid<u64> for &IBig

type Output = u64

fn rem_euclid(self, rhs: u64) -> u64

impl RemEuclid<u64> for IBig

type Output = u64

fn rem_euclid(self, rhs: u64) -> u64

impl RemEuclid<u8> for &IBig

type Output = u8

fn rem_euclid(self, rhs: u8) -> u8

impl RemEuclid<u8> for IBig

type Output = u8

fn rem_euclid(self, rhs: u8) -> u8

impl RemEuclid<usize> for &IBig

type Output = usize

fn rem_euclid(self, rhs: usize) -> usize

impl RemEuclid<usize> for IBig

type Output = usize

fn rem_euclid(self, rhs: usize) -> usize

impl SampleUniform for IBig

type Sampler = UniformIBig

The UniformSampler implementation supporting type X.

impl Serialize for IBig

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Shl<&usize> for &IBig

type Output = IBig

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> IBig

Performs the << operation.

impl Shl<&usize> for IBig

type Output = IBig

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> IBig

Performs the << operation.

impl Shl<usize> for &IBig

type Output = IBig

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> IBig

Performs the << operation.

impl Shl<usize> for IBig

type Output = IBig

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> IBig

Performs the << operation.

impl ShlAssign<&usize> for IBig

fn shl_assign(&mut self, rhs: &usize)

Performs the <<= operation.

impl ShlAssign<usize> for IBig

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl Shr<&usize> for &IBig

type Output = IBig

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> IBig

Performs the >> operation.

impl Shr<&usize> for IBig

type Output = IBig

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> IBig

Performs the >> operation.

impl Shr<usize> for &IBig

type Output = IBig

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> IBig

Performs the >> operation.

impl Shr<usize> for IBig

type Output = IBig

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> IBig

Performs the >> operation.

impl ShrAssign<&usize> for IBig

fn shr_assign(&mut self, rhs: &usize)

Performs the >>= operation.

impl ShrAssign<usize> for IBig

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl Signed for IBig

fn abs(&self) -> Self

Computes the absolute value.

fn abs_sub(&self, other: &Self) -> Self

The positive difference of two numbers.

fn signum(&self) -> Self

Returns the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

impl<'a> Sub<&'a IBig> for &i128

type Output = <i128 as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a IBig> for &i16

type Output = <i16 as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a IBig> for &i32

type Output = <i32 as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a IBig> for &i64

type Output = <i64 as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a IBig> for &i8

type Output = <i8 as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a IBig> for &isize

type Output = <isize as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a IBig> for &u128

type Output = <u128 as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a IBig> for &u16

type Output = <u16 as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a IBig> for &u32

type Output = <u32 as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a IBig> for &u64

type Output = <u64 as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a IBig> for &u8

type Output = <u8 as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl<'a> Sub<&'a IBig> for &usize

type Output = <usize as Sub<&'a IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Self::Output

Performs the - operation.

impl Sub<&IBig> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for i128

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for i16

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for i32

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for i64

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for i8

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for isize

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for u128

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for u16

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for u32

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for u64

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for u8

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl Sub<&IBig> for usize

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> IBig

Performs the - operation.

impl<'a> Sub<&i128> for &'a IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig 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 IBig

type Output = <&'a IBig 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 IBig

type Output = <IBig as Sub<usize>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: &usize) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for &i128

type Output = <i128 as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &i16

type Output = <i16 as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &i32

type Output = <i32 as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &i64

type Output = <i64 as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &i8

type Output = <i8 as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &isize

type Output = <isize as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &u128

type Output = <u128 as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &u16

type Output = <u16 as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &u32

type Output = <u32 as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &u64

type Output = <u64 as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &u8

type Output = <u8 as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for &usize

type Output = <usize as Sub<IBig>>::Output

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Self::Output

Performs the - operation.

impl Sub<IBig> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for i128

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for i16

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for i32

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for i64

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for i8

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for isize

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for u128

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for u16

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for u32

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for u64

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for u8

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<IBig> for usize

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> IBig

Performs the - operation.

impl Sub<i128> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> IBig

Performs the - operation.

impl Sub<i128> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> IBig

Performs the - operation.

impl Sub<i16> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> IBig

Performs the - operation.

impl Sub<i16> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> IBig

Performs the - operation.

impl Sub<i32> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> IBig

Performs the - operation.

impl Sub<i32> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> IBig

Performs the - operation.

impl Sub<i64> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> IBig

Performs the - operation.

impl Sub<i64> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> IBig

Performs the - operation.

impl Sub<i8> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> IBig

Performs the - operation.

impl Sub<i8> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> IBig

Performs the - operation.

impl Sub<isize> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> IBig

Performs the - operation.

impl Sub<isize> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: isize) -> IBig

Performs the - operation.

impl Sub<u128> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> IBig

Performs the - operation.

impl Sub<u128> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> IBig

Performs the - operation.

impl Sub<u16> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> IBig

Performs the - operation.

impl Sub<u16> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> IBig

Performs the - operation.

impl Sub<u32> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> IBig

Performs the - operation.

impl Sub<u32> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> IBig

Performs the - operation.

impl Sub<u64> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> IBig

Performs the - operation.

impl Sub<u64> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> IBig

Performs the - operation.

impl Sub<u8> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> IBig

Performs the - operation.

impl Sub<u8> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> IBig

Performs the - operation.

impl Sub<usize> for &IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> IBig

Performs the - operation.

impl Sub<usize> for IBig

type Output = IBig

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> IBig

Performs the - operation.

impl SubAssign<&IBig> for IBig

fn sub_assign(&mut self, rhs: &IBig)

Performs the -= operation.

impl SubAssign<&i128> for IBig

fn sub_assign(&mut self, rhs: &i128)

Performs the -= operation.

impl SubAssign<&i16> for IBig

fn sub_assign(&mut self, rhs: &i16)

Performs the -= operation.

impl SubAssign<&i32> for IBig

fn sub_assign(&mut self, rhs: &i32)

Performs the -= operation.

impl SubAssign<&i64> for IBig

fn sub_assign(&mut self, rhs: &i64)

Performs the -= operation.

impl SubAssign<&i8> for IBig

fn sub_assign(&mut self, rhs: &i8)

Performs the -= operation.

impl SubAssign<&isize> for IBig

fn sub_assign(&mut self, rhs: &isize)

Performs the -= operation.

impl SubAssign<&u128> for IBig

fn sub_assign(&mut self, rhs: &u128)

Performs the -= operation.

impl SubAssign<&u16> for IBig

fn sub_assign(&mut self, rhs: &u16)

Performs the -= operation.

impl SubAssign<&u32> for IBig

fn sub_assign(&mut self, rhs: &u32)

Performs the -= operation.

impl SubAssign<&u64> for IBig

fn sub_assign(&mut self, rhs: &u64)

Performs the -= operation.

impl SubAssign<&u8> for IBig

fn sub_assign(&mut self, rhs: &u8)

Performs the -= operation.

impl SubAssign<&usize> for IBig

fn sub_assign(&mut self, rhs: &usize)

Performs the -= operation.

impl SubAssign<IBig> for IBig

fn sub_assign(&mut self, rhs: IBig)

Performs the -= operation.

impl SubAssign<i128> for IBig

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl SubAssign<i16> for IBig

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl SubAssign<i32> for IBig

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign<i64> for IBig

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl SubAssign<i8> for IBig

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl SubAssign<isize> for IBig

fn sub_assign(&mut self, rhs: isize)

Performs the -= operation.

impl SubAssign<u128> for IBig

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl SubAssign<u16> for IBig

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl SubAssign<u32> for IBig

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl SubAssign<u64> for IBig

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl SubAssign<u8> for IBig

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl SubAssign<usize> for IBig

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<&IBig> for i128

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> Result<i128, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&IBig> for i16

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> Result<i16, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&IBig> for i32

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> Result<i32, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&IBig> for i64

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> Result<i64, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&IBig> for i8

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> Result<i8, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&IBig> for isize

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> Result<isize, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&IBig> for u128

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> Result<u128, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&IBig> for u16

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> Result<u16, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&IBig> for u32

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> Result<u32, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&IBig> for u64

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> Result<u64, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&IBig> for u8

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> Result<u8, OutOfBoundsError>

Performs the conversion.

impl TryFrom<&IBig> for usize

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: &IBig) -> 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<IBig> for i128

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<i128, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for i16

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<i16, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for i32

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<i32, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for i64

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<i64, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for i8

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<i8, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for isize

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<isize, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for u128

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<u128, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for u16

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<u16, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for u32

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<u32, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for u64

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<u64, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for u8

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<u8, OutOfBoundsError>

Performs the conversion.

impl TryFrom<IBig> for usize

type Error = OutOfBoundsError

The type returned in the event of a conversion error.

fn try_from(value: IBig) -> Result<usize, OutOfBoundsError>

Performs the conversion.

impl UnsignedAbs for &IBig

type Output = UBig

fn unsigned_abs(self) -> UBig

impl UnsignedAbs for IBig

type Output = UBig

fn unsigned_abs(self) -> UBig

impl UpperHex for IBig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Zero for IBig

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 IBig

impl StructuralEq for IBig

impl StructuralPartialEq for IBig