Struct oberon::inner_types::elliptic_curve::bigint::Uint

pub struct Uint<const LIMBS: usize> { /* private fields */ }

Expand description

Big unsigned integer.

Generic over the given number of LIMBS

Encoding support

This type supports many different types of encodings, either via the Encoding trait or various const fn decoding and encoding functions that can be used with Uint constants.

Optional crate features for encoding (off-by-default):

generic-array: enables ArrayEncoding trait which can be used to Uint as GenericArray<u8, N> and a ArrayDecoding trait which can be used to GenericArray<u8, N> as Uint.
rlp: support for Recursive Length Prefix (RLP) encoding.

Implementations§

§

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.

§

impl<const LIMBS: usize> Uint<LIMBS>

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

Computes self + rhs mod p in constant time.

Assumes self + rhs as unbounded integer is < 2p.

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

Computes self + rhs mod p in constant time for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

Assumes self + rhs as unbounded integer is < 2p.

§

impl<const LIMBS: usize> Uint<LIMBS>

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

Computes bitwise a & b.

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

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

Perform checked bitwise AND, returning a CtOption which is_some always

Calculate the number of bits needed to represent this number.

pub const fn leading_zeros(self) -> usize

Calculate the number of leading zeros in the binary representation of this number.

pub const fn trailing_zeros(self) -> usize

Calculate the number of trailing zeros in the binary representation of this number.

pub const fn bits(self) -> usize

Calculate the number of bits needed to represent this number.

pub const fn bit(self, index: usize) -> CtChoice

Get the value of the bit at position index, as a truthy or falsy CtChoice. Returns the falsy value for indices out of range.

§

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn ct_div_rem_limb_with_reciprocal( &self, reciprocal: &Reciprocal ) -> (Uint<LIMBS>, Limb)

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

pub fn div_rem_limb_with_reciprocal( &self, reciprocal: &CtOption<Reciprocal> ) -> CtOption<(Uint<LIMBS>, Limb)>

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

pub fn div_rem_limb(&self, rhs: NonZero<Limb>) -> (Uint<LIMBS>, Limb)

Computes self / rhs, returns the quotient (q) and remainder (r).

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

Computes self % rhs, returns the remainder and and the truthy value for is_some or the falsy value for is_none.

NOTE: Use only if you need to access const fn. Otherwise use Self::rem. This is variable only with respect to rhs.

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

pub const fn const_rem_wide( lower_upper: (Uint<LIMBS>, Uint<LIMBS>), rhs: &Uint<LIMBS> ) -> (Uint<LIMBS>, CtChoice)

Computes self % rhs, returns the remainder and and the truthy value for is_some or the falsy value for is_none.

This is variable only with respect to rhs.

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

pub const fn rem2k(&self, k: usize) -> Uint<LIMBS>

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 fn div_rem(&self, rhs: &NonZero<Uint<LIMBS>>) -> (Uint<LIMBS>, Uint<LIMBS>)

Computes self / rhs, returns the quotient, remainder.

pub fn rem(&self, rhs: &NonZero<Uint<LIMBS>>) -> Uint<LIMBS>

Computes self % rhs, returns the remainder.

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

Wrapped division is just normal division i.e. self / rhs There’s no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.

Panics if rhs == 0.

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

Perform checked division, returning a CtOption which is_some only if the rhs != 0

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

Wrapped (modular) remainder calculation is just self % rhs. There’s no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.

Panics if rhs == 0.

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

Perform checked reduction, returning a CtOption which is_some only if the rhs != 0

§

impl<const LIMBS: usize> Uint<LIMBS>

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.

§

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn from_u8(n: u8) -> Uint<LIMBS>

Create a Uint from a u8 (const-friendly)

pub const fn from_u16(n: u16) -> Uint<LIMBS>

Create a Uint from a u16 (const-friendly)

pub const fn from_u32(n: u32) -> Uint<LIMBS>

Create a Uint from a u32 (const-friendly)

pub const fn from_u64(n: u64) -> Uint<LIMBS>

Create a Uint from a u64 (const-friendly)

pub const fn from_u128(n: u128) -> Uint<LIMBS>

Create a Uint from a u128 (const-friendly)

pub const fn from_word(n: u64) -> Uint<LIMBS>

Create a Uint from a Word (const-friendly)

pub const fn from_wide_word(n: u128) -> Uint<LIMBS>

Create a Uint from a WideWord (const-friendly)

§

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn inv_mod2k(&self, k: usize) -> Uint<LIMBS>

Computes 1/self mod 2^k as specified in Algorithm 4 from A Secure Algorithm for Inversion Modulo 2k by Sadiel de la Fe and Carles Ferrer. See https://www.mdpi.com/2410-387X/2/3/23.

Conditions: self < 2^k and self must be odd

