Struct sunscreen_zkp_backend::Uint

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn adc(&self, rhs: &Uint<LIMBS>, carry: Limb) -> (Uint<LIMBS>, Limb)

Computes a + b + carry, returning the result along with the new carry.

pub const fn saturating_add(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform saturating addition, returning MAX on overflow.

pub const fn wrapping_add(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform wrapping addition, discarding overflow.

pub const fn wrapping_and(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform wrapping bitwise AND.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

Perform wrapping bitwise OR.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

pub fn checked_or(&self, rhs: &Uint<LIMBS>) -> CtOption<Uint<LIMBS>>

Perform checked bitwise OR, returning a CtOption which is_some always

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn bitxor(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Computes bitwise a ^ b.

pub const fn wrapping_xor(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform wrapping bitwise `XOR``.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

pub fn checked_xor(&self, rhs: &Uint<LIMBS>) -> CtOption<Uint<LIMBS>>

Perform checked bitwise XOR, returning a CtOption which is_some always

Computes self / rhs using a pre-made reciprocal, returns the quotient (q) and remainder (r).

Computes self % 2^k. Faster than reduce since its a power of 2. Limited to 2^16-1 since Uint doesn’t support higher.

pub const fn from_be_slice(bytes: &[u8]) -> Uint<LIMBS>

Create a new Uint from the provided big endian bytes.

pub const fn from_be_hex(hex: &str) -> Uint<LIMBS>

Create a new Uint from the provided big endian hex string.

pub const fn from_le_slice(bytes: &[u8]) -> Uint<LIMBS>

Create a new Uint from the provided little endian bytes.

pub const fn from_le_hex(hex: &str) -> Uint<LIMBS>

Create a new Uint from the provided little endian hex string.

Computes the multiplicative inverse of self mod modulus, where modulus is odd. In other words self^-1 mod modulus. bits and modulus_bits are the bounds on the bit size of self and modulus, respectively (the inversion speed will be proportional to bits + modulus_bits). The second element of the tuple is the truthy value if an inverse exists, otherwise it is a falsy value.

Note: variable time in bits and modulus_bits.

The algorithm is the same as in GMP 6.2.1’s mpn_sec_invert.

pub const fn inv_odd_mod( &self, modulus: &Uint<LIMBS> ) -> (Uint<LIMBS>, CtChoice)

Computes the multiplicative inverse of self mod modulus, where modulus is odd. Returns (inverse, CtChoice::TRUE) if an inverse exists, otherwise (undefined, CtChoice::FALSE).

pub const fn inv_mod(&self, modulus: &Uint<LIMBS>) -> (Uint<LIMBS>, CtChoice)

Computes the multiplicative inverse of self mod modulus. Returns (inverse, CtChoice::TRUE) if an inverse exists, otherwise (undefined, CtChoice::FALSE).

impl<const LIMBS: usize> Uint<LIMBS>

pub fn mul<const HLIMBS: usize>( &self, rhs: &Uint<HLIMBS> ) -> <Uint<HLIMBS> as ConcatMixed<Uint<LIMBS>>>::MixedOutputwhere Uint<HLIMBS>: ConcatMixed<Uint<LIMBS>>,

Multiply self by rhs, returning a concatenated “wide” result.

pub const fn mul_wide<const HLIMBS: usize>( &self, rhs: &Uint<HLIMBS> ) -> (Uint<LIMBS>, Uint<HLIMBS>)

Compute “wide” multiplication, with a product twice the size of the input.

Returns a tuple containing the (lo, hi) components of the product.

Ordering note

Releases of crypto-bigint prior to v0.3 used (hi, lo) ordering instead. This has been changed for better consistency with the rest of the APIs in this crate.

For more info see: https://github.com/RustCrypto/crypto-bigint/issues/4

pub const fn saturating_mul<const HLIMBS: usize>( &self, rhs: &Uint<HLIMBS> ) -> Uint<LIMBS>

Perform saturating multiplication, returning MAX on overflow.

pub const fn wrapping_mul<const H: usize>(&self, rhs: &Uint<H>) -> Uint<LIMBS>

Perform wrapping multiplication, discarding overflow.

pub fn square(&self) -> <Uint<LIMBS> as Concat>::Outputwhere Uint<LIMBS>: Concat,

Square self, returning a concatenated “wide” result.

Wrapped sqrt is just normal √(self) There’s no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.

pub fn checked_sqrt(&self) -> CtOption<Uint<LIMBS>>

👎Deprecated since 0.5.3: This functionality will be moved to checked_sqrt_vartime in a future release.

See Self::checked_sqrt_vartime.

pub fn checked_sqrt_vartime(&self) -> CtOption<Uint<LIMBS>>

Perform checked sqrt, returning a CtOption which is_some only if the √(self)² == self

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn sbb(&self, rhs: &Uint<LIMBS>, borrow: Limb) -> (Uint<LIMBS>, Limb)

Computes a - (b + borrow), returning the result along with the new borrow.

pub const fn saturating_sub(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform saturating subtraction, returning ZERO on underflow.

pub const fn wrapping_sub(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform wrapping subtraction, discarding underflow and wrapping around the boundary of the type.

Performs the &= operation. Read more

Performs the |= operation. Read more

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves. Read more

impl<const LIMBS: usize> ConstantTimeEq for Uint<LIMBS>

fn ct_eq(&self, other: &Uint<LIMBS>) -> Choice

Determine if two items are equal. Read more

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U1024::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U1024::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self ) -> <Uint<crypto_bigint::::uint::U1024::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self ) -> <Uint<crypto_bigint::::uint::U1024::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U16384::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U16384::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U16384::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U16384::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self ) -> <Uint<crypto_bigint::::uint::U16384::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self ) -> <Uint<crypto_bigint::::uint::U16384::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U224::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U224::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U224::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U224::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self ) -> <Uint<crypto_bigint::::uint::U224::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self ) -> <Uint<crypto_bigint::::uint::U224::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U32768::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U32768::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U32768::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U32768::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self ) -> <Uint<crypto_bigint::::uint::U32768::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self ) -> <Uint<crypto_bigint::::uint::U32768::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U4224::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U4224::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U4224::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U4224::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self ) -> <Uint<crypto_bigint::::uint::U4224::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self ) -> <Uint<crypto_bigint::::uint::U4224::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U544::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U544::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U544::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U544::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self ) -> <Uint<crypto_bigint::::uint::U544::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self ) -> <Uint<crypto_bigint::::uint::U544::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U64::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U64::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U64::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U64::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self ) -> <Uint<crypto_bigint::::uint::U64::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self ) -> <Uint<crypto_bigint::::uint::U64::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U832::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U832::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U832::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U832::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self ) -> <Uint<crypto_bigint::::uint::U832::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes( &self ) -> <Uint<crypto_bigint::::uint::U832::{constant#0}> as Encoding>::Repr

Encode to little endian bytes.

type Repr = [u8; 120]

Byte array representation.

fn from_be_bytes( bytes: <Uint<crypto_bigint::::uint::U960::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U960::{constant#0}>

Decode from big endian bytes.

fn from_le_bytes( bytes: <Uint<crypto_bigint::::uint::U960::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U960::{constant#0}>

Decode from little endian bytes.

fn to_be_bytes( &self ) -> <Uint<crypto_bigint::::uint::U960::{constant#0}> as Encoding>::Repr

Encode to big endian bytes.

Feeds a slice of this type into the given Hasher. Read more

This method returns an Ordering between self and other. Read more

1.21.0 · source§

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

Compares and returns the maximum of two values. Read more

1.21.0 · source§

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

Compares and returns the minimum of two values. Read more

1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval. Read more

impl<const LIMBS: usize> PartialEq<Uint<LIMBS>> for Uint<LIMBS>

fn eq(&self, other: &Uint<LIMBS>) -> bool

This method tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

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

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

When used with a fixed rhs, this function is constant-time with respect to self.

type Output = Uint<LIMBS>

The resulting type after applying the << operator.

impl<const LIMBS: usize> Shl<usize> for Uint<LIMBS>

fn shl(self, rhs: usize) -> Uint<LIMBS>

NOTE: this operation is variable time with respect to rhs ONLY.

When used with a fixed rhs, this function is constant-time with respect to self.

type Output = Uint<LIMBS>

The resulting type after applying the << operator.

impl<const LIMBS: usize> Shr<usize> for Uint<LIMBS>

fn shr(self, rhs: usize) -> Uint<LIMBS>

NOTE: this operation is variable time with respect to rhs ONLY.

When used with a fixed rhs, this function is constant-time with respect to self.

impl<const LIMBS: usize> Copy for Uint<LIMBS>

impl<const LIMBS: usize> Eq for Uint<LIMBS>

fn into(self) -> U

Calls U::from(self).

impl<T, U> TryInto for Twhere U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

fn vzip(self) -> V

impl<T, U> ZkpInto<T> for Uwhere T: ZkpFrom,

fn zkp_into(self) -> T

See std::convert::Into::into.