Struct `BigUint`

pub struct BigUint { /* private fields */ }

A big unsigned integer type.

Implementations

`impl BigUint`

const ZERO: Self = _;

A constant BigUint with value 0, useful for static initialization.

const ONE: Self = _;

A constant BigUint with value 1, useful for static initialization.

fn new(digits: Vec<u32>) -> BigUint

Creates and initializes a BigUint.

The base 2³² digits are ordered least significant digit first.

const fn new_const(n: u32) -> Self

Creates a constant BigUint from a primitive u32 value.

Non-const callers should use [From<u32>] instead.

fn from_slice(slice: &[u32]) -> BigUint

Creates and initializes a BigUint.

The base 2³² digits are ordered least significant digit first.

fn assign_from_slice(&mut self, slice: &[u32])

Assign a value to a BigUint.

The base 2³² digits are ordered least significant digit first.

fn from_bytes_be(bytes: &[u8]) -> BigUint

Creates and initializes a BigUint.

The bytes are in big-endian byte order.

Examples

use num_bigint::BigUint;

assert_eq!(BigUint::from_bytes_be(b"A"),
           BigUint::parse_bytes(b"65", 10).unwrap());
assert_eq!(BigUint::from_bytes_be(b"AA"),
           BigUint::parse_bytes(b"16705", 10).unwrap());
assert_eq!(BigUint::from_bytes_be(b"AB"),
           BigUint::parse_bytes(b"16706", 10).unwrap());
assert_eq!(BigUint::from_bytes_be(b"Hello world!"),
           BigUint::parse_bytes(b"22405534230753963835153736737", 10).unwrap());

fn from_bytes_le(bytes: &[u8]) -> BigUint

Creates and initializes a BigUint.

The bytes are in little-endian byte order.

fn parse_bytes(buf: &[u8], radix: u32) -> Option<BigUint>

Creates and initializes a BigUint. The input slice must contain ascii/utf8 characters in [0-9a-zA-Z]. radix must be in the range 2...36.

The function from_str_radix from the Num trait provides the same logic for &str buffers.

Examples

use num_bigint::{BigUint, ToBigUint};

assert_eq!(BigUint::parse_bytes(b"1234", 10), ToBigUint::to_biguint(&1234));
assert_eq!(BigUint::parse_bytes(b"ABCD", 16), ToBigUint::to_biguint(&0xABCD));
assert_eq!(BigUint::parse_bytes(b"G", 16), None);

fn from_radix_be(buf: &[u8], radix: u32) -> Option<BigUint>

Creates and initializes a BigUint. Each u8 of the input slice is interpreted as one digit of the number and must therefore be less than radix.

The bytes are in big-endian byte order. radix must be in the range 2...256.

Examples

use num_bigint::{BigUint};

let inbase190 = &[15, 33, 125, 12, 14];
let a = BigUint::from_radix_be(inbase190, 190).unwrap();
assert_eq!(a.to_radix_be(190), inbase190);

fn from_radix_le(buf: &[u8], radix: u32) -> Option<BigUint>

Creates and initializes a BigUint. Each u8 of the input slice is interpreted as one digit of the number and must therefore be less than radix.

The bytes are in little-endian byte order. radix must be in the range 2...256.

Examples

use num_bigint::{BigUint};

let inbase190 = &[14, 12, 125, 33, 15];
let a = BigUint::from_radix_be(inbase190, 190).unwrap();
assert_eq!(a.to_radix_be(190), inbase190);

fn to_bytes_be(&self) -> Vec<u8>

Returns the byte representation of the BigUint in big-endian byte order.

Examples

use num_bigint::BigUint;

let i = BigUint::parse_bytes(b"1125", 10).unwrap();
assert_eq!(i.to_bytes_be(), vec![4, 101]);

fn to_bytes_le(&self) -> Vec<u8>

Returns the byte representation of the BigUint in little-endian byte order.

Examples

use num_bigint::BigUint;

let i = BigUint::parse_bytes(b"1125", 10).unwrap();
assert_eq!(i.to_bytes_le(), vec![101, 4]);

fn to_u32_digits(&self) -> Vec<u32>

Returns the u32 digits representation of the BigUint ordered least significant digit first.

Examples

use num_bigint::BigUint;

assert_eq!(BigUint::from(1125u32).to_u32_digits(), vec![1125]);
assert_eq!(BigUint::from(4294967295u32).to_u32_digits(), vec![4294967295]);
assert_eq!(BigUint::from(4294967296u64).to_u32_digits(), vec![0, 1]);
assert_eq!(BigUint::from(112500000000u64).to_u32_digits(), vec![830850304, 26]);

fn to_u64_digits(&self) -> Vec<u64>

Returns the u64 digits representation of the BigUint ordered least significant digit first.

Examples

use num_bigint::BigUint;

assert_eq!(BigUint::from(1125u32).to_u64_digits(), vec![1125]);
assert_eq!(BigUint::from(4294967295u32).to_u64_digits(), vec![4294967295]);
assert_eq!(BigUint::from(4294967296u64).to_u64_digits(), vec![4294967296]);
assert_eq!(BigUint::from(112500000000u64).to_u64_digits(), vec![112500000000]);
assert_eq!(BigUint::from(1u128 << 64).to_u64_digits(), vec![0, 1]);

fn iter_u32_digits(&self) -> U32Digits<'_>

Returns an iterator of u32 digits representation of the BigUint ordered least significant digit first.