pub const fn inv_odd_mod_bounded( &self, modulus: &Uint<LIMBS>, bits: usize, modulus_bits: usize ) -> (Uint<LIMBS>, CtChoice)

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, Word::MAX) if an inverse exists, otherwise (undefined, Word::ZERO).

§

impl<const LIMBS: usize> Uint<LIMBS>

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

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(&self, rhs: &Uint<LIMBS>) -> Uint<LIMBS>

Perform saturating multiplication, returning MAX on overflow.

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

Perform wrapping multiplication, discarding overflow.

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

Square self, returning a concatenated “wide” result.

pub const fn square_wide(&self) -> (Uint<LIMBS>, Uint<LIMBS>)

Square self, returning a “wide” result in two parts as (lo, hi).

§

impl<const LIMBS: usize> Uint<LIMBS>

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

Computes self * rhs mod p in constant time for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb. For the modulus reduction, this function implements Algorithm 14.47 from the “Handbook of Applied Cryptography”, by A. Menezes, P. van Oorschot, and S. Vanstone, CRC Press, 1996.

§

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn neg_mod(&self, p: &Uint<LIMBS>) -> Uint<LIMBS>

Computes -a mod p in constant time. Assumes self is in [0, p).

pub const fn neg_mod_special(&self, c: Limb) -> Uint<LIMBS>

Computes -a mod p in constant time for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

§

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn resize<const T: usize>(&self) -> Uint<T>

Construct a Uint<T> from the unsigned integer value, truncating the upper bits if the value is too large to be represented.

§

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn shl_vartime(&self, n: usize) -> Uint<LIMBS>

Computes self << shift.

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

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

pub const fn shl_vartime_wide( lower_upper: (Uint<LIMBS>, Uint<LIMBS>), n: usize ) -> (Uint<LIMBS>, Uint<LIMBS>)

Computes a left shift on a wide input as (lo, hi).

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

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

§

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn shr_vartime(&self, shift: usize) -> Uint<LIMBS>

Computes self >> n.

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

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

pub const fn shr_vartime_wide( lower_upper: (Uint<LIMBS>, Uint<LIMBS>), n: usize ) -> (Uint<LIMBS>, Uint<LIMBS>)

Computes a right shift on a wide input as (lo, hi).

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

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

§

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn sqrt(&self) -> Uint<LIMBS>

Computes √(self) Uses Brent & Zimmermann, Modern Computer Arithmetic, v0.5.9, Algorithm 1.13

Callers can check if self is a square by squaring the result

pub const fn wrapping_sqrt(&self) -> Uint<LIMBS>

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>>

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.

§

impl<const LIMBS: usize> Uint<LIMBS>

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

Computes self - rhs mod p in constant time.

Assumes self - rhs as unbounded signed integer is in [-p, p).

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

Computes self - rhs mod p in constant time for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

Assumes self - rhs as unbounded signed integer is in [-p, p).

§

impl<const LIMBS: usize> Uint<LIMBS>

pub const ZERO: Uint<LIMBS> = Self::from_u8(0)

The value 0.

pub const ONE: Uint<LIMBS> = Self::from_u8(1)

The value 1.

pub const MAX: Uint<LIMBS> = Self{ limbs: [Limb::MAX; LIMBS],}

Maximum value this Uint can express.

pub const BITS: usize = LIMBS * Limb::BITS

Total size of the represented integer in bits.

pub const BYTES: usize = LIMBS * Limb::BYTES

Total size of the represented integer in bytes.

pub const LIMBS: usize = LIMBS

The number of limbs used on this platform.

pub const fn new(limbs: [Limb; LIMBS]) -> Uint<LIMBS>

Const-friendly Uint constructor.

pub const fn from_words(arr: [u64; LIMBS]) -> Uint<LIMBS>

Create a Uint from an array of Words (i.e. word-sized unsigned integers).

pub const fn to_words(self) -> [u64; LIMBS]

Create an array of Words (i.e. word-sized unsigned integers) from a Uint.

pub const fn as_words(&self) -> &[u64; LIMBS]

Borrow the inner limbs as an array of Words.

pub fn as_words_mut(&mut self) -> &mut [u64; LIMBS]

Borrow the inner limbs as a mutable array of Words.

pub const fn as_limbs(&self) -> &[Limb; LIMBS]

Borrow the limbs of this Uint.

pub fn as_limbs_mut(&mut self) -> &mut [Limb; LIMBS]

Borrow the limbs of this Uint mutably.

pub const fn to_limbs(self) -> [Limb; LIMBS]

Convert this Uint into its inner limbs.

Trait Implementations§

§

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

§

type Output = Uint<LIMBS>

Output type.

§

fn add_mod(&self, rhs: &Uint<LIMBS>, p: &Uint<LIMBS>) -> Uint<LIMBS>

Compute self + rhs mod p. Read more

§

Size of a byte array which encodes a big integer.

