`impl BigInt`

fn new(sign: Sign, digits: Vec<u32>) -> BigInt

Creates and initializes a BigInt.

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

fn from_biguint(sign: Sign, data: BigUint) -> BigInt

Creates and initializes a BigInt.

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

fn from_slice(sign: Sign, slice: &[u32]) -> BigInt

Creates and initializes a BigInt.

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

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

Reinitializes a BigInt.

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

fn from_bytes_be(sign: Sign, bytes: &[u8]) -> BigInt

Creates and initializes a BigInt.

The bytes are in big-endian byte order.

Examples

use num_bigint::{BigInt, Sign};

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

fn from_bytes_le(sign: Sign, bytes: &[u8]) -> BigInt

Creates and initializes a BigInt.

The bytes are in little-endian byte order.

fn from_signed_bytes_be(digits: &[u8]) -> BigInt

Creates and initializes a BigInt from an array of bytes in two's complement binary representation.

The digits are in big-endian base 2⁸.

fn from_signed_bytes_le(digits: &[u8]) -> BigInt

Creates and initializes a BigInt from an array of bytes in two's complement.

The digits are in little-endian base 2⁸.

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

Creates and initializes a BigInt.

Examples

use num_bigint::{BigInt, ToBigInt};

assert_eq!(BigInt::parse_bytes(b"1234", 10), ToBigInt::to_bigint(&1234));
assert_eq!(BigInt::parse_bytes(b"ABCD", 16), ToBigInt::to_bigint(&0xABCD));
assert_eq!(BigInt::parse_bytes(b"G", 16), None);

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

Creates and initializes a BigInt. 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::{BigInt, Sign};

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

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

Creates and initializes a BigInt. 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::{BigInt, Sign};

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

fn to_bytes_be(self: &Self) -> (Sign, Vec<u8>)

Returns the sign and the byte representation of the BigInt in big-endian byte order.

Examples

use num_bigint::{ToBigInt, Sign};

let i = -1125.to_bigint().unwrap();
assert_eq!(i.to_bytes_be(), (Sign::Minus, vec![4, 101]));

fn to_bytes_le(self: &Self) -> (Sign, Vec<u8>)

Returns the sign and the byte representation of the BigInt in little-endian byte order.

Examples

use num_bigint::{ToBigInt, Sign};

let i = -1125.to_bigint().unwrap();
assert_eq!(i.to_bytes_le(), (Sign::Minus, vec![101, 4]));

fn to_u32_digits(self: &Self) -> (Sign, Vec<u32>)

Returns the sign and the u32 digits representation of the BigInt ordered least significant digit first.

Examples

use num_bigint::{BigInt, Sign};

assert_eq!(BigInt::from(-1125).to_u32_digits(), (Sign::Minus, vec![1125]));
assert_eq!(BigInt::from(4294967295u32).to_u32_digits(), (Sign::Plus, vec![4294967295]));
assert_eq!(BigInt::from(4294967296u64).to_u32_digits(), (Sign::Plus, vec![0, 1]));
assert_eq!(BigInt::from(-112500000000i64).to_u32_digits(), (Sign::Minus, vec![830850304, 26]));
assert_eq!(BigInt::from(112500000000i64).to_u32_digits(), (Sign::Plus, vec![830850304, 26]));

fn to_u64_digits(self: &Self) -> (Sign, Vec<u64>)

Returns the sign and the u64 digits representation of the BigInt ordered least significant digit first.

Examples

use num_bigint::{BigInt, Sign};

assert_eq!(BigInt::from(-1125).to_u64_digits(), (Sign::Minus, vec![1125]));
assert_eq!(BigInt::from(4294967295u32).to_u64_digits(), (Sign::Plus, vec![4294967295]));
assert_eq!(BigInt::from(4294967296u64).to_u64_digits(), (Sign::Plus, vec![4294967296]));
assert_eq!(BigInt::from(-112500000000i64).to_u64_digits(), (Sign::Minus, vec![112500000000]));
assert_eq!(BigInt::from(112500000000i64).to_u64_digits(), (Sign::Plus, vec![112500000000]));
assert_eq!(BigInt::from(1u128 << 64).to_u64_digits(), (Sign::Plus, vec![0, 1]));

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

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