Examples

use num_bigint::BigUint;

assert_eq!(BigUint::from(1125u32).iter_u32_digits().collect::<Vec<u32>>(), vec![1125]);
assert_eq!(BigUint::from(4294967295u32).iter_u32_digits().collect::<Vec<u32>>(), vec![4294967295]);
assert_eq!(BigUint::from(4294967296u64).iter_u32_digits().collect::<Vec<u32>>(), vec![0, 1]);
assert_eq!(BigUint::from(112500000000u64).iter_u32_digits().collect::<Vec<u32>>(), vec![830850304, 26]);

fn iter_u64_digits(&self) -> U64Digits<'_>

Returns an iterator of u64 digits representation of the BigUint ordered least significant digit first.

Examples

use num_bigint::BigUint;

assert_eq!(BigUint::from(1125u32).iter_u64_digits().collect::<Vec<u64>>(), vec![1125]);
assert_eq!(BigUint::from(4294967295u32).iter_u64_digits().collect::<Vec<u64>>(), vec![4294967295]);
assert_eq!(BigUint::from(4294967296u64).iter_u64_digits().collect::<Vec<u64>>(), vec![4294967296]);
assert_eq!(BigUint::from(112500000000u64).iter_u64_digits().collect::<Vec<u64>>(), vec![112500000000]);
assert_eq!(BigUint::from(1u128 << 64).iter_u64_digits().collect::<Vec<u64>>(), vec![0, 1]);

fn to_str_radix(&self, radix: u32) -> String

Returns the integer formatted as a string in the given radix. radix must be in the range 2...36.

Examples

use num_bigint::BigUint;

let i = BigUint::parse_bytes(b"ff", 16).unwrap();
assert_eq!(i.to_str_radix(16), "ff");

fn to_radix_be(&self, radix: u32) -> Vec<u8>

Returns the integer in the requested base in big-endian digit order. The output is not given in a human readable alphabet but as a zero based u8 number. radix must be in the range 2...256.

Examples

use num_bigint::BigUint;

assert_eq!(BigUint::from(0xFFFFu64).to_radix_be(159),
           vec![2, 94, 27]);
// 0xFFFF = 65535 = 2*(159^2) + 94*159 + 27

fn to_radix_le(&self, radix: u32) -> Vec<u8>

Returns the integer in the requested base in little-endian digit order. The output is not given in a human readable alphabet but as a zero based u8 number. radix must be in the range 2...256.

Examples

use num_bigint::BigUint;

assert_eq!(BigUint::from(0xFFFFu64).to_radix_le(159),
           vec![27, 94, 2]);
// 0xFFFF = 65535 = 27 + 94*159 + 2*(159^2)

fn bits(&self) -> u64

Determines the fewest bits necessary to express the BigUint.

fn pow(&self, exponent: u32) -> Self

Returns self ^ exponent.

fn modpow(&self, exponent: &Self, modulus: &Self) -> Self

Returns (self ^ exponent) % modulus.

Panics if the modulus is zero.

fn modinv(&self, modulus: &Self) -> Option<Self>

Returns the modular multiplicative inverse if it exists, otherwise None.

This solves for x in the interval [0, modulus) such that self * x ≡ 1 (mod modulus). The solution exists if and only if gcd(self, modulus) == 1.

use num_bigint::BigUint;
use num_traits::{One, Zero};

let m = BigUint::from(383_u32);

// Trivial cases
assert_eq!(BigUint::zero().modinv(&m), None);
assert_eq!(BigUint::one().modinv(&m), Some(BigUint::one()));
let neg1 = &m - 1u32;
assert_eq!(neg1.modinv(&m), Some(neg1));

let a = BigUint::from(271_u32);
let x = a.modinv(&m).unwrap();
assert_eq!(x, BigUint::from(106_u32));
assert_eq!(x.modinv(&m).unwrap(), a);
assert!((a * x % m).is_one());

fn sqrt(&self) -> Self

Returns the truncated principal square root of self -- see Roots::sqrt

fn cbrt(&self) -> Self

Returns the truncated principal cube root of self -- see Roots::cbrt.

fn nth_root(&self, n: u32) -> Self

Returns the truncated principal nth root of self -- see Roots::nth_root.

fn trailing_zeros(&self) -> Option<u64>

Returns the number of least-significant bits that are zero, or None if the entire number is zero.

fn trailing_ones(&self) -> u64

Returns the number of least-significant bits that are ones.

fn count_ones(&self) -> u64

Returns the number of one bits.

fn bit(&self, bit: u64) -> bool

Returns whether the bit in the given position is set

fn set_bit(&mut self, bit: u64, value: bool)

Sets or clears the bit in the given position

Note that setting a bit greater than the current bit length, a reallocation may be needed to store the new digits

Trait Implementations

`impl Add for BigUint`

type Output = BigUint;
fn add(self, other: BigUint) -> BigUint

`impl Add<&BigUint> for BigUint`

type Output = BigUint;
fn add(self, other: &BigUint) -> BigUint

`impl Add<&u128> for BigUint`

type Output = BigUint;
fn add(self, other: &u128) -> BigUint

`impl Add<&u16> for BigUint`

type Output = BigUint;
fn add(self, other: &u16) -> BigUint

`impl Add<&u32> for BigUint`

type Output = BigUint;
fn add(self, other: &u32) -> BigUint

`impl Add<&u64> for BigUint`

