`pub struct BigInt { /* private fields */ }`

## Expand description

A big signed integer type.

## Implementations§

source§### impl BigInt

### impl BigInt

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

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

Creates and initializes a `BigInt`

.

The base 2^{32} digits are ordered least significant digit first.

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

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

Creates and initializes a `BigInt`

.

The base 2^{32} digits are ordered least significant digit first.

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

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

Creates and initializes a `BigInt`

.

The base 2^{32} digits are ordered least significant digit first.

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

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

Reinitializes a `BigInt`

.

The base 2^{32} digits are ordered least significant digit first.

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

#### pub 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());
```

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

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

Creates and initializes a `BigInt`

.

The bytes are in little-endian byte order.

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

#### pub 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^{8}.

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

#### pub 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^{8}.

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

#### pub 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));
```

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

#### pub 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));
```

source#### pub fn to_bytes_be(&self) -> (Sign, Vec<u8>)

#### pub fn to_bytes_be(&self) -> (Sign, Vec<u8>)

source#### pub fn to_bytes_le(&self) -> (Sign, Vec<u8>)

#### pub fn to_bytes_le(&self) -> (Sign, Vec<u8>)

source#### pub fn to_u32_digits(&self) -> (Sign, Vec<u32>)

#### pub 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]));
```

source#### pub fn to_u64_digits(&self) -> (Sign, Vec<u64>)

#### pub 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]));
```

source#### pub fn iter_u32_digits(&self) -> U32Digits<'_> ⓘ

#### pub 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]);
```

source#### pub fn iter_u64_digits(&self) -> U64Digits<'_> ⓘ

#### pub 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]);
```

source#### pub fn to_signed_bytes_be(&self) -> Vec<u8>

#### pub fn to_signed_bytes_be(&self) -> Vec<u8>

source#### pub fn to_signed_bytes_le(&self) -> Vec<u8>

#### pub fn to_signed_bytes_le(&self) -> Vec<u8>

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

#### pub 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");
```

source#### pub fn to_radix_be(&self, radix: u32) -> (Sign, Vec<u8>)

#### pub 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
```

source#### pub fn to_radix_le(&self, radix: u32) -> (Sign, Vec<u8>)

#### pub 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)
```

source#### pub fn magnitude(&self) -> &BigUint

#### pub fn magnitude(&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());
```

source#### pub fn into_parts(self) -> (Sign, BigUint)

#### pub 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};
use num_traits::Zero;
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()));
```

source#### pub fn bits(&self) -> u64

#### pub fn bits(&self) -> u64

Determines the fewest bits necessary to express the `BigInt`

,
not including the sign.

source#### pub fn to_biguint(&self) -> Option<BigUint>

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

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

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

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

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

source#### pub fn modpow(&self, exponent: &BigInt, modulus: &BigInt) -> BigInt

#### pub fn modpow(&self, exponent: &BigInt, modulus: &BigInt) -> BigInt

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.

source#### pub fn sqrt(&self) -> BigInt

#### pub fn sqrt(&self) -> BigInt

Returns the truncated principal square root of `self`

–
see `num_integer::Roots::sqrt()`

.

source#### pub fn cbrt(&self) -> BigInt

#### pub fn cbrt(&self) -> BigInt

Returns the truncated principal cube root of `self`

–
see `num_integer::Roots::cbrt()`

.

source#### pub fn nth_root(&self, n: u32) -> BigInt

#### pub fn nth_root(&self, n: u32) -> BigInt

Returns the truncated principal `n`

th root of `self`

–
See `num_integer::Roots::nth_root()`

.

source#### pub fn trailing_zeros(&self) -> Option<u64>

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

Returns the number of least-significant bits that are zero,
or `None`

if the entire number is zero.

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

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

Returns whether the bit in position `bit`

is set,
using the two’s complement for negative numbers

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

#### pub 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§

source§### impl AddAssign<&BigInt> for BigInt