Examples

use num_bigint::BigInt;

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

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

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

Examples

use num_bigint::BigInt;

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

fn to_signed_bytes_be(self: &Self) -> Vec<u8>

Returns the two's-complement byte representation of the BigInt in big-endian byte order.

Examples

use num_bigint::ToBigInt;

let i = -1125.to_bigint().unwrap();
assert_eq!(i.to_signed_bytes_be(), vec![251, 155]);

fn to_signed_bytes_le(self: &Self) -> Vec<u8>

Returns the two's-complement byte representation of the BigInt in little-endian byte order.

Examples

use num_bigint::ToBigInt;

let i = -1125.to_bigint().unwrap();
assert_eq!(i.to_signed_bytes_le(), vec![155, 251]);

fn to_str_radix(self: &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::BigInt;

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

fn to_radix_be(self: &Self, radix: u32) -> (Sign, 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::{BigInt, Sign};

assert_eq!(BigInt::from(-0xFFFFi64).to_radix_be(159),
           (Sign::Minus, vec![2, 94, 27]));
// 0xFFFF = 65535 = 2*(159^2) + 94*159 + 27

fn to_radix_le(self: &Self, radix: u32) -> (Sign, 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::{BigInt, Sign};

assert_eq!(BigInt::from(-0xFFFFi64).to_radix_le(159),
           (Sign::Minus, vec![27, 94, 2]));
// 0xFFFF = 65535 = 27 + 94*159 + 2*(159^2)

fn sign(self: &Self) -> Sign

Returns the sign of the BigInt as a Sign.

Examples

use num_bigint::{BigInt, Sign};

assert_eq!(BigInt::from(1234).sign(), Sign::Plus);
assert_eq!(BigInt::from(-4321).sign(), Sign::Minus);
assert_eq!(BigInt::ZERO.sign(), Sign::NoSign);

fn magnitude(self: &Self) -> &BigUint

Returns the magnitude of the BigInt as a BigUint.

Examples

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

assert_eq!(BigInt::from(1234).magnitude(), &BigUint::from(1234u32));
assert_eq!(BigInt::from(-4321).magnitude(), &BigUint::from(4321u32));
assert!(BigInt::ZERO.magnitude().is_zero());

fn into_parts(self: Self) -> (Sign, BigUint)

Convert this BigInt into its Sign and BigUint magnitude, the reverse of [BigInt::from_biguint()].

Examples

use num_bigint::{BigInt, BigUint, Sign};

assert_eq!(BigInt::from(1234).into_parts(), (Sign::Plus, BigUint::from(1234u32)));
assert_eq!(BigInt::from(-4321).into_parts(), (Sign::Minus, BigUint::from(4321u32)));
assert_eq!(BigInt::ZERO.into_parts(), (Sign::NoSign, BigUint::ZERO));

fn bits(self: &Self) -> u64

Determines the fewest bits necessary to express the BigInt, not including the sign.

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

Converts this BigInt into a BigUint, if it's not negative.

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

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

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

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

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

Returns self ^ exponent.

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

Returns (self ^ exponent) mod modulus

Note that this rounds like mod_floor, not like the % operator, which makes a difference when given a negative self or modulus. The result will be in the interval [0, modulus) for modulus > 0, or in the interval (modulus, 0] for modulus < 0

Panics if the exponent is negative or the modulus is zero.

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

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

This solves for x such that self * x ≡ 1 (mod modulus). Note that this rounds like mod_floor, not like the % operator, which makes a difference when given a negative self or modulus. The solution will be in the interval [0, modulus) for modulus > 0, or in the interval (modulus, 0] for modulus < 0, and it exists if and only if gcd(self, modulus) == 1.

use num_bigint::BigInt;
use num_integer::Integer;
use num_traits::{One, Zero};

let m = BigInt::from(383);

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

// Positive self and modulus
let a = BigInt::from(271);
let x = a.modinv(&m).unwrap();
assert_eq!(x, BigInt::from(106));
assert_eq!(x.modinv(&m).unwrap(), a);
assert_eq!((&a * x).mod_floor(&m), BigInt::one());

// Negative self and positive modulus
let b = -&a;
let x = b.modinv(&m).unwrap();
assert_eq!(x, BigInt::from(277));
assert_eq!((&b * x).mod_floor(&m), BigInt::one());

// Positive self and negative modulus
let n = -&m;
let x = a.modinv(&n).unwrap();
assert_eq!(x, BigInt::from(-277));
assert_eq!((&a * x).mod_floor(&n), &n + 1);

// Negative self and modulus
let x = b.modinv(&n).unwrap();
assert_eq!(x, BigInt::from(-106));
assert_eq!((&b * x).mod_floor(&n), &n + 1);

fn sqrt(self: &Self) -> Self

Returns the truncated principal square root of self -- see [num_integer::Roots::sqrt()].

fn cbrt(self: &Self) -> Self

Returns the truncated principal cube root of self -- see [num_integer::Roots::cbrt()].

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

Returns the truncated principal nth root of self -- See [num_integer::Roots::nth_root()].

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

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

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

Returns whether the bit in position bit is set, using the two's complement for negative numbers

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

Sets or clears the bit in the given position, using the two's complement for negative numbers

Note that setting/clearing a bit (for positive/negative numbers, respectively) greater than the current bit length, a reallocation may be needed to store the new digits

`impl Add for BigInt`

fn add(self: Self, other: &i32) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: u32) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: u16) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: u64) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: i8) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: isize) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: u128) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &u128) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &u16) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &i8) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: i32) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &isize) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: i64) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: i128) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &i128) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: BigInt) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &u64) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: u8) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: usize) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: i16) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &i64) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &BigInt) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &u8) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &usize) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &i16) -> BigInt