type Output = BigUint;
fn add(self, other: &u64) -> BigUint

`impl Add<&u8> for BigUint`

type Output = BigUint;
fn add(self, other: &u8) -> BigUint

`impl Add<&usize> for BigUint`

type Output = BigUint;
fn add(self, other: &usize) -> BigUint

`impl Add<u128> for BigUint`

type Output = BigUint;
fn add(self, other: u128) -> BigUint

`impl Add<u16> for BigUint`

type Output = BigUint;
fn add(self, other: u16) -> BigUint

`impl Add<u32> for BigUint`

type Output = BigUint;
fn add(self, other: u32) -> BigUint

`impl Add<u64> for BigUint`

type Output = BigUint;
fn add(self, other: u64) -> BigUint

`impl Add<u8> for BigUint`

type Output = BigUint;
fn add(self, other: u8) -> BigUint

`impl Add<usize> for BigUint`

type Output = BigUint;
fn add(self, other: usize) -> BigUint

`impl AddAssign for BigUint`

fn add_assign(&mut self, other: BigUint)

`impl AddAssign<&BigUint> for BigUint`

fn add_assign(&mut self, other: &BigUint)

`impl AddAssign<u128> for BigUint`

fn add_assign(&mut self, other: u128)

`impl AddAssign<u16> for BigUint`

fn add_assign(&mut self, other: u16)

`impl AddAssign<u32> for BigUint`

fn add_assign(&mut self, other: u32)

`impl AddAssign<u64> for BigUint`

fn add_assign(&mut self, other: u64)

`impl AddAssign<u8> for BigUint`

fn add_assign(&mut self, other: u8)

`impl AddAssign<usize> for BigUint`

fn add_assign(&mut self, other: usize)

`impl Binary for BigUint`

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

`impl BitAnd for BigUint`

type Output = BigUint;
fn bitand(self, other: BigUint) -> BigUint

`impl BitAnd<&BigUint> for BigUint`

type Output = BigUint;
fn bitand(self, other: &BigUint) -> BigUint

`impl BitAndAssign for BigUint`

fn bitand_assign(&mut self, other: BigUint)

`impl BitAndAssign<&BigUint> for BigUint`

fn bitand_assign(&mut self, other: &BigUint)

`impl BitOr for BigUint`

type Output = BigUint;
fn bitor(self, other: BigUint) -> BigUint

`impl BitOr<&BigUint> for BigUint`

type Output = BigUint;
fn bitor(self, other: &BigUint) -> BigUint

`impl BitOrAssign for BigUint`

fn bitor_assign(&mut self, other: BigUint)

`impl BitOrAssign<&BigUint> for BigUint`

fn bitor_assign(&mut self, other: &BigUint)

`impl BitXor for BigUint`

type Output = BigUint;
fn bitxor(self, other: BigUint) -> BigUint

`impl BitXor<&BigUint> for BigUint`

type Output = BigUint;
fn bitxor(self, other: &BigUint) -> BigUint

`impl BitXorAssign for BigUint`

fn bitxor_assign(&mut self, other: BigUint)

`impl BitXorAssign<&BigUint> for BigUint`

fn bitxor_assign(&mut self, other: &BigUint)

`impl CheckedAdd for BigUint`

fn checked_add(&self, v: &BigUint) -> Option<BigUint>

`impl CheckedDiv for BigUint`

fn checked_div(&self, v: &BigUint) -> Option<BigUint>

`impl CheckedEuclid for BigUint`

fn checked_div_euclid(&self, v: &BigUint) -> Option<BigUint>
fn checked_rem_euclid(&self, v: &BigUint) -> Option<BigUint>
fn checked_div_rem_euclid(&self, v: &Self) -> Option<(Self, Self)>

`impl CheckedMul for BigUint`

fn checked_mul(&self, v: &BigUint) -> Option<BigUint>

`impl CheckedSub for BigUint`

fn checked_sub(&self, v: &BigUint) -> Option<BigUint>

`impl Clone for BigUint`

fn clone(&self) -> Self
fn clone_from(&mut self, other: &Self)

`impl ConstOne for BigUint`

const ONE: Self = Self::ONE;

`impl ConstZero for BigUint`

const ZERO: Self = Self::ZERO;

`impl Debug for BigUint`

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

`impl Default for BigUint`

fn default() -> BigUint

`impl Display for BigUint`

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

`impl Div for BigUint`

type Output = BigUint;
fn div(self, other: BigUint) -> BigUint

`impl Div<&BigUint> for BigUint`

type Output = BigUint;
fn div(self, other: &BigUint) -> BigUint

`impl Div<&u128> for BigUint`

type Output = BigUint;
fn div(self, other: &u128) -> BigUint

`impl Div<&u16> for BigUint`

type Output = BigUint;
fn div(self, other: &u16) -> BigUint

`impl Div<&u32> for BigUint`

type Output = BigUint;
fn div(self, other: &u32) -> BigUint

`impl Div<&u64> for BigUint`

type Output = BigUint;
fn div(self, other: &u64) -> BigUint

`impl Div<&u8> for BigUint`

type Output = BigUint;
fn div(self, other: &u8) -> BigUint

`impl Div<&usize> for BigUint`

type Output = BigUint;
fn div(self, other: &usize) -> BigUint

`impl Div<u128> for BigUint`

type Output = BigUint;
fn div(self, other: u128) -> BigUint