§

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U1792::{constant#0}> as ArrayEncoding>::ByteSize> ) -> Uint<crypto_bigint::::uint::U1792::{constant#0}>

Deserialize from a big-endian byte array.

§

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U1792::{constant#0}> as ArrayEncoding>::ByteSize> ) -> Uint<crypto_bigint::::uint::U1792::{constant#0}>

Deserialize from a little-endian byte array.

§

fn to_be_byte_array( &self ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U1792::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

§

fn to_le_byte_array( &self ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U1792::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

§

Size of a byte array which encodes a big integer.

§

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U3072::{constant#0}> as ArrayEncoding>::ByteSize> ) -> Uint<crypto_bigint::::uint::U3072::{constant#0}>

Deserialize from a big-endian byte array.

§

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U3072::{constant#0}> as ArrayEncoding>::ByteSize> ) -> Uint<crypto_bigint::::uint::U3072::{constant#0}>

Deserialize from a little-endian byte array.

§

fn to_be_byte_array( &self ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U3072::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

§

fn to_le_byte_array( &self ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U3072::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

§

Size of a byte array which encodes a big integer.

§

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U448::{constant#0}> as ArrayEncoding>::ByteSize> ) -> Uint<crypto_bigint::::uint::U448::{constant#0}>

Deserialize from a big-endian byte array.

§

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U448::{constant#0}> as ArrayEncoding>::ByteSize> ) -> Uint<crypto_bigint::::uint::U448::{constant#0}>

Deserialize from a little-endian byte array.

§

fn to_be_byte_array( &self ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U448::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

§

fn to_le_byte_array( &self ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U448::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

§

Size of a byte array which encodes a big integer.

§

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U64::{constant#0}> as ArrayEncoding>::ByteSize> ) -> Uint<crypto_bigint::::uint::U64::{constant#0}>

Deserialize from a big-endian byte array.

§

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U64::{constant#0}> as ArrayEncoding>::ByteSize> ) -> Uint<crypto_bigint::::uint::U64::{constant#0}>

Deserialize from a little-endian byte array.

§

fn to_be_byte_array( &self ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U64::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

§

fn to_le_byte_array( &self ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U64::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a little-endian byte array.

§

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

§

fn from_be_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U896::{constant#0}> as ArrayEncoding>::ByteSize> ) -> Uint<crypto_bigint::::uint::U896::{constant#0}>

Deserialize from a big-endian byte array.

§

fn from_le_byte_array( bytes: GenericArray<u8, <Uint<crypto_bigint::::uint::U896::{constant#0}> as ArrayEncoding>::ByteSize> ) -> Uint<crypto_bigint::::uint::U896::{constant#0}>

Deserialize from a little-endian byte array.

§

fn to_be_byte_array( &self ) -> GenericArray<u8, <Uint<crypto_bigint::::uint::U896::{constant#0}> as ArrayEncoding>::ByteSize>

Serialize to a big-endian byte array.

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::U1792::{constant#0}> as Encoding>::Repr ) -> Uint<crypto_bigint::::uint::U1792::{constant#0}>

Decode from big endian bytes.

§

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

Decode from little endian bytes.

§

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

Encode to big endian bytes.

§

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

Encode to little endian bytes.

§

Byte array representation.

§

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

Decode from big endian bytes.

§

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

Decode from little endian bytes.

§

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

Encode to big endian bytes.

§

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

Encode to little endian bytes.

§

Byte array representation.

§

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

Decode from big endian bytes.

§

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

Decode from little endian bytes.

§

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

Encode to big endian bytes.

§

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

Encode to little endian bytes.

§

Byte array representation.

§

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

Decode from big endian bytes.

§

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

Decode from little endian bytes.

§

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

Encode to big endian bytes.

§

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

Encode to little endian bytes.

§

Byte array representation.

§

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

Decode from big endian bytes.

§

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

Decode from little endian bytes.

§

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

Encode to big endian bytes.

§

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

Encode to little endian bytes.

§

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

§

Compute -self mod p.

§

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

§

type Output = Uint<LIMBS>

The resulting type after applying the ! operator.

§

fn not(self) -> <Uint<LIMBS> as Not>::Output

Performs the unary ! operation. Read more

§

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

§

fn cmp(&self, other: &Uint<LIMBS>) -> Ordering

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.

§

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<A, T> AsMutBits<T> for Awhere A: AsMut<[T]>, T: BitStore,

§

fn as_mut_bits<O>(&mut self) -> &mut BitSlice<T, O>where O: BitOrder,

Views self as a mutable bit-slice region with the O ordering.

source §

fn from(t: T) -> T

Returns the argument unchanged.

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.

source §

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.

source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Performs the conversion.

source §

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

§

type Error = >::Error

The type returned in the event of a conversion error.

source §

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

Performs the conversion.

source §

impl<Z> Zeroize for Zwhere Z: DefaultIsZeroes,

source §

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.