### impl AddAssign<&BigInt> for BigInt

source§#### fn add_assign(&mut self, other: &BigInt)

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

`+=`

operation. Read moresource§### impl AddAssign<i128> for BigInt

### impl AddAssign<i128> for BigInt

source§#### fn add_assign(&mut self, other: i128)

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

`+=`

operation. Read moresource§### impl AddAssign<i16> for BigInt

### impl AddAssign<i16> for BigInt

source§#### fn add_assign(&mut self, other: i16)

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

`+=`

operation. Read moresource§### impl AddAssign<i32> for BigInt

### impl AddAssign<i32> for BigInt

source§#### fn add_assign(&mut self, other: i32)

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

`+=`

operation. Read moresource§### impl AddAssign<i64> for BigInt

### impl AddAssign<i64> for BigInt

source§#### fn add_assign(&mut self, other: i64)

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

`+=`

operation. Read moresource§### impl AddAssign<i8> for BigInt

### impl AddAssign<i8> for BigInt

source§#### fn add_assign(&mut self, other: i8)

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

`+=`

operation. Read moresource§### impl AddAssign<isize> for BigInt

### impl AddAssign<isize> for BigInt

source§#### fn add_assign(&mut self, other: isize)

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

`+=`

operation. Read moresource§### impl AddAssign<u128> for BigInt

### impl AddAssign<u128> for BigInt

source§#### fn add_assign(&mut self, other: u128)

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

`+=`

operation. Read moresource§### impl AddAssign<u16> for BigInt

### impl AddAssign<u16> for BigInt

source§#### fn add_assign(&mut self, other: u16)

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

`+=`

operation. Read moresource§### impl AddAssign<u32> for BigInt

### impl AddAssign<u32> for BigInt

source§#### fn add_assign(&mut self, other: u32)

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

`+=`

operation. Read moresource§### impl AddAssign<u64> for BigInt

### impl AddAssign<u64> for BigInt

source§#### fn add_assign(&mut self, other: u64)

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

`+=`

operation. Read moresource§### impl AddAssign<u8> for BigInt

### impl AddAssign<u8> for BigInt

source§#### fn add_assign(&mut self, other: u8)

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

`+=`

operation. Read moresource§### impl AddAssign<usize> for BigInt

### impl AddAssign<usize> for BigInt

source§#### fn add_assign(&mut self, other: usize)

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

`+=`

operation. Read moresource§### impl AddAssign for BigInt

### impl AddAssign for BigInt

source§#### fn add_assign(&mut self, other: BigInt)

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

`+=`

operation. Read moresource§### impl BitAndAssign<&BigInt> for BigInt

### impl BitAndAssign<&BigInt> for BigInt

source§#### fn bitand_assign(&mut self, other: &BigInt)

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

`&=`

operation. Read moresource§### impl BitAndAssign for BigInt

### impl BitAndAssign for BigInt

source§#### fn bitand_assign(&mut self, other: BigInt)

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

`&=`

operation. Read moresource§### impl BitOrAssign<&BigInt> for BigInt

### impl BitOrAssign<&BigInt> for BigInt

source§#### fn bitor_assign(&mut self, other: &BigInt)

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

`|=`

operation. Read moresource§### impl BitOrAssign for BigInt

### impl BitOrAssign for BigInt

source§#### fn bitor_assign(&mut self, other: BigInt)

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

`|=`

operation. Read moresource§### impl BitXorAssign<&BigInt> for BigInt

### impl BitXorAssign<&BigInt> for BigInt

source§#### fn bitxor_assign(&mut self, other: &BigInt)

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

`^=`

operation. Read moresource§### impl BitXorAssign for BigInt

### impl BitXorAssign for BigInt

source§#### fn bitxor_assign(&mut self, other: BigInt)

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

`^=`

operation. Read moresource§### impl CheckedAdd for BigInt

### impl CheckedAdd for BigInt