`impl Div<u16> for BigUint`

type Output = BigUint;
fn div(self, other: u16) -> BigUint

`impl Div<u32> for BigUint`

type Output = BigUint;
fn div(self, other: u32) -> BigUint

`impl Div<u64> for BigUint`

type Output = BigUint;
fn div(self, other: u64) -> BigUint

`impl Div<u8> for BigUint`

type Output = BigUint;
fn div(self, other: u8) -> BigUint

`impl Div<usize> for BigUint`

type Output = BigUint;
fn div(self, other: usize) -> BigUint

`impl DivAssign for BigUint`

fn div_assign(&mut self, other: BigUint)

`impl DivAssign<&BigUint> for BigUint`

fn div_assign(&mut self, other: &BigUint)

`impl DivAssign<u128> for BigUint`

fn div_assign(&mut self, other: u128)

`impl DivAssign<u16> for BigUint`

fn div_assign(&mut self, other: u16)

`impl DivAssign<u32> for BigUint`

fn div_assign(&mut self, other: u32)

`impl DivAssign<u64> for BigUint`

fn div_assign(&mut self, other: u64)

`impl DivAssign<u8> for BigUint`

fn div_assign(&mut self, other: u8)

`impl DivAssign<usize> for BigUint`

fn div_assign(&mut self, other: usize)

`impl Eq for BigUint`

`impl Euclid for BigUint`

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

`impl From<bool> for BigUint`

fn from(x: bool) -> Self

`impl From<u128> for BigUint`

fn from(n: u128) -> Self

`impl From<u16> for BigUint`

fn from(n: u16) -> Self

`impl From<u32> for BigUint`

fn from(n: u32) -> Self

`impl From<u64> for BigUint`

fn from(n: u64) -> Self

`impl From<u8> for BigUint`

fn from(n: u8) -> Self

`impl From<usize> for BigUint`

fn from(n: usize) -> Self

`impl FromBytes for BigUint`

type Bytes = [u8];
fn from_be_bytes(bytes: &Self::Bytes) -> Self
fn from_le_bytes(bytes: &Self::Bytes) -> Self

`impl FromPrimitive for BigUint`

fn from_i64(n: i64) -> Option<BigUint>
fn from_i128(n: i128) -> Option<BigUint>
fn from_u64(n: u64) -> Option<BigUint>
fn from_u128(n: u128) -> Option<BigUint>
fn from_f64(n: f64) -> Option<BigUint>

`impl FromStr for BigUint`

type Err = ParseBigIntError;
fn from_str(s: &str) -> Result<BigUint, ParseBigIntError>

`impl Hash for BigUint`

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

`impl Integer for BigUint`

fn div_rem(&self, other: &BigUint) -> (BigUint, BigUint)
fn div_floor(&self, other: &BigUint) -> BigUint
fn mod_floor(&self, other: &BigUint) -> BigUint
fn div_mod_floor(&self, other: &BigUint) -> (BigUint, BigUint)
fn div_ceil(&self, other: &BigUint) -> BigUint
fn gcd(&self, other: &Self) -> Self: Calculates the Greatest Common Divisor (GCD) of the number and other.
fn lcm(&self, other: &BigUint) -> BigUint: Calculates the Lowest Common Multiple (LCM) of the number and other.
fn gcd_lcm(&self, other: &Self) -> (Self, Self): Calculates the Greatest Common Divisor (GCD) and Lowest Common Multiple (LCM) together.
fn divides(&self, other: &BigUint) -> bool: Deprecated, use is_multiple_of instead.
fn is_multiple_of(&self, other: &BigUint) -> bool: Returns true if the number is a multiple of other.
fn is_even(&self) -> bool: Returns true if the number is divisible by 2.
fn is_odd(&self) -> bool: Returns true if the number is not divisible by 2.
fn next_multiple_of(&self, other: &Self) -> Self: Rounds up to nearest multiple of argument.
fn prev_multiple_of(&self, other: &Self) -> Self: Rounds down to nearest multiple of argument.
fn dec(&mut self)
fn inc(&mut self)

`impl LowerBounded for BigUint`

fn min_value() -> Self

`impl LowerHex for BigUint`

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

`impl Mul for BigUint`

type Output = BigUint;
fn mul(self, other: BigUint) -> BigUint

`impl Mul<&BigUint> for BigUint`

type Output = BigUint;
fn mul(self, other: &BigUint) -> BigUint

`impl Mul<&u128> for BigUint`

type Output = BigUint;
fn mul(self, other: &u128) -> BigUint

`impl Mul<&u16> for BigUint`

type Output = BigUint;
fn mul(self, other: &u16) -> BigUint

`impl Mul<&u32> for BigUint`

type Output = BigUint;
fn mul(self, other: &u32) -> BigUint

`impl Mul<&u64> for BigUint`

type Output = BigUint;
fn mul(self, other: &u64) -> BigUint

`impl Mul<&u8> for BigUint`

type Output = BigUint;
fn mul(self, other: &u8) -> BigUint

`impl Mul<&usize> for BigUint`

type Output = BigUint;
fn mul(self, other: &usize) -> BigUint

`impl Mul<u128> for BigUint`

type Output = BigUint;
fn mul(self, other: u128) -> BigUint

`impl Mul<u16> for BigUint`

type Output = BigUint;
fn mul(self, other: u16) -> BigUint

`impl Mul<u32> for BigUint`