`impl Add for BigInt`

fn add(self: Self, other: &u32) -> BigInt

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: BigInt)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: i16)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: u8)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: isize)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: u32)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: u64)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: u128)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: u16)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: i32)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: i64)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: i128)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: usize)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: &BigInt)

`impl AddAssign for BigInt`

fn add_assign(self: &mut Self, other: i8)

`impl Binary for BigInt`

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

`impl BitAnd for BigInt`

fn bitand(self: Self, other: &BigInt) -> BigInt

`impl BitAnd for BigInt`

fn bitand(self: Self, other: BigInt) -> BigInt

`impl BitAndAssign for BigInt`

fn bitand_assign(self: &mut Self, other: &BigInt)

`impl BitAndAssign for BigInt`

fn bitand_assign(self: &mut Self, other: BigInt)

`impl BitOr for BigInt`

fn bitor(self: Self, other: BigInt) -> BigInt

`impl BitOr for BigInt`

fn bitor(self: Self, other: &BigInt) -> BigInt

`impl BitOrAssign for BigInt`

fn bitor_assign(self: &mut Self, other: &BigInt)

`impl BitOrAssign for BigInt`

fn bitor_assign(self: &mut Self, other: BigInt)

`impl BitXor for BigInt`

fn bitxor(self: Self, other: BigInt) -> BigInt

`impl BitXor for BigInt`

fn bitxor(self: Self, other: &BigInt) -> BigInt

`impl BitXorAssign for BigInt`

fn bitxor_assign(self: &mut Self, other: &BigInt)

`impl BitXorAssign for BigInt`

fn bitxor_assign(self: &mut Self, other: BigInt)

`impl CheckedAdd for BigInt`

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

`impl CheckedDiv for BigInt`

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

`impl CheckedEuclid for BigInt`

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

`impl CheckedMul for BigInt`

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

`impl CheckedSub for BigInt`

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

`impl Clone for BigInt`

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

`impl ConstZero for BigInt`

`impl Debug for BigInt`

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

`impl Default for BigInt`

fn default() -> BigInt