source§### impl CheckedDiv for BigInt

### impl CheckedDiv for BigInt

source§### impl CheckedEuclid for BigInt

### impl CheckedEuclid for BigInt

source§#### fn checked_div_euclid(&self, v: &BigInt) -> Option<BigInt>

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

`None`

instead of panicking on division by zero
and instead of wrapping around on underflow and overflow.source§#### fn checked_rem_euclid(&self, v: &BigInt) -> Option<BigInt>

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

`None`

is returned.source§#### fn checked_div_rem_euclid(&self, v: &Self) -> Option<(Self, Self)>

#### fn checked_div_rem_euclid(&self, v: &Self) -> Option<(Self, Self)>

source§### impl CheckedMul for BigInt

### impl CheckedMul for BigInt

source§### impl CheckedSub for BigInt

### impl CheckedSub for BigInt

source§### impl<'de> Deserialize<'de> for BigInt

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

source§#### fn deserialize<D>(
deserializer: D
) -> Result<BigInt, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,

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

source§### impl Distribution<BigInt> for RandomBits

### impl Distribution<BigInt> for RandomBits

source§### impl DivAssign<&BigInt> for BigInt

### impl DivAssign<&BigInt> for BigInt

source§#### fn div_assign(&mut self, other: &BigInt)

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

`/=`

operation. Read moresource§### impl DivAssign<i128> for BigInt

### impl DivAssign<i128> for BigInt

source§#### fn div_assign(&mut self, other: i128)

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

`/=`

operation. Read moresource§### impl DivAssign<i16> for BigInt

### impl DivAssign<i16> for BigInt

source§#### fn div_assign(&mut self, other: i16)

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

`/=`

operation. Read moresource§### impl DivAssign<i32> for BigInt

### impl DivAssign<i32> for BigInt

source§#### fn div_assign(&mut self, other: i32)

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

`/=`

operation. Read moresource§### impl DivAssign<i64> for BigInt

### impl DivAssign<i64> for BigInt

source§#### fn div_assign(&mut self, other: i64)

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

`/=`

operation. Read moresource§### impl DivAssign<i8> for BigInt

### impl DivAssign<i8> for BigInt

source§#### fn div_assign(&mut self, other: i8)

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

`/=`

operation. Read moresource§### impl DivAssign<isize> for BigInt

### impl DivAssign<isize> for BigInt

source§#### fn div_assign(&mut self, other: isize)

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

`/=`

operation. Read moresource§### impl DivAssign<u128> for BigInt

### impl DivAssign<u128> for BigInt

source§#### fn div_assign(&mut self, other: u128)

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

`/=`

operation. Read moresource§### impl DivAssign<u16> for BigInt

### impl DivAssign<u16> for BigInt

source§#### fn div_assign(&mut self, other: u16)

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

`/=`

operation. Read moresource§### impl DivAssign<u32> for BigInt

### impl DivAssign<u32> for BigInt

source§#### fn div_assign(&mut self, other: u32)

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

`/=`

operation. Read moresource§### impl DivAssign<u64> for BigInt

### impl DivAssign<u64> for BigInt

source§#### fn div_assign(&mut self, other: u64)

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

`/=`

operation. Read moresource§### impl DivAssign<u8> for BigInt

### impl DivAssign<u8> for BigInt

source§#### fn div_assign(&mut self, other: u8)

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

`/=`

operation. Read moresource§### impl DivAssign<usize> for BigInt

### impl DivAssign<usize> for BigInt

source§#### fn div_assign(&mut self, other: usize)

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

`/=`

operation. Read moresource§### impl DivAssign for BigInt

### impl DivAssign for BigInt

source§#### fn div_assign(&mut self, other: BigInt)

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

`/=`

operation. Read moresource§### impl Euclid for BigInt

### impl Euclid for BigInt

source§#### fn div_euclid(&self, v: &BigInt) -> BigInt

