Struct BigInt

pub struct BigInt<const N: usize>(pub [u64; N]);

Tuple Fields

0: [u64; N]

Implementations

impl<const N: usize> BigInt<N>

pub const fn new(value: [u64; N]) -> Self

pub const fn zero() -> Self

pub const fn one() -> Self

Trait Implementations

impl<const N: usize> AsMut<[u64]> for BigInt<N>

fn as_mut(&mut self) -> &mut [u64]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<const N: usize> AsRef<[u64]> for BigInt<N>

fn as_ref(&self) -> &[u64]

Converts this type into a shared reference of the (usually inferred) input type.

impl<const N: usize> BigInteger for BigInt<N>

const NUM_LIMBS: usize = N

Number of 64-bit limbs representing Self.

fn add_with_carry(&mut self, other: &Self) -> bool

Add another BigInteger to self. This method stores the result in self, and returns a carry bit.

fn sub_with_borrow(&mut self, other: &Self) -> bool

Subtract another BigInteger from this one. This method stores the result in self, and returns a borrow.

fn mul2(&mut self) -> bool

Performs a leftwise bitshift of this number, effectively multiplying it by 2. Overflow is ignored.

fn muln(&mut self, n: u32)

👎Deprecated since 0.4.2: please use the operator << instead

Performs a leftwise bitshift of this number by n bits, effectively multiplying it by 2^n. Overflow is ignored.

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

Multiplies this BigInteger by another BigInteger, returning both low and high bits of the result.

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

Multiplies this BigInteger by another BigInteger, storing the result in self. Overflow is ignored.

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

Multiplies this BigInteger by another BigInteger, returning the high bits of the result.

fn div2(&mut self)

Performs a rightwise bitshift of this number, effectively dividing it by 2.

fn divn(&mut self, n: u32)

👎Deprecated since 0.4.2: please use the operator >> instead

Performs a rightwise bitshift of this number by some amount.

fn is_odd(&self) -> bool

Returns true iff this number is odd.

fn is_even(&self) -> bool

Returns true iff this number is even.

fn is_zero(&self) -> bool

Returns true iff this number is zero.

fn num_bits(&self) -> u32

Compute the minimum number of bits needed to encode this number.

fn get_bit(&self, i: usize) -> bool

Compute the i-th bit of self.

fn from_bits_be(bits: &[bool]) -> Self

Returns the big integer representation of a given big endian boolean array.

fn from_bits_le(bits: &[bool]) -> Self

Returns the big integer representation of a given little endian boolean array.

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

Returns the byte representation in a big endian byte array, with leading zeros.

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

Returns the byte representation in a little endian byte array, with trailing zeros.

fn to_bits_be(&self) -> Vec<bool>

Returns the bit representation in a big endian boolean array, with leading zeroes.

fn to_bits_le(&self) -> Vec<bool>

Returns the bit representation in a little endian boolean array, with trailing zeroes.

fn find_wnaf(&self, w: usize) -> Option<Vec<i64>>

Returns the windowed non-adjacent form of self, for a window of size w.

impl<B: Borrow<Self>, const N: usize> BitAnd<B> for BigInt<N>

type Output = BigInt<N>

The resulting type after applying the & operator.

fn bitand(self, rhs: B) -> Self::Output

Performs the & operation.

impl<B: Borrow<Self>, const N: usize> BitAndAssign<B> for BigInt<N>

fn bitand_assign(&mut self, rhs: B)

Performs the &= operation.

impl<B: Borrow<Self>, const N: usize> BitOr<B> for BigInt<N>

type Output = BigInt<N>

The resulting type after applying the | operator.

fn bitor(self, rhs: B) -> Self::Output

Performs the | operation.

impl<B: Borrow<Self>, const N: usize> BitOrAssign<B> for BigInt<N>

fn bitor_assign(&mut self, rhs: B)

Performs the |= operation.

impl<B: Borrow<Self>, const N: usize> BitXor<B> for BigInt<N>

type Output = BigInt<N>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: B) -> Self::Output

Performs the ^ operation.

impl<B: Borrow<Self>, const N: usize> BitXorAssign<B> for BigInt<N>

fn bitxor_assign(&mut self, rhs: B)

Performs the ^= operation.

impl<const N: usize> CanonicalDeserialize for BigInt<N>

fn deserialize_with_mode<R: Read>( reader: R, compress: Compress, validate: Validate, ) -> Result<Self, SerializationError>

