pub struct BigInt(/* private fields */);
Methods from Deref<Target = BigInt>§
sourcepub 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 232 digits are ordered least significant digit first.
sourcepub fn to_bytes_be(&self) -> (Sign, Vec<u8>)
pub fn to_bytes_be(&self) -> (Sign, Vec<u8>)
sourcepub fn to_bytes_le(&self) -> (Sign, Vec<u8>)
pub fn to_bytes_le(&self) -> (Sign, Vec<u8>)
sourcepub 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]));
sourcepub 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]));
sourcepub 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]);
sourcepub 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]);
sourcepub fn to_signed_bytes_be(&self) -> Vec<u8> ⓘ
pub fn to_signed_bytes_be(&self) -> Vec<u8> ⓘ
sourcepub fn to_signed_bytes_le(&self) -> Vec<u8> ⓘ
pub fn to_signed_bytes_le(&self) -> Vec<u8> ⓘ
sourcepub 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");
sourcepub 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
sourcepub 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)
sourcepub 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());
sourcepub fn bits(&self) -> u64
pub fn bits(&self) -> u64
Determines the fewest bits necessary to express the BigInt
,
not including the sign.
sourcepub 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>
sourcepub 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.
sourcepub fn sqrt(&self) -> BigInt
pub fn sqrt(&self) -> BigInt
Returns the truncated principal square root of self
–
see num_integer::Roots::sqrt()
.
sourcepub fn cbrt(&self) -> BigInt
pub fn cbrt(&self) -> BigInt
Returns the truncated principal cube root of self
–
see num_integer::Roots::cbrt()
.
sourcepub 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()
.
sourcepub 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.
sourcepub 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
sourcepub 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