#### fn div_euclid(&self, v: &BigInt) -> BigInt

`rem_euclid`

. Read moresource§#### fn rem_euclid(&self, v: &BigInt) -> BigInt

#### fn rem_euclid(&self, v: &BigInt) -> BigInt

`self (mod v)`

. Read moresource§#### fn div_rem_euclid(&self, v: &Self) -> (Self, Self)

#### fn div_rem_euclid(&self, v: &Self) -> (Self, Self)

source§### impl FromBytes for BigInt

### impl FromBytes for BigInt

#### type Bytes = [u8]

source§#### fn from_be_bytes(bytes: &<BigInt as FromBytes>::Bytes) -> BigInt

#### fn from_be_bytes(bytes: &<BigInt as FromBytes>::Bytes) -> BigInt

source§#### fn from_le_bytes(bytes: &<BigInt as FromBytes>::Bytes) -> BigInt

#### fn from_le_bytes(bytes: &<BigInt as FromBytes>::Bytes) -> BigInt

source§#### fn from_ne_bytes(bytes: &Self::Bytes) -> Self

#### fn from_ne_bytes(bytes: &Self::Bytes) -> Self

source§### impl FromPrimitive for BigInt

### impl FromPrimitive for BigInt

source§#### fn from_i64(n: i64) -> Option<BigInt>

#### fn from_i64(n: i64) -> Option<BigInt>

`i64`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i128(n: i128) -> Option<BigInt>

#### fn from_i128(n: i128) -> Option<BigInt>

`i128`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned. Read moresource§#### fn from_u64(n: u64) -> Option<BigInt>

#### fn from_u64(n: u64) -> Option<BigInt>

`u64`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u128(n: u128) -> Option<BigInt>

#### fn from_u128(n: u128) -> Option<BigInt>

`u128`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned. Read moresource§#### fn from_f64(n: f64) -> Option<BigInt>

#### fn from_f64(n: f64) -> Option<BigInt>

`f64`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned. Read moresource§#### fn from_isize(n: isize) -> Option<Self>

#### fn from_isize(n: isize) -> Option<Self>

`isize`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i8(n: i8) -> Option<Self>

#### fn from_i8(n: i8) -> Option<Self>

`i8`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i16(n: i16) -> Option<Self>

#### fn from_i16(n: i16) -> Option<Self>

`i16`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_i32(n: i32) -> Option<Self>

#### fn from_i32(n: i32) -> Option<Self>

`i32`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_usize(n: usize) -> Option<Self>

#### fn from_usize(n: usize) -> Option<Self>

`usize`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u8(n: u8) -> Option<Self>

#### fn from_u8(n: u8) -> Option<Self>

`u8`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§#### fn from_u16(n: u16) -> Option<Self>

#### fn from_u16(n: u16) -> Option<Self>

`u16`

to return an optional value of this type. If the
value cannot be represented by this type, then `None`

is returned.source§### impl Integer for BigInt

### impl Integer for BigInt

source§#### fn gcd(&self, other: &BigInt) -> BigInt

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

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

.

The result is always positive.

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

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

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

.

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

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

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

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

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

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

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

👎Deprecated: Please use is_multiple_of instead

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

Deprecated, use `is_multiple_of`

instead.

source§#### fn is_multiple_of(&self, other: &BigInt) -> bool

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

Returns `true`

if the number is a multiple of `other`

.

source§#### fn next_multiple_of(&self, other: &BigInt) -> BigInt

#### fn next_multiple_of(&self, other: &BigInt) -> BigInt

Rounds up to nearest multiple of argument.

source§#### fn prev_multiple_of(&self, other: &BigInt) -> BigInt

#### fn prev_multiple_of(&self, other: &BigInt) -> BigInt

Rounds down to nearest multiple of argument.

source§#### fn div_rem(&self, other: &BigInt) -> (BigInt, BigInt)

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

