Struct BigInt

pub struct BigInt { /* private fields */ }

A big signed integer type.

Implementations

impl BigInt

const ZERO: Self = _;

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

const ONE: Self = _;

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

const NEG_ONE: Self = _;

A constant BigInt with value -1, useful for static initialization.

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

Creates and initializes a BigInt.

The base 232 digits are ordered least significant digit first.

const fn new_const(n: i32) -> Self

Creates a constant BigInt from a primitive i32 value.

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

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

Creates and initializes a BigInt.

The base 232 digits are ordered least significant digit first.

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

Creates and initializes a BigInt.

The base 232 digits are ordered least significant digit first.

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

Reinitializes a BigInt.

The base 232 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 28.

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

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) -> (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) -> (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) -> (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) -> (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) -> 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) -> 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) -> 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) -> 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, 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, 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, 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) -> 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) -> &BigUint

Returns the magnitude of the BigInt as a BigUint.

Examples

use num_bigint::{BigInt, BigUint};

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

fn into_parts(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) -> u64

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

fn into_biguint(self) -> Option<BigUint>

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

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

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

fn checked_add(&self, v: &BigInt) -> Option<BigInt>
fn checked_sub(&self, v: &BigInt) -> Option<BigInt>
fn checked_mul(&self, v: &BigInt) -> Option<BigInt>
fn checked_div(&self, v: &BigInt) -> Option<BigInt>
fn pow(&self, exponent: u32) -> Self

Returns self ^ exponent.