`impl Display for BigInt`

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

`impl Div for BigInt`

fn div(self: Self, other: i128) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: u64) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: u8) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: usize) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: i16) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: i64) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: u32) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &u8) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &usize) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &i16) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &u128) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: i32) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &BigInt) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &u64) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &i128) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &u32) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &i64) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: BigInt) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: u16) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: i8) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: isize) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &i32) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &u16) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &i8) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: &isize) -> BigInt

`impl Div for BigInt`

fn div(self: Self, other: u128) -> BigInt

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: u128)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: usize)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: i128)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: &BigInt)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: u64)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: i8)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: i64)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: u32)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: BigInt)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: i16)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: i32)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: u8)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: isize)

`impl DivAssign for BigInt`

fn div_assign(self: &mut Self, other: u16)

`impl Eq for BigInt`

`impl Euclid for BigInt`

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

`impl Freeze for BigInt`

`impl From for BigInt`

fn from(n: i32) -> Self

`impl From for BigInt`

fn from(n: u16) -> Self

`impl From for BigInt`

fn from(x: bool) -> Self

`impl From for BigInt`

fn from(n: i64) -> Self

`impl From for BigInt`

fn from(n: isize) -> Self

`impl From for BigInt`

fn from(n: u32) -> Self

`impl From for BigInt`

fn from(n: i128) -> Self

`impl From for BigInt`

fn from(n: u64) -> Self

`impl From for BigInt`

fn from(n: usize) -> Self

`impl From for BigInt`

fn from(n: i8) -> Self

`impl From for BigInt`

fn from(n: u128) -> Self

`impl From for BigInt`

fn from(n: BigUint) -> Self

`impl From for BigInt`

fn from(n: i16) -> Self

`impl From for BigInt`

fn from(n: u8) -> Self

`impl FromBytes for BigInt`

fn from_be_bytes(bytes: &<Self as >::Bytes) -> Self
fn from_le_bytes(bytes: &<Self as >::Bytes) -> Self

`impl FromPrimitive for BigInt`

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

`impl FromStr for BigInt`

fn from_str(s: &str) -> Result<BigInt, ParseBigIntError>

`impl Hash for BigInt`

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

`impl Integer for BigInt`

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

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

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

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

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

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

Calculates the Greatest Common Divisor (GCD) of the number and other.

The result is always positive.

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

Calculates the Lowest Common Multiple (LCM) of the number and other.

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

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

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

Greatest common divisor, least common multiple, and Bézout coefficients.

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

Deprecated, use is_multiple_of instead.

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

Returns true if the number is a multiple of other.

fn is_even(self: &Self) -> bool

Returns true if the number is divisible by 2.

fn is_odd(self: &Self) -> bool

Returns true if the number is not divisible by 2.

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

Rounds up to nearest multiple of argument.

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

Rounds down to nearest multiple of argument.

fn dec(self: &mut Self)

fn inc(self: &mut Self)

`impl LowerHex for BigInt`

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

`impl Mul for BigInt`

fn mul(self: Self, other: BigInt) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: u32) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: u16) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: u64) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: i8) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: isize) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: u128) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &u128) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &u16) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &i8) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: i32) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &isize) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: i64) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: i128) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &i128) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &u64) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: u8) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: usize) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: i16) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &i64) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &BigInt) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &u8) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &usize) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &i16) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &u32) -> BigInt

`impl Mul for BigInt`

fn mul(self: Self, other: &i32) -> BigInt

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: u8)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: isize)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: u32)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: u64)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: u128)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: u16)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: i32)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: i64)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: i128)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: usize)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: BigInt)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: i8)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: &BigInt)

`impl MulAssign for BigInt`

fn mul_assign(self: &mut Self, other: i16)

`impl Neg for BigInt`

fn neg(self: Self) -> BigInt

`impl Not for BigInt`

fn not(self: Self) -> BigInt

`impl Num for BigInt`

fn from_str_radix(s: &str, radix: u32) -> Result<BigInt, ParseBigIntError>: Creates and initializes a BigInt.