`(quotient, remainder)`

. Read moresource§#### fn div_mod_floor(&self, other: &BigInt) -> (BigInt, BigInt)

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

`(quotient, remainder)`

. Read moresource§#### fn extended_gcd(&self, other: &Self) -> ExtendedGcd<Self>where
Self: Clone,

#### fn extended_gcd(&self, other: &Self) -> ExtendedGcd<Self>where
Self: Clone,

source§### impl MulAssign<&BigInt> for BigInt

### impl MulAssign<&BigInt> for BigInt

source§#### fn mul_assign(&mut self, other: &BigInt)

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

`*=`

operation. Read moresource§### impl MulAssign<i128> for BigInt

### impl MulAssign<i128> for BigInt

source§#### fn mul_assign(&mut self, other: i128)

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

`*=`

operation. Read moresource§### impl MulAssign<i16> for BigInt

### impl MulAssign<i16> for BigInt

source§#### fn mul_assign(&mut self, other: i16)

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

`*=`

operation. Read moresource§### impl MulAssign<i32> for BigInt

### impl MulAssign<i32> for BigInt

source§#### fn mul_assign(&mut self, other: i32)

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

`*=`

operation. Read moresource§### impl MulAssign<i64> for BigInt

### impl MulAssign<i64> for BigInt

source§#### fn mul_assign(&mut self, other: i64)

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

`*=`

operation. Read moresource§### impl MulAssign<i8> for BigInt

### impl MulAssign<i8> for BigInt

source§#### fn mul_assign(&mut self, other: i8)

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

`*=`

operation. Read moresource§### impl MulAssign<isize> for BigInt

### impl MulAssign<isize> for BigInt

source§#### fn mul_assign(&mut self, other: isize)

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

`*=`

operation. Read moresource§### impl MulAssign<u128> for BigInt

### impl MulAssign<u128> for BigInt

source§#### fn mul_assign(&mut self, other: u128)

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

`*=`

operation. Read moresource§### impl MulAssign<u16> for BigInt

### impl MulAssign<u16> for BigInt

source§#### fn mul_assign(&mut self, other: u16)

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

`*=`

operation. Read moresource§### impl MulAssign<u32> for BigInt

### impl MulAssign<u32> for BigInt

source§#### fn mul_assign(&mut self, other: u32)

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

`*=`

operation. Read moresource§### impl MulAssign<u64> for BigInt

### impl MulAssign<u64> for BigInt

source§#### fn mul_assign(&mut self, other: u64)

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

`*=`

operation. Read moresource§### impl MulAssign<u8> for BigInt

### impl MulAssign<u8> for BigInt

source§#### fn mul_assign(&mut self, other: u8)

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

`*=`

operation. Read moresource§### impl MulAssign<usize> for BigInt

### impl MulAssign<usize> for BigInt

source§#### fn mul_assign(&mut self, other: usize)

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

`*=`

operation. Read moresource§### impl MulAssign for BigInt

### impl MulAssign for BigInt

source§#### fn mul_assign(&mut self, other: BigInt)

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

`*=`

operation. Read moresource§### impl Num for BigInt

### impl Num for BigInt

source§#### fn from_str_radix(s: &str, radix: u32) -> Result<BigInt, ParseBigIntError>

#### fn from_str_radix(s: &str, radix: u32) -> Result<BigInt, ParseBigIntError>

Creates and initializes a `BigInt`

.

#### type FromStrRadixErr = ParseBigIntError

source§### impl Ord for BigInt

### impl Ord for BigInt

source§### impl PartialEq for BigInt

### impl PartialEq for BigInt

source§### impl PartialOrd for BigInt

### impl PartialOrd for BigInt

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

#### fn le(&self, other: &Rhs) -> bool

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl RemAssign<&BigInt> for BigInt

### impl RemAssign<&BigInt> for BigInt

source§#### fn rem_assign(&mut self, other: &BigInt)

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

