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,

Reads Self from reader using the compressed form if applicable. Performs validation if applicable.

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

where R: Read,

Reads Self from reader using the compressed form if applicable, without validating the deserialized value.

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

where R: Read,

Reads Self from reader using the uncompressed form. Performs validation if applicable.

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

where R: Read,

Reads Self from reader using the uncompressed form, without validating the deserialized value.

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

Returns the size in bytes of the serialized version of self with the given compression mode.

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

where W: Write,

Serializes self into writer using the compressed form if applicable.

fn compressed_size(&self) -> usize

Returns the size in bytes of the compressed serialized version of self.

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

where W: Write,

Serializes self into writer using the uncompressed form.

fn uncompressed_size(&self) -> usize

Returns the size in bytes of the uncompressed serialized version of self.

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

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

Returns a duplicate 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<P: SmallFpConfig> From<BigInt<1>> for SmallFp<P>

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

Converts to this type from the input type.

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<P: SmallFpConfig> From<SmallFp<P>> for BigInt<1>

fn from(fp: SmallFp<P>) -> 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>

const TRIVIAL_CHECK: bool = true

Whether the check method is trivial (i.e. always returns Ok(())). If this is true, the batch_check method will skip all checks and return Ok(()). This should be set to true for types where check is trivial, e.g. integers, field elements, etc. This is false by default. This is primarily an optimization to skip unnecessary checks in batch_check.

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

Checks whether self is valid. If self is valid, returns Ok(()). Otherwise, returns an error describing the failure. This method is called by deserialize_with_mode if validate is Validate::Yes.

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

where Self: 'a,

Checks whether all items in batch are valid. If all items are valid, returns Ok(()). Otherwise, returns an error describing the first failure.

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>