`impl Octal for BigInt`

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

`impl One for BigInt`

fn one() -> BigInt
fn set_one(self: &mut Self)
fn is_one(self: &Self) -> bool

`impl Ord for BigInt`

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

`impl PartialEq for BigInt`

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

`impl PartialOrd for BigInt`

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

`impl Pow for BigInt`

fn pow(self: Self, rhs: u8) -> BigInt

`impl Pow for BigInt`

fn pow(self: Self, rhs: u32) -> BigInt

`impl Pow for BigInt`

fn pow(self: Self, rhs: BigUint) -> BigInt

`impl Pow for BigInt`

fn pow(self: Self, rhs: &u64) -> BigInt

`impl Pow for BigInt`

fn pow(self: Self, rhs: u64) -> BigInt

`impl Pow for BigInt`

fn pow(self: Self, rhs: &u8) -> BigInt

`impl Pow for BigInt`

fn pow(self: Self, rhs: &usize) -> BigInt

`impl Pow for BigInt`

fn pow(self: Self, rhs: usize) -> BigInt

`impl Pow for BigInt`

fn pow(self: Self, rhs: &u16) -> BigInt

`impl Pow for BigInt`

fn pow(self: Self, rhs: &u128) -> BigInt

`impl Pow for BigInt`

fn pow(self: Self, rhs: u16) -> BigInt

`impl Pow for BigInt`

fn pow(self: Self, rhs: u128) -> BigInt

`impl Pow for BigInt`

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

`impl Pow for BigInt`

fn pow(self: Self, rhs: &BigUint) -> BigInt

`impl RefUnwindSafe for BigInt`

`impl Rem for BigInt`

fn rem(self: Self, other: isize) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &i32) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &u16) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &i8) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &isize) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: u128) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: i128) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: u64) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: u8) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: usize) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: i16) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: i64) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: u32) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &u8) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &usize) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &i16) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &u128) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: i32) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &BigInt) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &u64) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &i128) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &u32) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: &i64) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: BigInt) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: u16) -> BigInt

`impl Rem for BigInt`

fn rem(self: Self, other: i8) -> BigInt

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: u8)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: isize)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: u16)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: u128)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: usize)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: i128)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: &BigInt)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: u64)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: i8)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: i64)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: u32)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: BigInt)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: i16)

`impl RemAssign for BigInt`

fn rem_assign(self: &mut Self, other: i32)

`impl Roots for BigInt`

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

`impl Send for BigInt`

`impl Serialize for BigInt`

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

`impl Shl for BigInt`

fn shl(self: Self, rhs: u128) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: i16) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: i128) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &u32) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &usize) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &i32) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &isize) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: u32) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: usize) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: i32) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: isize) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &u64) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &i8) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &i64) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: u64) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: i8) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: i64) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &u16) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: u8) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &u128) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &u8) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &i16) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: &i128) -> BigInt

`impl Shl for BigInt`

fn shl(self: Self, rhs: u16) -> BigInt

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl ShlAssign for BigInt`

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

`impl Shr for BigInt`

fn shr(self: Self, rhs: usize) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: i32) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: isize) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &u8) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &u64) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &i8) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &i64) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: u64) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: i8) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: i64) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &u16) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &u128) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &i16) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &i128) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: u16) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: u128) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: u8) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: i16) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: i128) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &u32) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &usize) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &i32) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: &isize) -> BigInt

`impl Shr for BigInt`

fn shr(self: Self, rhs: u32) -> BigInt

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl ShrAssign for BigInt`

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

`impl Signed for BigInt`

fn abs(self: &Self) -> BigInt
fn abs_sub(self: &Self, other: &BigInt) -> BigInt
fn signum(self: &Self) -> BigInt
fn is_positive(self: &Self) -> bool
fn is_negative(self: &Self) -> bool

`impl Sub for BigInt`