`%=`

operation. Read moresource§### impl RemAssign<i128> for BigInt

### impl RemAssign<i128> for BigInt

source§#### fn rem_assign(&mut self, other: i128)

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

`%=`

operation. Read moresource§### impl RemAssign<i16> for BigInt

### impl RemAssign<i16> for BigInt

source§#### fn rem_assign(&mut self, other: i16)

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

`%=`

operation. Read moresource§### impl RemAssign<i32> for BigInt

### impl RemAssign<i32> for BigInt

source§#### fn rem_assign(&mut self, other: i32)

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

`%=`

operation. Read moresource§### impl RemAssign<i64> for BigInt

### impl RemAssign<i64> for BigInt

source§#### fn rem_assign(&mut self, other: i64)

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

`%=`

operation. Read moresource§### impl RemAssign<i8> for BigInt

### impl RemAssign<i8> for BigInt

source§#### fn rem_assign(&mut self, other: i8)

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

`%=`

operation. Read moresource§### impl RemAssign<isize> for BigInt

### impl RemAssign<isize> for BigInt

source§#### fn rem_assign(&mut self, other: isize)

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

`%=`

operation. Read moresource§### impl RemAssign<u128> for BigInt

### impl RemAssign<u128> for BigInt

source§#### fn rem_assign(&mut self, other: u128)

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

`%=`

operation. Read moresource§### impl RemAssign<u16> for BigInt

### impl RemAssign<u16> for BigInt

source§#### fn rem_assign(&mut self, other: u16)

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

`%=`

operation. Read moresource§### impl RemAssign<u32> for BigInt

### impl RemAssign<u32> for BigInt

source§#### fn rem_assign(&mut self, other: u32)

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

`%=`

operation. Read moresource§### impl RemAssign<u64> for BigInt

### impl RemAssign<u64> for BigInt

source§#### fn rem_assign(&mut self, other: u64)

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

`%=`

operation. Read moresource§### impl RemAssign<u8> for BigInt

### impl RemAssign<u8> for BigInt

source§#### fn rem_assign(&mut self, other: u8)

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

`%=`

operation. Read moresource§### impl RemAssign<usize> for BigInt

### impl RemAssign<usize> for BigInt

source§#### fn rem_assign(&mut self, other: usize)

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

`%=`

operation. Read moresource§### impl RemAssign for BigInt

### impl RemAssign for BigInt

source§#### fn rem_assign(&mut self, other: BigInt)

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

`%=`

operation. Read moresource§### impl Roots for BigInt

### impl Roots for BigInt

source§### impl SampleUniform for BigInt

### impl SampleUniform for BigInt

§#### type Sampler = UniformBigInt

#### type Sampler = UniformBigInt

`UniformSampler`

implementation supporting type `X`

.source§### impl Serialize for BigInt

### impl Serialize for BigInt

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

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

source§### impl ShlAssign<&i128> for BigInt

### impl ShlAssign<&i128> for BigInt

source§#### fn shl_assign(&mut self, rhs: &i128)

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

`<<=`

operation. Read moresource§### impl ShlAssign<&i16> for BigInt

### impl ShlAssign<&i16> for BigInt

source§#### fn shl_assign(&mut self, rhs: &i16)

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

`<<=`

operation. Read moresource§### impl ShlAssign<&i32> for BigInt

### impl ShlAssign<&i32> for BigInt

source§#### fn shl_assign(&mut self, rhs: &i32)

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

`<<=`

operation. Read moresource§### impl ShlAssign<&i64> for BigInt

### impl ShlAssign<&i64> for BigInt

source§#### fn shl_assign(&mut self, rhs: &i64)

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

`<<=`

operation. Read moresource§### impl ShlAssign<&i8> for BigInt

### impl ShlAssign<&i8> for BigInt

source§#### fn shl_assign(&mut self, rhs: &i8)

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

`<<=`