The general deserialize method that takes in customization flags.

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_compressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

impl<const N: usize> CanonicalSerialize for BigInt<N>

fn serialize_with_mode<W: Write>( &self, writer: W, compress: Compress, ) -> Result<(), SerializationError>

The general serialize method that takes in customization flags.

fn serialized_size(&self, compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn uncompressed_size(&self) -> usize

impl<const N: usize> Clone for BigInt<N>

fn clone(&self) -> BigInt<N>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const N: usize> Debug for BigInt<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for BigInt<N>

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize> Display for BigInt<N>

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

Formats the value using the given formatter.

impl<const N: usize> Distribution<BigInt<N>> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> BigInt<N>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<const N: usize> From<BigInt<N>> for BigInt

fn from(val: BigInt<N>) -> BigInt

Converts to this type from the input type.

impl<const N: usize> From<BigInt<N>> for BigUint

fn from(val: BigInt<N>) -> BigUint

Converts to this type from the input type.

impl<P: FpConfig<N>, const N: usize> From<BigInt<N>> for Fp<P, N>

fn from(int: BigInt<N>) -> Self

Converts Self::BigInteger into Self

impl<P: FpConfig<N>, const N: usize> From<Fp<P, N>> for BigInt<N>

fn from(fp: Fp<P, N>) -> Self

Converts to this type from the input type.

impl<const N: usize> From<u16> for BigInt<N>

fn from(val: u16) -> BigInt<N>

Converts to this type from the input type.

impl<const N: usize> From<u32> for BigInt<N>

fn from(val: u32) -> BigInt<N>

Converts to this type from the input type.

impl<const N: usize> From<u64> for BigInt<N>

fn from(val: u64) -> BigInt<N>

Converts to this type from the input type.

impl<const N: usize> From<u8> for BigInt<N>

fn from(val: u8) -> BigInt<N>

Converts to this type from the input type.

impl<const N: usize> FromStr for BigInt<N>

type Err = ()

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<const N: usize> Hash for BigInt<N>

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: usize> Not for BigInt<N>

type Output = BigInt<N>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const N: usize> Ord for BigInt<N>

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const N: usize> PartialEq for BigInt<N>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize> PartialOrd for BigInt<N>

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const N: usize> Shl<u32> for BigInt<N>

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

Computes the bitwise shift left operation in place.

Differently from the built-in numeric types (u8, u32, u64, etc.) this operation does not return an overflow error if the number of bits shifted is larger than N * 64. Instead, the overflow will be chopped off.

type Output = BigInt<N>

The resulting type after applying the << operator.

impl<const N: usize> ShlAssign<u32> for BigInt<N>

fn shl_assign(&mut self, rhs: u32)

Computes the bitwise shift left operation in place.

Differently from the built-in numeric types (u8, u32, u64, etc.) this operation does not return an overflow error if the number of bits shifted is larger than N * 64. Instead, the overflow will be chopped off.

impl<const N: usize> Shr<u32> for BigInt<N>

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

Computes bitwise shift right operation.

Differently from the built-in numeric types (u8, u32, u64, etc.) this operation does not return an underflow error if the number of bits shifted is larger than N * 64. Instead the result will be saturated to zero.

type Output = BigInt<N>

The resulting type after applying the >> operator.

impl<const N: usize> ShrAssign<u32> for BigInt<N>

fn shr_assign(&mut self, rhs: u32)

Computes the bitwise shift right operation in place.

Differently from the built-in numeric types (u8, u32, u64, etc.) this operation does not return an underflow error if the number of bits shifted is larger than N * 64. Instead the result will be saturated to zero.

impl<const N: usize> TryFrom<BigUint> for BigInt<N>

fn try_from(val: BigUint) -> Result<BigInt<N>, Self::Error>

Returns Err(()) if the bit size of val is more than N * 64.

type Error = ()

The type returned in the event of a conversion error.

impl<const N: usize> UpperHex for BigInt<N>

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

Formats the value using the given formatter.

impl<const N: usize> Valid for BigInt<N>

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>( batch: impl Iterator<Item = &'a Self> + Send, ) -> Result<(), SerializationError>

where Self: 'a,

impl<const N: usize> Zeroize for BigInt<N>

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl<const N: usize> Copy for BigInt<N>

impl<const N: usize> Eq for BigInt<N>

impl<const N: usize> StructuralPartialEq for BigInt<N>