fn sub(self: Self, other: isize) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: u128) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &i32) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &u16) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &i8) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &isize) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: i128) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: BigInt) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: u8) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: usize) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: i16) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: i64) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: u32) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &BigInt) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &u8) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &usize) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &i16) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &u128) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: i32) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &u64) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &i128) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &u32) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: &i64) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: u16) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: u64) -> BigInt

`impl Sub for BigInt`

fn sub(self: Self, other: i8) -> BigInt

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: u8)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: isize)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: u64)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: u128)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: u16)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: usize)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: i128)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: &BigInt)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: i8)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: i64)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: u32)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: BigInt)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: i16)

`impl SubAssign for BigInt`

fn sub_assign(self: &mut Self, other: i32)

`impl Sync for BigInt`

`impl ToBigInt for BigInt`

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

`impl ToBigUint for BigInt`

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

`impl ToBytes for BigInt`

fn to_be_bytes(self: &Self) -> <Self as >::Bytes
fn to_le_bytes(self: &Self) -> <Self as >::Bytes

`impl ToPrimitive for BigInt`

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

`impl Unpin for BigInt`

`impl UnsafeUnpin for BigInt`

`impl UnwindSafe for BigInt`

`impl UpperHex for BigInt`

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

`impl Zero for BigInt`

fn zero() -> BigInt
fn set_zero(self: &mut Self)
fn is_zero(self: &Self) -> bool

`impl<'de> Deserialize for BigInt`

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

`impl Average for BigInt`

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

`impl<T> Any for BigInt`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for BigInt`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for BigInt`

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

`impl<T> CloneToUninit for BigInt`

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

`impl<T> DeserializeOwned for BigInt`

`impl<T> From for BigInt`

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

`impl<T> NumAssign for BigInt`

`impl<T> NumAssignRef for BigInt`

`impl<T> NumRef for BigInt`

`impl<T> Product for BigInt`

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

`impl<T> Sum for BigInt`

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

`impl<T> ToOwned for BigInt`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T> ToString for BigInt`

fn to_string(self: &Self) -> String

`impl<T, Base> RefNum for BigInt`

`impl<T, Rhs> NumAssignOps for BigInt`

`impl<T, Rhs, Output> NumOps for BigInt`

`impl<T, U> Into for BigInt`

fn into(self: 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 BigInt`

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

`impl<T, U> TryInto for BigInt`

fn try_into(self: Self) -> Result<U, >::Error>

Implementations

impl BigInt

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

Examples

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl Add for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl AddAssign for BigInt

impl Binary for BigInt

impl BitAnd for BigInt

impl BitAnd for BigInt

impl BitAndAssign for BigInt

impl BitAndAssign for BigInt

impl BitOr for BigInt

impl BitOr for BigInt

impl BitOrAssign for BigInt

impl BitOrAssign for BigInt

impl BitXor for BigInt

impl BitXor for BigInt

impl BitXorAssign for BigInt

impl BitXorAssign for BigInt

impl CheckedAdd for BigInt

impl CheckedDiv for BigInt

impl CheckedEuclid for BigInt

impl CheckedMul for BigInt

impl CheckedSub for BigInt

impl Clone for BigInt

impl ConstZero for BigInt

`impl BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl Add for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl AddAssign for BigInt`

`impl Binary for BigInt`

`impl BitAnd for BigInt`

`impl BitAnd for BigInt`

`impl BitAndAssign for BigInt`

`impl BitAndAssign for BigInt`

`impl BitOr for BigInt`

`impl BitOr for BigInt`

`impl BitOrAssign for BigInt`

`impl BitOrAssign for BigInt`

`impl BitXor for BigInt`

`impl BitXor for BigInt`

`impl BitXorAssign for BigInt`

`impl BitXorAssign for BigInt`

`impl CheckedAdd for BigInt`

`impl CheckedDiv for BigInt`

`impl CheckedEuclid for BigInt`

`impl CheckedMul for BigInt`

`impl CheckedSub for BigInt`

`impl Clone for BigInt`

`impl ConstZero for BigInt`

`impl Debug for BigInt`

`impl Default for BigInt`

`impl Display for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`

`impl Div for BigInt`