operation. Read moresource§### impl ShlAssign<&isize> for BigInt

### impl ShlAssign<&isize> for BigInt

source§#### fn shl_assign(&mut self, rhs: &isize)

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

`<<=`

operation. Read moresource§### impl ShlAssign<&u128> for BigInt

### impl ShlAssign<&u128> for BigInt

source§#### fn shl_assign(&mut self, rhs: &u128)

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

`<<=`

operation. Read moresource§### impl ShlAssign<&u16> for BigInt

### impl ShlAssign<&u16> for BigInt

source§#### fn shl_assign(&mut self, rhs: &u16)

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

`<<=`

operation. Read moresource§### impl ShlAssign<&u32> for BigInt

### impl ShlAssign<&u32> for BigInt

source§#### fn shl_assign(&mut self, rhs: &u32)

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

`<<=`

operation. Read moresource§### impl ShlAssign<&u64> for BigInt

### impl ShlAssign<&u64> for BigInt

source§#### fn shl_assign(&mut self, rhs: &u64)

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

`<<=`

operation. Read moresource§### impl ShlAssign<&u8> for BigInt

### impl ShlAssign<&u8> for BigInt

source§#### fn shl_assign(&mut self, rhs: &u8)

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

`<<=`

operation. Read moresource§### impl ShlAssign<&usize> for BigInt

### impl ShlAssign<&usize> for BigInt

source§#### fn shl_assign(&mut self, rhs: &usize)

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

`<<=`

operation. Read moresource§### impl ShlAssign<i128> for BigInt

### impl ShlAssign<i128> for BigInt

source§#### fn shl_assign(&mut self, rhs: i128)

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

`<<=`

operation. Read moresource§### impl ShlAssign<i16> for BigInt

### impl ShlAssign<i16> for BigInt

source§#### fn shl_assign(&mut self, rhs: i16)

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

`<<=`

operation. Read moresource§### impl ShlAssign<i32> for BigInt

### impl ShlAssign<i32> for BigInt

source§#### fn shl_assign(&mut self, rhs: i32)

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

`<<=`

operation. Read moresource§### impl ShlAssign<i64> for BigInt

### impl ShlAssign<i64> for BigInt

source§#### fn shl_assign(&mut self, rhs: i64)

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

`<<=`

operation. Read moresource§### impl ShlAssign<i8> for BigInt

### impl ShlAssign<i8> for BigInt

source§#### fn shl_assign(&mut self, rhs: i8)

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

`<<=`

operation. Read moresource§### impl ShlAssign<isize> for BigInt

### impl ShlAssign<isize> for BigInt

source§#### fn shl_assign(&mut self, rhs: isize)

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

`<<=`

operation. Read moresource§### impl ShlAssign<u128> for BigInt

### impl ShlAssign<u128> for BigInt

source§#### fn shl_assign(&mut self, rhs: u128)

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

`<<=`

operation. Read moresource§### impl ShlAssign<u16> for BigInt

### impl ShlAssign<u16> for BigInt

source§#### fn shl_assign(&mut self, rhs: u16)

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

`<<=`

operation. Read moresource§### impl ShlAssign<u32> for BigInt

### impl ShlAssign<u32> for BigInt

source§#### fn shl_assign(&mut self, rhs: u32)

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

`<<=`

operation. Read moresource§### impl ShlAssign<u64> for BigInt

### impl ShlAssign<u64> for BigInt

source§#### fn shl_assign(&mut self, rhs: u64)

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

`<<=`

operation. Read moresource§### impl ShlAssign<u8> for BigInt

### impl ShlAssign<u8> for BigInt

source§#### fn shl_assign(&mut self, rhs: u8)

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

`<<=`

operation. Read moresource§### impl ShlAssign<usize> for BigInt

### impl ShlAssign<usize> for BigInt

source§#### fn shl_assign(&mut self, rhs: usize)

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

`<<=`

operation. Read more