type Output = BigUint;
fn mul(self, other: u32) -> BigUint

`impl Mul<u64> for BigUint`

type Output = BigUint;
fn mul(self, other: u64) -> BigUint

`impl Mul<u8> for BigUint`

type Output = BigUint;
fn mul(self, other: u8) -> BigUint

`impl Mul<usize> for BigUint`

type Output = BigUint;
fn mul(self, other: usize) -> BigUint

`impl MulAssign for BigUint`

fn mul_assign(&mut self, other: BigUint)

`impl MulAssign<&BigUint> for BigUint`

fn mul_assign(&mut self, other: &BigUint)

`impl MulAssign<u128> for BigUint`

fn mul_assign(&mut self, other: u128)

`impl MulAssign<u16> for BigUint`

fn mul_assign(&mut self, other: u16)

`impl MulAssign<u32> for BigUint`

fn mul_assign(&mut self, other: u32)

`impl MulAssign<u64> for BigUint`

fn mul_assign(&mut self, other: u64)

`impl MulAssign<u8> for BigUint`

fn mul_assign(&mut self, other: u8)

`impl MulAssign<usize> for BigUint`

fn mul_assign(&mut self, other: usize)

`impl Num for BigUint`

type FromStrRadixErr = ParseBigIntError;
fn from_str_radix(s: &str, radix: u32) -> Result<BigUint, ParseBigIntError>: Creates and initializes a BigUint.

`impl Octal for BigUint`

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

`impl One for BigUint`

fn one() -> BigUint
fn set_one(&mut self)
fn is_one(&self) -> bool

`impl Ord for BigUint`

fn cmp(&self, other: &BigUint) -> Ordering

`impl PartialEq for BigUint`

fn eq(&self, other: &BigUint) -> bool

`impl PartialOrd for BigUint`

fn partial_cmp(&self, other: &BigUint) -> Option<Ordering>

`impl Pow<&BigUint> for BigUint`

type Output = BigUint;
fn pow(self, exp: &BigUint) -> BigUint

`impl Pow<&u128> for BigUint`

type Output = BigUint;
fn pow(self, exp: &u128) -> BigUint

`impl Pow<&u16> for BigUint`

type Output = BigUint;
fn pow(self, exp: &u16) -> BigUint

`impl Pow<&u32> for BigUint`

type Output = BigUint;
fn pow(self, exp: &u32) -> BigUint

`impl Pow<&u64> for BigUint`

type Output = BigUint;
fn pow(self, exp: &u64) -> BigUint

`impl Pow<&u8> for BigUint`

type Output = BigUint;
fn pow(self, exp: &u8) -> BigUint

`impl Pow<&usize> for BigUint`

type Output = BigUint;
fn pow(self, exp: &usize) -> BigUint

`impl Pow<BigUint> for BigUint`

type Output = BigUint;
fn pow(self, exp: BigUint) -> BigUint

`impl Pow<u128> for BigUint`

type Output = BigUint;
fn pow(self, exp: u128) -> BigUint

`impl Pow<u16> for BigUint`

type Output = BigUint;
fn pow(self, exp: u16) -> BigUint

`impl Pow<u32> for BigUint`

type Output = BigUint;
fn pow(self, exp: u32) -> BigUint

`impl Pow<u64> for BigUint`

type Output = BigUint;
fn pow(self, exp: u64) -> BigUint

`impl Pow<u8> for BigUint`

type Output = BigUint;
fn pow(self, exp: u8) -> BigUint

`impl Pow<usize> for BigUint`

type Output = BigUint;
fn pow(self, exp: usize) -> BigUint

`impl Rem for BigUint`

type Output = BigUint;
fn rem(self, other: BigUint) -> BigUint

`impl Rem<&BigUint> for BigUint`

type Output = BigUint;
fn rem(self, other: &BigUint) -> BigUint

`impl Rem<&u128> for BigUint`

type Output = BigUint;
fn rem(self, other: &u128) -> BigUint

`impl Rem<&u16> for BigUint`

type Output = BigUint;
fn rem(self, other: &u16) -> BigUint

`impl Rem<&u32> for BigUint`

type Output = BigUint;
fn rem(self, other: &u32) -> BigUint

`impl Rem<&u64> for BigUint`

type Output = BigUint;
fn rem(self, other: &u64) -> BigUint

`impl Rem<&u8> for BigUint`

type Output = BigUint;
fn rem(self, other: &u8) -> BigUint

`impl Rem<&usize> for BigUint`

type Output = BigUint;
fn rem(self, other: &usize) -> BigUint

`impl Rem<u128> for BigUint`

type Output = BigUint;
fn rem(self, other: u128) -> BigUint

`impl Rem<u16> for BigUint`

type Output = BigUint;
fn rem(self, other: u16) -> BigUint

`impl Rem<u32> for BigUint`

type Output = BigUint;
fn rem(self, other: u32) -> BigUint

`impl Rem<u64> for BigUint`

type Output = BigUint;
fn rem(self, other: u64) -> BigUint

`impl Rem<u8> for BigUint`

type Output = BigUint;
fn rem(self, other: u8) -> BigUint

`impl Rem<usize> for BigUint`

type Output = BigUint;
fn rem(self, other: usize) -> BigUint

`impl RemAssign for BigUint`

fn rem_assign(&mut self, other: BigUint)

`impl RemAssign<&BigUint> for BigUint`

fn rem_assign(&mut self, other: &BigUint)