fn modpow(&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, 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

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

fn cbrt(&self) -> Self

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

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

Returns the truncated principal nth root of self -- See [num_integer::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 bit(&self, bit: u64) -> bool

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

fn set_bit(&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

Trait Implementations

impl Add for BigInt

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

impl Add<&BigInt> for BigInt

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

impl Add<&i128> for BigInt

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

impl Add<&i16> for BigInt

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

impl Add<&i32> for BigInt

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

impl Add<&i64> for BigInt

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

impl Add<&i8> for BigInt

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

impl Add<&isize> for BigInt

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

impl Add<&u128> for BigInt

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

impl Add<&u16> for BigInt

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

impl Add<&u32> for BigInt

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

impl Add<&u64> for BigInt

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

impl Add<&u8> for BigInt

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

impl Add<&usize> for BigInt

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

impl Add<i128> for BigInt

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

impl Add<i16> for BigInt

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

impl Add<i32> for BigInt

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

impl Add<i64> for BigInt

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

impl Add<i8> for BigInt

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

impl Add<isize> for BigInt

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

impl Add<u128> for BigInt

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

impl Add<u16> for BigInt

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

impl Add<u32> for BigInt

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

impl Add<u64> for BigInt

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

impl Add<u8> for BigInt

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

impl Add<usize> for BigInt

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

impl AddAssign for BigInt

fn add_assign(&mut self, other: BigInt)

impl AddAssign<&BigInt> for BigInt

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

impl AddAssign<i128> for BigInt

fn add_assign(&mut self, other: i128)

impl AddAssign<i16> for BigInt

fn add_assign(&mut self, other: i16)

impl AddAssign<i32> for BigInt

fn add_assign(&mut self, other: i32)

impl AddAssign<i64> for BigInt

fn add_assign(&mut self, other: i64)

impl AddAssign<i8> for BigInt

fn add_assign(&mut self, other: i8)

impl AddAssign<isize> for BigInt

fn add_assign(&mut self, other: isize)

impl AddAssign<u128> for BigInt

fn add_assign(&mut self, other: u128)

impl AddAssign<u16> for BigInt

fn add_assign(&mut self, other: u16)

impl AddAssign<u32> for BigInt

fn add_assign(&mut self, other: u32)

impl AddAssign<u64> for BigInt

fn add_assign(&mut self, other: u64)

impl AddAssign<u8> for BigInt

fn add_assign(&mut self, other: u8)

impl AddAssign<usize> for BigInt

fn add_assign(&mut self, other: usize)

impl Binary for BigInt

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

impl BitAnd for BigInt

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

impl BitAnd<&BigInt> for BigInt

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

impl BitAndAssign for BigInt

fn bitand_assign(&mut self, other: BigInt)

impl BitAndAssign<&BigInt> for BigInt

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

impl BitOr for BigInt

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

impl BitOr<&BigInt> for BigInt

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

impl BitOrAssign for BigInt

fn bitor_assign(&mut self, other: BigInt)

impl BitOrAssign<&BigInt> for BigInt

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

impl BitXor for BigInt

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

impl BitXor<&BigInt> for BigInt

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

impl BitXorAssign for BigInt

fn bitxor_assign(&mut self, other: BigInt)

impl BitXorAssign<&BigInt> for BigInt

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

impl CheckedAdd for BigInt

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

impl CheckedDiv for BigInt

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

impl CheckedEuclid for BigInt

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

impl CheckedMul for BigInt

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

impl CheckedSub for BigInt

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

impl Clone for BigInt

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

impl ConstOne for BigInt

const ONE: Self = Self::ONE;

impl ConstZero for BigInt

const ZERO: Self = Self::ZERO;

impl Debug for BigInt

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

impl Default for BigInt

fn default() -> BigInt

impl Display for BigInt

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

impl Div for BigInt

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

impl Div<&BigInt> for BigInt

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

impl Div<&i128> for BigInt

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

impl Div<&i16> for BigInt

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

impl Div<&i32> for BigInt

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

impl Div<&i64> for BigInt

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

impl Div<&i8> for BigInt

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

impl Div<&isize> for BigInt

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

impl Div<&u128> for BigInt

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

impl Div<&u16> for BigInt

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

impl Div<&u32> for BigInt

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

impl Div<&u64> for BigInt

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

impl Div<&u8> for BigInt

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

impl Div<&usize> for BigInt

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

impl Div<i128> for BigInt

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

impl Div<i16> for BigInt

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

impl Div<i32> for BigInt

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

impl Div<i64> for BigInt

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

impl Div<i8> for BigInt

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

impl Div<isize> for BigInt

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

impl Div<u128> for BigInt

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

impl Div<u16> for BigInt

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

impl Div<u32> for BigInt

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

impl Div<u64> for BigInt

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

impl Div<u8> for BigInt

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

impl Div<usize> for BigInt

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

impl DivAssign for BigInt

fn div_assign(&mut self, other: BigInt)

impl DivAssign<&BigInt> for BigInt

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

impl DivAssign<i128> for BigInt

fn div_assign(&mut self, other: i128)

impl DivAssign<i16> for BigInt

fn div_assign(&mut self, other: i16)

impl DivAssign<i32> for BigInt

fn div_assign(&mut self, other: i32)

impl DivAssign<i64> for BigInt

fn div_assign(&mut self, other: i64)

impl DivAssign<i8> for BigInt

fn div_assign(&mut self, other: i8)

impl DivAssign<isize> for BigInt

fn div_assign(&mut self, other: isize)

impl DivAssign<u128> for BigInt

fn div_assign(&mut self, other: u128)

impl DivAssign<u16> for BigInt

fn div_assign(&mut self, other: u16)

impl DivAssign<u32> for BigInt

fn div_assign(&mut self, other: u32)

impl DivAssign<u64> for BigInt

fn div_assign(&mut self, other: u64)

impl DivAssign<u8> for BigInt

fn div_assign(&mut self, other: u8)

impl DivAssign<usize> for BigInt

fn div_assign(&mut self, other: usize)

impl Eq for BigInt

impl Euclid for BigInt

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

impl From<BigUint> for BigInt

fn from(n: BigUint) -> Self

impl From<bool> for BigInt

fn from(x: bool) -> Self

impl From<i128> for BigInt

fn from(n: i128) -> Self

impl From<i16> for BigInt

fn from(n: i16) -> Self

impl From<i32> for BigInt

fn from(n: i32) -> Self

impl From<i64> for BigInt

fn from(n: i64) -> Self

impl From<i8> for BigInt

fn from(n: i8) -> Self

impl From<isize> for BigInt

fn from(n: isize) -> Self

impl From<u128> for BigInt

fn from(n: u128) -> Self

impl From<u16> for BigInt

fn from(n: u16) -> Self

impl From<u32> for BigInt

fn from(n: u32) -> Self

impl From<u64> for BigInt

fn from(n: u64) -> Self

impl From<u8> for BigInt

fn from(n: u8) -> Self

impl From<usize> for BigInt

fn from(n: usize) -> Self

impl FromBytes for BigInt

type Bytes = [u8];
fn from_be_bytes(bytes: &Self::Bytes) -> Self
fn from_le_bytes(bytes: &Self::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

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

impl Hash for BigInt

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

impl Integer for BigInt

fn div_rem(&self, other: &BigInt) -> (BigInt, BigInt)
fn div_floor(&self, other: &BigInt) -> BigInt
fn mod_floor(&self, other: &BigInt) -> BigInt
fn div_mod_floor(&self, other: &BigInt) -> (BigInt, BigInt)
fn div_ceil(&self, other: &Self) -> Self
fn gcd(&self, other: &BigInt) -> BigInt

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

The result is always non-negative.

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

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

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

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

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

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

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

Deprecated, use is_multiple_of instead.

fn is_multiple_of(&self, other: &BigInt) -> 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 LowerHex for BigInt

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

impl Mul for BigInt

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

impl Mul<&BigInt> for BigInt

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

impl Mul<&i128> for BigInt

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

impl Mul<&i16> for BigInt

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

impl Mul<&i32> for BigInt

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

impl Mul<&i64> for BigInt

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

impl Mul<&i8> for BigInt

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

impl Mul<&isize> for BigInt

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

impl Mul<&u128> for BigInt

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

impl Mul<&u16> for BigInt

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

impl Mul<&u32> for BigInt

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

impl Mul<&u64> for BigInt

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

impl Mul<&u8> for BigInt

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

impl Mul<&usize> for BigInt

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

impl Mul<i128> for BigInt

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

impl Mul<i16> for BigInt

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

impl Mul<i32> for BigInt

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

impl Mul<i64> for BigInt

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

impl Mul<i8> for BigInt

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

impl Mul<isize> for BigInt

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

impl Mul<u128> for BigInt

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

impl Mul<u16> for BigInt

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

impl Mul<u32> for BigInt

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

impl Mul<u64> for BigInt

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

impl Mul<u8> for BigInt

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

impl Mul<usize> for BigInt

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

impl MulAssign for BigInt

fn mul_assign(&mut self, other: BigInt)

impl MulAssign<&BigInt> for BigInt

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

impl MulAssign<i128> for BigInt

fn mul_assign(&mut self, other: i128)

impl MulAssign<i16> for BigInt

fn mul_assign(&mut self, other: i16)

impl MulAssign<i32> for BigInt

fn mul_assign(&mut self, other: i32)

impl MulAssign<i64> for BigInt

fn mul_assign(&mut self, other: i64)

impl MulAssign<i8> for BigInt

fn mul_assign(&mut self, other: i8)

impl MulAssign<isize> for BigInt

fn mul_assign(&mut self, other: isize)

impl MulAssign<u128> for BigInt

fn mul_assign(&mut self, other: u128)

impl MulAssign<u16> for BigInt

fn mul_assign(&mut self, other: u16)

impl MulAssign<u32> for BigInt

fn mul_assign(&mut self, other: u32)

impl MulAssign<u64> for BigInt

fn mul_assign(&mut self, other: u64)

impl MulAssign<u8> for BigInt

fn mul_assign(&mut self, other: u8)

impl MulAssign<usize> for BigInt

fn mul_assign(&mut self, other: usize)

impl Neg for BigInt

type Output = BigInt;
fn neg(self) -> BigInt

impl Not for BigInt

type Output = BigInt;
fn not(self) -> BigInt

impl Num for BigInt

type FromStrRadixErr = ParseBigIntError;
fn from_str_radix(s: &str, radix: u32) -> Result<BigInt, ParseBigIntError>

Creates and initializes a BigInt.

impl Octal for BigInt

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

impl One for BigInt

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

impl Ord for BigInt

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

impl PartialEq for BigInt

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

impl PartialOrd for BigInt

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

impl Pow<&BigUint> for BigInt

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

impl Pow<&u128> for BigInt

type Output = BigInt;
fn pow(self, rhs: &u128) -> BigInt

impl Pow<&u16> for BigInt

type Output = BigInt;
fn pow(self, rhs: &u16) -> BigInt

impl Pow<&u32> for BigInt

type Output = BigInt;
fn pow(self, rhs: &u32) -> BigInt

impl Pow<&u64> for BigInt

type Output = BigInt;
fn pow(self, rhs: &u64) -> BigInt

impl Pow<&u8> for BigInt

type Output = BigInt;
fn pow(self, rhs: &u8) -> BigInt

impl Pow<&usize> for BigInt

type Output = BigInt;
fn pow(self, rhs: &usize) -> BigInt

impl Pow<BigUint> for BigInt

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

impl Pow<u128> for BigInt

type Output = BigInt;
fn pow(self, rhs: u128) -> BigInt

impl Pow<u16> for BigInt

type Output = BigInt;
fn pow(self, rhs: u16) -> BigInt

impl Pow<u32> for BigInt

type Output = BigInt;
fn pow(self, rhs: u32) -> BigInt

impl Pow<u64> for BigInt

type Output = BigInt;
fn pow(self, rhs: u64) -> BigInt

impl Pow<u8> for BigInt

type Output = BigInt;
fn pow(self, rhs: u8) -> BigInt

impl Pow<usize> for BigInt

type Output = BigInt;
fn pow(self, rhs: usize) -> BigInt

impl Rem for BigInt

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

impl Rem<&BigInt> for BigInt

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

impl Rem<&i128> for BigInt

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

impl Rem<&i16> for BigInt

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

impl Rem<&i32> for BigInt

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

impl Rem<&i64> for BigInt

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

impl Rem<&i8> for BigInt

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

impl Rem<&isize> for BigInt

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

impl Rem<&u128> for BigInt

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

impl Rem<&u16> for BigInt

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

impl Rem<&u32> for BigInt

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

impl Rem<&u64> for BigInt

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

impl Rem<&u8> for BigInt

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

impl Rem<&usize> for BigInt

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

impl Rem<i128> for BigInt

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

impl Rem<i16> for BigInt

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

impl Rem<i32> for BigInt

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

impl Rem<i64> for BigInt

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

impl Rem<i8> for BigInt

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

impl Rem<isize> for BigInt

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

impl Rem<u128> for BigInt

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

impl Rem<u16> for BigInt

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

impl Rem<u32> for BigInt

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

impl Rem<u64> for BigInt

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

impl Rem<u8> for BigInt

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

impl Rem<usize> for BigInt

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

impl RemAssign for BigInt

fn rem_assign(&mut self, other: BigInt)

impl RemAssign<&BigInt> for BigInt

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

impl RemAssign<i128> for BigInt

fn rem_assign(&mut self, other: i128)

impl RemAssign<i16> for BigInt

fn rem_assign(&mut self, other: i16)

impl RemAssign<i32> for BigInt

fn rem_assign(&mut self, other: i32)

impl RemAssign<i64> for BigInt

fn rem_assign(&mut self, other: i64)

impl RemAssign<i8> for BigInt

fn rem_assign(&mut self, other: i8)

impl RemAssign<isize> for BigInt

fn rem_assign(&mut self, other: isize)

impl RemAssign<u128> for BigInt

fn rem_assign(&mut self, other: u128)

impl RemAssign<u16> for BigInt

fn rem_assign(&mut self, other: u16)

impl RemAssign<u32> for BigInt

fn rem_assign(&mut self, other: u32)

impl RemAssign<u64> for BigInt

fn rem_assign(&mut self, other: u64)

impl RemAssign<u8> for BigInt

fn rem_assign(&mut self, other: u8)

impl RemAssign<usize> for BigInt

fn rem_assign(&mut self, other: usize)

impl Roots for BigInt

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

impl Serialize for BigInt

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

impl Shl<&i128> for BigInt

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

impl Shl<&i16> for BigInt

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

impl Shl<&i32> for BigInt

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

impl Shl<&i64> for BigInt

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

impl Shl<&i8> for BigInt

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

impl Shl<&isize> for BigInt

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

impl Shl<&u128> for BigInt

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

impl Shl<&u16> for BigInt

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

impl Shl<&u32> for BigInt

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

impl Shl<&u64> for BigInt

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

impl Shl<&u8> for BigInt

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

impl Shl<&usize> for BigInt

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

impl Shl<i128> for BigInt

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

impl Shl<i16> for BigInt

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

impl Shl<i32> for BigInt

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

impl Shl<i64> for BigInt

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

impl Shl<i8> for BigInt

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

impl Shl<isize> for BigInt

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

impl Shl<u128> for BigInt

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

impl Shl<u16> for BigInt

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

impl Shl<u32> for BigInt

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

impl Shl<u64> for BigInt

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

impl Shl<u8> for BigInt

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

impl Shl<usize> for BigInt

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

impl ShlAssign<&i128> for BigInt

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

impl ShlAssign<&i16> for BigInt

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

impl ShlAssign<&i32> for BigInt

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

impl ShlAssign<&i64> for BigInt

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

impl ShlAssign<&i8> for BigInt

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

impl ShlAssign<&isize> for BigInt

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

impl ShlAssign<&u128> for BigInt

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

impl ShlAssign<&u16> for BigInt

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

impl ShlAssign<&u32> for BigInt

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

impl ShlAssign<&u64> for BigInt

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

impl ShlAssign<&u8> for BigInt

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

impl ShlAssign<&usize> for BigInt

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

impl ShlAssign<i128> for BigInt

fn shl_assign(&mut self, rhs: i128)

impl ShlAssign<i16> for BigInt

fn shl_assign(&mut self, rhs: i16)

impl ShlAssign<i32> for BigInt

fn shl_assign(&mut self, rhs: i32)

impl ShlAssign<i64> for BigInt

fn shl_assign(&mut self, rhs: i64)

impl ShlAssign<i8> for BigInt

fn shl_assign(&mut self, rhs: i8)

impl ShlAssign<isize> for BigInt

fn shl_assign(&mut self, rhs: isize)

impl ShlAssign<u128> for BigInt

fn shl_assign(&mut self, rhs: u128)

impl ShlAssign<u16> for BigInt

fn shl_assign(&mut self, rhs: u16)

impl ShlAssign<u32> for BigInt

fn shl_assign(&mut self, rhs: u32)

impl ShlAssign<u64> for BigInt

fn shl_assign(&mut self, rhs: u64)

impl ShlAssign<u8> for BigInt

fn shl_assign(&mut self, rhs: u8)

impl ShlAssign<usize> for BigInt

fn shl_assign(&mut self, rhs: usize)

impl Shr<&i128> for BigInt

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

impl Shr<&i16> for BigInt

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

impl Shr<&i32> for BigInt

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

impl Shr<&i64> for BigInt

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

impl Shr<&i8> for BigInt

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

impl Shr<&isize> for BigInt

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

impl Shr<&u128> for BigInt

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

impl Shr<&u16> for BigInt

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

impl Shr<&u32> for BigInt

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

impl Shr<&u64> for BigInt

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

impl Shr<&u8> for BigInt

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

impl Shr<&usize> for BigInt

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

impl Shr<i128> for BigInt

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

impl Shr<i16> for BigInt

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

impl Shr<i32> for BigInt

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

impl Shr<i64> for BigInt

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

impl Shr<i8> for BigInt

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

impl Shr<isize> for BigInt

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

impl Shr<u128> for BigInt

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

impl Shr<u16> for BigInt

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

impl Shr<u32> for BigInt

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

impl Shr<u64> for BigInt

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

impl Shr<u8> for BigInt

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

impl Shr<usize> for BigInt

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

impl ShrAssign<&i128> for BigInt

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

impl ShrAssign<&i16> for BigInt

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

impl ShrAssign<&i32> for BigInt

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

impl ShrAssign<&i64> for BigInt

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

impl ShrAssign<&i8> for BigInt

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

impl ShrAssign<&isize> for BigInt

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

impl ShrAssign<&u128> for BigInt

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

impl ShrAssign<&u16> for BigInt

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

impl ShrAssign<&u32> for BigInt

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

impl ShrAssign<&u64> for BigInt

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

impl ShrAssign<&u8> for BigInt

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

impl ShrAssign<&usize> for BigInt

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

impl ShrAssign<i128> for BigInt

fn shr_assign(&mut self, rhs: i128)

impl ShrAssign<i16> for BigInt

fn shr_assign(&mut self, rhs: i16)

impl ShrAssign<i32> for BigInt

fn shr_assign(&mut self, rhs: i32)

impl ShrAssign<i64> for BigInt

fn shr_assign(&mut self, rhs: i64)

impl ShrAssign<i8> for BigInt

fn shr_assign(&mut self, rhs: i8)

impl ShrAssign<isize> for BigInt

fn shr_assign(&mut self, rhs: isize)

impl ShrAssign<u128> for BigInt

fn shr_assign(&mut self, rhs: u128)

impl ShrAssign<u16> for BigInt

fn shr_assign(&mut self, rhs: u16)

impl ShrAssign<u32> for BigInt

fn shr_assign(&mut self, rhs: u32)

impl ShrAssign<u64> for BigInt

fn shr_assign(&mut self, rhs: u64)

impl ShrAssign<u8> for BigInt

fn shr_assign(&mut self, rhs: u8)

impl ShrAssign<usize> for BigInt

fn shr_assign(&mut self, rhs: usize)

impl Signed for BigInt

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

impl Sub for BigInt

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

impl Sub<&BigInt> for BigInt

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

impl Sub<&i128> for BigInt

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

impl Sub<&i16> for BigInt

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

impl Sub<&i32> for BigInt

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

impl Sub<&i64> for BigInt

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

impl Sub<&i8> for BigInt

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

impl Sub<&isize> for BigInt

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

impl Sub<&u128> for BigInt

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

impl Sub<&u16> for BigInt

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

impl Sub<&u32> for BigInt

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

impl Sub<&u64> for BigInt

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

impl Sub<&u8> for BigInt

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

impl Sub<&usize> for BigInt

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

impl Sub<i128> for BigInt

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

impl Sub<i16> for BigInt

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

impl Sub<i32> for BigInt

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

impl Sub<i64> for BigInt

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

impl Sub<i8> for BigInt

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

impl Sub<isize> for BigInt

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

impl Sub<u128> for BigInt

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

impl Sub<u16> for BigInt

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

impl Sub<u32> for BigInt

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

impl Sub<u64> for BigInt

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

impl Sub<u8> for BigInt

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

impl Sub<usize> for BigInt

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

impl SubAssign for BigInt

fn sub_assign(&mut self, other: BigInt)

impl SubAssign<&BigInt> for BigInt

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

impl SubAssign<i128> for BigInt

fn sub_assign(&mut self, other: i128)

impl SubAssign<i16> for BigInt

fn sub_assign(&mut self, other: i16)

impl SubAssign<i32> for BigInt

fn sub_assign(&mut self, other: i32)

impl SubAssign<i64> for BigInt

fn sub_assign(&mut self, other: i64)

impl SubAssign<i8> for BigInt

fn sub_assign(&mut self, other: i8)

impl SubAssign<isize> for BigInt

fn sub_assign(&mut self, other: isize)

impl SubAssign<u128> for BigInt

fn sub_assign(&mut self, other: u128)

impl SubAssign<u16> for BigInt

fn sub_assign(&mut self, other: u16)

impl SubAssign<u32> for BigInt

fn sub_assign(&mut self, other: u32)

impl SubAssign<u64> for BigInt

fn sub_assign(&mut self, other: u64)

impl SubAssign<u8> for BigInt

fn sub_assign(&mut self, other: u8)

impl SubAssign<usize> for BigInt

fn sub_assign(&mut self, other: usize)

impl ToBigInt for BigInt

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

impl ToBigUint for BigInt

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

impl ToBytes for BigInt

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

impl ToPrimitive for BigInt

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 UpperHex for BigInt

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

impl Zero for BigInt

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

impl<'de> Deserialize<'de> for BigInt

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

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

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

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

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

Auto Trait Implementations

impl Freeze for BigInt

impl RefUnwindSafe for BigInt

impl Send for BigInt

impl Sync for BigInt

impl Unpin for BigInt

impl UnsafeUnpin for BigInt

impl UnwindSafe for BigInt

Blanket Implementations

impl<I> Average for BigInt 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 BigInt where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for BigInt where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for BigInt where T: ?Sized,

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

impl<T> CloneToUninit for BigInt where T: Clone,

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

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

impl<T> From<T> for BigInt

fn from(t: T) -> T

Returns the argument unchanged.

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

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

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

impl<T> ToOwned for BigInt where T: Clone,

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

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

fn to_string(&self) -> String

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

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

impl<T, Rhs, Output> NumOps<Rhs, Output> for BigInt 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<U> for BigInt 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<U> for BigInt where U: Into<T>,

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

impl<T, U> TryInto<U> for BigInt where U: TryFrom<T>,

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