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]) -> BigInt<N>

pub const fn zero() -> BigInt<N>

pub const fn one() -> BigInt<N>

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: &BigInt<N>) -> 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: &BigInt<N>) -> 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: &BigInt<N>) -> (BigInt<N>, BigInt<N>)

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

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

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

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

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]) -> BigInt<N>

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

fn from_bits_le(bits: &[bool]) -> BigInt<N>

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, const N: usize> BitAnd<B> for BigInt<N>

where B: Borrow<BigInt<N>>,

type Output = BigInt<N>

The resulting type after applying the & operator.

fn bitand(self, rhs: B) -> <BigInt<N> as BitAnd<B>>::Output

Performs the & operation.

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

where B: Borrow<BigInt<N>>,

fn bitand_assign(&mut self, rhs: B)

Performs the &= operation.

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

where B: Borrow<BigInt<N>>,

type Output = BigInt<N>

The resulting type after applying the | operator.

fn bitor(self, rhs: B) -> <BigInt<N> as BitOr<B>>::Output

Performs the | operation.

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

where B: Borrow<BigInt<N>>,

fn bitor_assign(&mut self, rhs: B)

Performs the |= operation.

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

where B: Borrow<BigInt<N>>,

type Output = BigInt<N>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: B) -> <BigInt<N> as BitXor<B>>::Output

Performs the ^ operation.

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

where B: Borrow<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>( reader: R, compress: Compress, validate: Validate, ) -> Result<BigInt<N>, SerializationError>

where R: Read,

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>( &self, writer: W, compress: Compress, ) -> Result<(), SerializationError>

where W: Write,

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 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<(), Error>

Formats the value using the given formatter.

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

fn default() -> BigInt<N>

Returns the “default value” for a type.

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

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

Formats the value using the given formatter.

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

where P: FpConfig<N>,

fn from(int: BigInt<N>) -> Fp<P, N>

Converts Self::BigInteger into Self

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

where P: FpConfig<N>,

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

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<BigInt<N>, <BigInt<N> as FromStr>::Err>

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

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

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

where __H: Hasher,

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) -> <BigInt<N> as Not>::Output

Performs the unary ! operation.

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

fn cmp(&self, other: &BigInt<N>) -> 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: &BigInt<N>) -> 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) -> <BigInt<N> as Shl<u32>>::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) -> <BigInt<N> as Shr<u32>>::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>, <BigInt<N> as TryFrom<BigUint>>::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<(), Error>

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>