`impl RemAssign<u128> for BigUint`

fn rem_assign(&mut self, other: u128)

`impl RemAssign<u16> for BigUint`

fn rem_assign(&mut self, other: u16)

`impl RemAssign<u32> for BigUint`

fn rem_assign(&mut self, other: u32)

`impl RemAssign<u64> for BigUint`

fn rem_assign(&mut self, other: u64)

`impl RemAssign<u8> for BigUint`

fn rem_assign(&mut self, other: u8)

`impl RemAssign<usize> for BigUint`

fn rem_assign(&mut self, other: usize)

`impl Roots for BigUint`

fn nth_root(&self, n: u32) -> Self
fn sqrt(&self) -> Self
fn cbrt(&self) -> Self

`impl Serialize for BigUint`

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,

`impl Shl<&i128> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &i128) -> BigUint

`impl Shl<&i16> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &i16) -> BigUint

`impl Shl<&i32> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &i32) -> BigUint

`impl Shl<&i64> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &i64) -> BigUint

`impl Shl<&i8> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &i8) -> BigUint

`impl Shl<&isize> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &isize) -> BigUint

`impl Shl<&u128> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &u128) -> BigUint

`impl Shl<&u16> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &u16) -> BigUint

`impl Shl<&u32> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &u32) -> BigUint

`impl Shl<&u64> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &u64) -> BigUint

`impl Shl<&u8> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &u8) -> BigUint

`impl Shl<&usize> for BigUint`

type Output = BigUint;
fn shl(self, rhs: &usize) -> BigUint

`impl Shl<i128> for BigUint`

type Output = BigUint;
fn shl(self, rhs: i128) -> BigUint

`impl Shl<i16> for BigUint`

type Output = BigUint;
fn shl(self, rhs: i16) -> BigUint

`impl Shl<i32> for BigUint`

type Output = BigUint;
fn shl(self, rhs: i32) -> BigUint

`impl Shl<i64> for BigUint`

type Output = BigUint;
fn shl(self, rhs: i64) -> BigUint

`impl Shl<i8> for BigUint`

type Output = BigUint;
fn shl(self, rhs: i8) -> BigUint

`impl Shl<isize> for BigUint`

type Output = BigUint;
fn shl(self, rhs: isize) -> BigUint

`impl Shl<u128> for BigUint`

type Output = BigUint;
fn shl(self, rhs: u128) -> BigUint

`impl Shl<u16> for BigUint`

type Output = BigUint;
fn shl(self, rhs: u16) -> BigUint

`impl Shl<u32> for BigUint`

type Output = BigUint;
fn shl(self, rhs: u32) -> BigUint

`impl Shl<u64> for BigUint`

type Output = BigUint;
fn shl(self, rhs: u64) -> BigUint

`impl Shl<u8> for BigUint`

type Output = BigUint;
fn shl(self, rhs: u8) -> BigUint

`impl Shl<usize> for BigUint`

type Output = BigUint;
fn shl(self, rhs: usize) -> BigUint

`impl ShlAssign<&i128> for BigUint`

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

`impl ShlAssign<&i16> for BigUint`

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

`impl ShlAssign<&i32> for BigUint`

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

`impl ShlAssign<&i64> for BigUint`

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

`impl ShlAssign<&i8> for BigUint`

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

`impl ShlAssign<&isize> for BigUint`

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

`impl ShlAssign<&u128> for BigUint`

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

`impl ShlAssign<&u16> for BigUint`

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

`impl ShlAssign<&u32> for BigUint`

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

`impl ShlAssign<&u64> for BigUint`

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

`impl ShlAssign<&u8> for BigUint`

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

`impl ShlAssign<&usize> for BigUint`

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

`impl ShlAssign<i128> for BigUint`

fn shl_assign(&mut self, rhs: i128)

`impl ShlAssign<i16> for BigUint`

fn shl_assign(&mut self, rhs: i16)

`impl ShlAssign<i32> for BigUint`

fn shl_assign(&mut self, rhs: i32)

`impl ShlAssign<i64> for BigUint`

fn shl_assign(&mut self, rhs: i64)

`impl ShlAssign<i8> for BigUint`

fn shl_assign(&mut self, rhs: i8)

`impl ShlAssign<isize> for BigUint`

fn shl_assign(&mut self, rhs: isize)

`impl ShlAssign<u128> for BigUint`

fn shl_assign(&mut self, rhs: u128)

`impl ShlAssign<u16> for BigUint`

fn shl_assign(&mut self, rhs: u16)

`impl ShlAssign<u32> for BigUint`

fn shl_assign(&mut self, rhs: u32)

`impl ShlAssign<u64> for BigUint`

fn shl_assign(&mut self, rhs: u64)

`impl ShlAssign<u8> for BigUint`

fn shl_assign(&mut self, rhs: u8)

`impl ShlAssign<usize> for BigUint`

fn shl_assign(&mut self, rhs: usize)

`impl Shr<&i128> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &i128) -> BigUint

`impl Shr<&i16> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &i16) -> BigUint

`impl Shr<&i32> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &i32) -> BigUint

`impl Shr<&i64> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &i64) -> BigUint

`impl Shr<&i8> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &i8) -> BigUint

`impl Shr<&isize> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &isize) -> BigUint

`impl Shr<&u128> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &u128) -> BigUint

`impl Shr<&u16> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &u16) -> BigUint

`impl Shr<&u32> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &u32) -> BigUint

`impl Shr<&u64> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &u64) -> BigUint

`impl Shr<&u8> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &u8) -> BigUint

`impl Shr<&usize> for BigUint`

type Output = BigUint;
fn shr(self, rhs: &usize) -> BigUint

`impl Shr<i128> for BigUint`

type Output = BigUint;
fn shr(self, rhs: i128) -> BigUint

`impl Shr<i16> for BigUint`

type Output = BigUint;
fn shr(self, rhs: i16) -> BigUint

`impl Shr<i32> for BigUint`

type Output = BigUint;
fn shr(self, rhs: i32) -> BigUint

`impl Shr<i64> for BigUint`

type Output = BigUint;
fn shr(self, rhs: i64) -> BigUint

`impl Shr<i8> for BigUint`

type Output = BigUint;
fn shr(self, rhs: i8) -> BigUint

`impl Shr<isize> for BigUint`

type Output = BigUint;
fn shr(self, rhs: isize) -> BigUint

`impl Shr<u128> for BigUint`

type Output = BigUint;
fn shr(self, rhs: u128) -> BigUint

`impl Shr<u16> for BigUint`

type Output = BigUint;
fn shr(self, rhs: u16) -> BigUint

`impl Shr<u32> for BigUint`

type Output = BigUint;
fn shr(self, rhs: u32) -> BigUint

`impl Shr<u64> for BigUint`

type Output = BigUint;
fn shr(self, rhs: u64) -> BigUint

`impl Shr<u8> for BigUint`

type Output = BigUint;
fn shr(self, rhs: u8) -> BigUint

`impl Shr<usize> for BigUint`

type Output = BigUint;
fn shr(self, rhs: usize) -> BigUint

`impl ShrAssign<&i128> for BigUint`

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

`impl ShrAssign<&i16> for BigUint`

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

`impl ShrAssign<&i32> for BigUint`

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

`impl ShrAssign<&i64> for BigUint`

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

`impl ShrAssign<&i8> for BigUint`

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

`impl ShrAssign<&isize> for BigUint`

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

`impl ShrAssign<&u128> for BigUint`

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

`impl ShrAssign<&u16> for BigUint`

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

`impl ShrAssign<&u32> for BigUint`

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

`impl ShrAssign<&u64> for BigUint`

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

`impl ShrAssign<&u8> for BigUint`

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

`impl ShrAssign<&usize> for BigUint`

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

`impl ShrAssign<i128> for BigUint`

fn shr_assign(&mut self, rhs: i128)

`impl ShrAssign<i16> for BigUint`

fn shr_assign(&mut self, rhs: i16)

`impl ShrAssign<i32> for BigUint`

fn shr_assign(&mut self, rhs: i32)

`impl ShrAssign<i64> for BigUint`

fn shr_assign(&mut self, rhs: i64)

`impl ShrAssign<i8> for BigUint`

fn shr_assign(&mut self, rhs: i8)

`impl ShrAssign<isize> for BigUint`

fn shr_assign(&mut self, rhs: isize)

`impl ShrAssign<u128> for BigUint`

fn shr_assign(&mut self, rhs: u128)

`impl ShrAssign<u16> for BigUint`

fn shr_assign(&mut self, rhs: u16)

`impl ShrAssign<u32> for BigUint`

fn shr_assign(&mut self, rhs: u32)

`impl ShrAssign<u64> for BigUint`

fn shr_assign(&mut self, rhs: u64)

`impl ShrAssign<u8> for BigUint`

fn shr_assign(&mut self, rhs: u8)

`impl ShrAssign<usize> for BigUint`

fn shr_assign(&mut self, rhs: usize)

`impl Sub for BigUint`

type Output = BigUint;
fn sub(self, other: BigUint) -> BigUint

`impl Sub<&BigUint> for BigUint`

type Output = BigUint;
fn sub(self, other: &BigUint) -> BigUint

`impl Sub<&u128> for BigUint`

type Output = BigUint;
fn sub(self, other: &u128) -> BigUint

`impl Sub<&u16> for BigUint`

type Output = BigUint;
fn sub(self, other: &u16) -> BigUint

`impl Sub<&u32> for BigUint`

type Output = BigUint;
fn sub(self, other: &u32) -> BigUint

`impl Sub<&u64> for BigUint`

type Output = BigUint;
fn sub(self, other: &u64) -> BigUint

`impl Sub<&u8> for BigUint`

type Output = BigUint;
fn sub(self, other: &u8) -> BigUint

`impl Sub<&usize> for BigUint`

type Output = BigUint;
fn sub(self, other: &usize) -> BigUint

`impl Sub<u128> for BigUint`

type Output = BigUint;
fn sub(self, other: u128) -> BigUint

`impl Sub<u16> for BigUint`

type Output = BigUint;
fn sub(self, other: u16) -> BigUint

`impl Sub<u32> for BigUint`

type Output = BigUint;
fn sub(self, other: u32) -> BigUint

`impl Sub<u64> for BigUint`

type Output = BigUint;
fn sub(self, other: u64) -> BigUint

`impl Sub<u8> for BigUint`

type Output = BigUint;
fn sub(self, other: u8) -> BigUint

`impl Sub<usize> for BigUint`

type Output = BigUint;
fn sub(self, other: usize) -> BigUint

`impl SubAssign for BigUint`

fn sub_assign(&mut self, other: BigUint)

`impl SubAssign<&BigUint> for BigUint`

fn sub_assign(&mut self, other: &BigUint)

`impl SubAssign<u128> for BigUint`

fn sub_assign(&mut self, other: u128)

`impl SubAssign<u16> for BigUint`

fn sub_assign(&mut self, other: u16)

`impl SubAssign<u32> for BigUint`

fn sub_assign(&mut self, other: u32)

`impl SubAssign<u64> for BigUint`

fn sub_assign(&mut self, other: u64)

`impl SubAssign<u8> for BigUint`

fn sub_assign(&mut self, other: u8)

`impl SubAssign<usize> for BigUint`

fn sub_assign(&mut self, other: usize)

`impl ToBigInt for BigUint`

fn to_bigint(&self) -> Option<BigInt>

`impl ToBigUint for BigUint`

fn to_biguint(&self) -> Option<BigUint>

`impl ToBytes for BigUint`

type Bytes = Vec<u8>;
fn to_be_bytes(&self) -> Self::Bytes
fn to_le_bytes(&self) -> Self::Bytes

`impl ToPrimitive for BigUint`

fn to_i64(&self) -> Option<i64>
fn to_i128(&self) -> Option<i128>
fn to_u64(&self) -> Option<u64>
fn to_u128(&self) -> Option<u128>
fn to_f32(&self) -> Option<f32>
fn to_f64(&self) -> Option<f64>

`impl TryFrom<&BigInt> for BigUint`

type Error = TryFromBigIntError<()>;
fn try_from(value: &BigInt) -> Result<BigUint, TryFromBigIntError<()>>

`impl TryFrom<BigInt> for BigUint`

type Error = TryFromBigIntError<BigInt>;
fn try_from(value: BigInt) -> Result<BigUint, TryFromBigIntError<BigInt>>

`impl TryFrom<i128> for BigUint`

type Error = TryFromBigIntError<()>;
fn try_from(value: i128) -> Result<BigUint, TryFromBigIntError<()>>

`impl TryFrom<i16> for BigUint`

type Error = TryFromBigIntError<()>;
fn try_from(value: i16) -> Result<BigUint, TryFromBigIntError<()>>

`impl TryFrom<i32> for BigUint`

type Error = TryFromBigIntError<()>;
fn try_from(value: i32) -> Result<BigUint, TryFromBigIntError<()>>

`impl TryFrom<i64> for BigUint`

type Error = TryFromBigIntError<()>;
fn try_from(value: i64) -> Result<BigUint, TryFromBigIntError<()>>

`impl TryFrom<i8> for BigUint`

type Error = TryFromBigIntError<()>;
fn try_from(value: i8) -> Result<BigUint, TryFromBigIntError<()>>

`impl TryFrom<isize> for BigUint`

type Error = TryFromBigIntError<()>;
fn try_from(value: isize) -> Result<BigUint, TryFromBigIntError<()>>

`impl Unsigned for BigUint`

`impl UpperHex for BigUint`

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

`impl Zero for BigUint`

fn zero() -> BigUint
fn set_zero(&mut self)
fn is_zero(&self) -> bool

`impl<'de> Deserialize<'de> for BigUint`

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

`impl<T> Product<T> for BigUint where BigUint: Mul<T, Output = BigUint>,`

fn product(iter: I) -> Self where I: Iterator<Item = T>,

`impl<T> Sum<T> for BigUint where BigUint: Add<T, Output = BigUint>,`

fn sum(iter: I) -> Self where I: Iterator<Item = T>,

Auto Trait Implementations

`impl Freeze for BigUint`

`impl RefUnwindSafe for BigUint`

`impl Send for BigUint`

`impl Sync for BigUint`

`impl Unpin for BigUint`

`impl UnsafeUnpin for BigUint`

`impl UnwindSafe for BigUint`

Blanket Implementations

`impl Average for BigUint where &'a I: for<'a, 'b> BitAnd<&'b I, Output = I> + for<'a, 'b> BitOr<&'b I, Output = I> + for<'a, 'b> BitXor<&'b I, Output = I>, I: Integer + Shr<usize, Output = I>,`

fn average_floor(&self, other: &I) -> I: Returns the floor value of the average of self and other.
fn average_ceil(&self, other: &I) -> I: Returns the ceil value of the average of self and other.

`impl<T> Any for BigUint where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for BigUint where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for BigUint where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for BigUint where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> DeserializeOwned for BigUint where T: for<'de> Deserialize<'de>,`

`impl<T> From<T> for BigUint`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> NumAssign for BigUint where T: Num + NumAssignOps,`

`impl<T> NumAssignRef for BigUint where T: NumAssign + for<'r> NumAssignOps<&'r T>,`

`impl<T> NumRef for BigUint where T: Num + for<'r> NumOps<&'r T>,`

`impl<T> ToOwned for BigUint where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T> ToString for BigUint where T: Display + ?Sized,`

fn to_string(&self) -> String

`impl<T, Base> RefNum<Base> for BigUint where T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base>,`

`impl<T, Rhs> NumAssignOps<Rhs> for BigUint where T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,`

`impl<T, Rhs, Output> NumOps<Rhs, Output> for BigUint where T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,`

`impl<T, U> Into for BigUint where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for BigUint where U: Into<T>,`

type Error = never;
fn try_from(value: U) -> Result<T, never>

`impl<T, U> TryInto for BigUint where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>