Struct Uint 

pub struct Uint { /* private fields */ }

Available on crate feature bigint only.

Fixed-precision heap-allocated big unsigned integer.

Alternative to the stack-allocated Uint but with a fixed precision chosen at runtime instead of compile time.

Unlike many other heap-allocated big integer libraries, this type is not arbitrary precision and will wrap at its fixed-precision rather than automatically growing.

Implementations

impl BoxedUint

pub fn adc(&self, rhs: &BoxedUint, carry: Limb) -> (BoxedUint, Limb)

👎Deprecated since 0.7.0:

please use carrying_add instead

Computes self + rhs + carry, returning the result along with the new carry.

pub fn carrying_add( &self, rhs: impl AsRef<UintRef>, carry: Limb, ) -> (BoxedUint, Limb)

Computes self + rhs + carry, returning the result along with the new carry.

The result is widened to the same width as the widest input.

pub fn adc_assign(&mut self, rhs: impl AsRef<[Limb]>, carry: Limb) -> Limb

👎Deprecated since 0.7.0:

please use carrying_add_assign instead

Computes self + rhs + carry in-place, returning the new carry.

Panics

• if rhs has a larger precision than self.

pub fn concatenating_add(&self, rhs: impl AsRef<UintRef>) -> BoxedUint

Computes self + rhs, returning a result which is concatenated with the overflow limb which would be returned if carrying_add were called with the same operands.

pub fn overflowing_add(&self, rhs: impl AsRef<UintRef>) -> (BoxedUint, Choice)

Computes self + rhs, returning a tuple of the sum along with a Choice which indicates whether an overflow occurred.

If an overflow occurred, then the wrapped value is returned.

pub fn overflowing_add_assign(&mut self, rhs: impl AsRef<UintRef>) -> Choice

Adds rhs to self, returning a Choice which indicates whether an overflow occurred.

If an overflow occurred, then the wrapped value is returned.

pub fn wrapping_add(&self, rhs: impl AsRef<UintRef>) -> BoxedUint

Perform wrapping addition, discarding overflow.

pub fn wrapping_add_assign(&mut self, rhs: impl AsRef<UintRef>)

Perform wrapping addition of rhs to self, discarding overflow.

impl BoxedUint

pub fn add_mod(&self, rhs: &BoxedUint, p: &NonZero<BoxedUint>) -> BoxedUint

Computes self + rhs mod p.

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

pub fn add_mod_assign(&mut self, rhs: &BoxedUint, p: &NonZero<BoxedUint>)

Computes self + rhs mod p and writes the result in self.

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

pub fn double_mod(&self, p: &NonZero<BoxedUint>) -> BoxedUint

Computes self + self mod p.

Assumes self as unbounded integer is < p.

pub fn add_mod_special(&self, rhs: &BoxedUint, c: Limb) -> BoxedUint

Computes self + rhs mod p 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 BoxedUint

pub fn bitand(&self, rhs: &BoxedUint) -> BoxedUint

Computes bitwise a & b.

pub fn bitand_limb(&self, rhs: Limb) -> BoxedUint

Perform bitwise AND between self and the given Limb, performing the AND operation on every limb of self.

pub fn wrapping_and(&self, rhs: &BoxedUint) -> BoxedUint

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: &BoxedUint) -> CtOption<BoxedUint>

Perform checked bitwise AND, returning a CtOption which is_some always

impl BoxedUint

pub fn not(&self) -> BoxedUint

Computes bitwise !a.

impl BoxedUint

pub fn bitor(&self, rhs: &BoxedUint) -> BoxedUint

Computes bitwise a | b.

pub fn wrapping_or(&self, rhs: &BoxedUint) -> BoxedUint

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: &BoxedUint) -> CtOption<BoxedUint>

Perform checked bitwise OR, returning a CtOption which is_some always

impl BoxedUint

pub fn bitxor(&self, rhs: &BoxedUint) -> BoxedUint

Computes bitwise a ^ b.

pub fn wrapping_xor(&self, rhs: &BoxedUint) -> BoxedUint

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: &BoxedUint) -> CtOption<BoxedUint>

Perform checked bitwise XOR, returning a CtOption which is_some always

impl BoxedUint

pub fn bit(&self, index: u32) -> Choice

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

pub const fn bit_vartime(&self, index: u32) -> bool

Returns true if the bit at position index is set, false otherwise.

Remarks

This operation is variable time with respect to index only.

pub fn bits(&self) -> u32

Calculate the number of bits needed to represent this number, i.e. the index of the highest set bit.

Use BoxedUint::bits_precision to get the total capacity of this integer.

pub fn bits_vartime(&self) -> u32

Calculate the number of bits needed to represent this number in variable-time with respect to self.

pub const fn leading_zeros(&self) -> u32

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

pub fn bits_precision(&self) -> u32

Get the precision of this BoxedUint in bits.

pub fn trailing_zeros(&self) -> u32

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

pub fn trailing_ones(&self) -> u32

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

pub fn trailing_zeros_vartime(&self) -> u32

Calculate the number of trailing zeros in the binary representation of this number in variable-time with respect to self.

pub fn trailing_ones_vartime(&self) -> u32

Calculate the number of trailing ones in the binary representation of this number, variable time in self.

impl BoxedUint

pub fn cmp_vartime(&self, rhs: impl AsRef<UintRef>) -> Ordering

Returns the Ordering between self and rhs in variable time.

impl BoxedUint

pub fn div_rem_limb_with_reciprocal( &self, reciprocal: &Reciprocal, ) -> (BoxedUint, 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>) -> (BoxedUint, Limb)

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

pub fn rem_limb_with_reciprocal(&self, reciprocal: &Reciprocal) -> Limb

Computes self % rhs using a pre-made reciprocal.

pub fn rem_limb(&self, rhs: NonZero<Limb>) -> Limb

Computes self % rhs.

pub fn div_rem<Rhs>( &self, rhs: &NonZero<Rhs>, ) -> (BoxedUint, <Rhs as ToUnsigned>::Unsigned)

where Rhs: ToUnsigned + ?Sized,

Computes self / rhs, returns the quotient, remainder.

pub fn rem<Rhs>(&self, rhs: &NonZero<Rhs>) -> <Rhs as ToUnsigned>::Unsigned

where Rhs: ToUnsigned + ?Sized,

Computes self % rhs, returns the remainder.

pub fn div_rem_vartime<Rhs>( &self, rhs: &NonZero<Rhs>, ) -> (BoxedUint, <Rhs as ToUnsigned>::Unsigned)

where Rhs: ToUnsigned + ?Sized,

Computes self / rhs, returns the quotient and remainder.

Variable-time with respect to rhs

pub fn rem_vartime<Rhs>( &self, rhs: &NonZero<Rhs>, ) -> <Rhs as ToUnsigned>::Unsigned

where Rhs: ToUnsigned + ?Sized,

Computes self % rhs, returns the remainder.

Variable-time with respect to rhs.

pub fn wrapping_div<Rhs>(&self, rhs: &NonZero<Rhs>) -> BoxedUint

where Rhs: ToUnsigned + ?Sized,

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 wrapping_div_vartime<Rhs>(&self, rhs: &NonZero<Rhs>) -> BoxedUint

where Rhs: ToUnsigned + ?Sized,

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

pub fn checked_div(&self, rhs: impl AsRef<UintRef>) -> CtOption<BoxedUint>

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

impl BoxedUint

pub fn from_be_slice( bytes: &[u8], bits_precision: u32, ) -> Result<BoxedUint, DecodeError>

Create a new BoxedUint from the provided big endian bytes.

The bits_precision argument represents the precision of the resulting integer, which is fixed as this type is not arbitrary-precision.

The new BoxedUint will be created with bits_precision rounded up to a multiple of Limb::BITS.

Errors

• Returns DecodeError::InputSize if the length of bytes is larger than bits_precision (rounded up to a multiple of 8).
• Returns DecodeError::Precision if the size of the decoded integer is larger than bits_precision.

pub fn from_be_slice_vartime(bytes: &[u8]) -> BoxedUint

Create a new BoxedUint from the provided big endian bytes, automatically selecting its precision based on the size of the input.

This method is variable-time with respect to all subsequent operations since it chooses the limb count based on the input size, and is therefore only suitable for public inputs.

When working with secret values, use BoxedUint::from_be_slice.

pub fn from_le_slice( bytes: &[u8], bits_precision: u32, ) -> Result<BoxedUint, DecodeError>

Create a new BoxedUint from the provided little endian bytes.

The bits_precision argument represents the precision of the resulting integer, which is fixed as this type is not arbitrary-precision.

The new BoxedUint will be created with bits_precision rounded up to a multiple of Limb::BITS.

Errors

• Returns DecodeError::InputSize if the length of bytes is larger than bits_precision (rounded up to a multiple of 8).
• Returns DecodeError::Precision if the size of the decoded integer is larger than bits_precision.

pub fn from_le_slice_vartime(bytes: &[u8]) -> BoxedUint

Create a new BoxedUint from the provided little endian bytes, automatically selecting its precision based on the size of the input.

This method is variable-time with respect to all subsequent operations since it chooses the limb count based on the input size, and is therefore only suitable for public inputs.

When working with secret values, use BoxedUint::from_le_slice.

pub fn to_be_bytes(&self) -> Box<[u8]>

Serialize this BoxedUint as big-endian.

pub fn to_be_bytes_trimmed_vartime(&self) -> Box<[u8]>

Serialize this BoxedUint as big-endian without leading zeroes.

pub fn to_le_bytes(&self) -> Box<[u8]>

Serialize this BoxedUint as little-endian.

pub fn to_le_bytes_trimmed_vartime(&self) -> Box<[u8]>

Serialize this BoxedUint as little-endian without trailing zeroes.

pub fn from_be_hex(hex: &str, bits_precision: u32) -> CtOption<BoxedUint>

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

Panics

• if hex string is not the expected size

pub fn from_str_radix_vartime( src: &str, radix: u32, ) -> Result<BoxedUint, DecodeError>

Create a new BoxedUint from a big-endian string in a given base.

The string may begin with a + character, and may use underscore characters to separate digits.

Errors

• Returns DecodeError::InvalidDigit if the input value contains non-digit characters or digits outside of the range 0..radix.

Panics

• if radix is not in the range from 2 to 36.

pub fn from_str_radix_with_precision_vartime( src: &str, radix: u32, bits_precision: u32, ) -> Result<BoxedUint, DecodeError>

Create a new BoxedUint from a big-endian string in a given base, with a given precision.

The string may begin with a + character, and may use underscore characters to separate digits.

The bits_precision argument represents the precision of the resulting integer, which is fixed as this type is not arbitrary-precision.

The new BoxedUint will be created with bits_precision rounded up to a multiple of Limb::BITS.

Errors

• Returns DecodeError::InputSize if the length of bytes is larger than bits_precision (rounded up to a multiple of 8).
• Returns DecodeError::InvalidDigit if the input value contains non-digit characters or digits are outside the range 0..radix.
• Returns DecodeError::Precision if the size of the decoded integer is larger than bits_precision.

Panics

• if radix is not in the range from 2 to 36.

pub fn to_string_radix_vartime(&self, radix: u32) -> String

Format a BoxedUint as a string in a given base.

Panics

• if radix is not in the range from 2 to 36.

impl BoxedUint

pub fn inv_odd_mod(&self, modulus: &Odd<BoxedUint>) -> CtOption<BoxedUint>

👎Deprecated since 0.7.0:

please use invert_odd_mod instead

Computes the multiplicative inverse of self mod modulus, where modulus is odd.

pub fn invert_odd_mod(&self, modulus: &Odd<BoxedUint>) -> CtOption<BoxedUint>

Computes the multiplicative inverse of self mod modulus, where modulus is odd.

pub fn invert_odd_mod_vartime( &self, modulus: &Odd<BoxedUint>, ) -> CtOption<BoxedUint>

Computes the multiplicative inverse of self mod modulus, where modulus is odd.

pub fn inv_mod2k_vartime(&self, k: u32) -> (BoxedUint, Choice)

👎Deprecated since 0.7.0:

please use invert_mod2k_vartime instead

Computes 1/self mod 2^k. This method is constant-time w.r.t. self but not k.

If the inverse does not exist (k > 0 and self is even, or k > bits_precision()), returns Choice::FALSE as the second element of the tuple, otherwise returns Choice::TRUE.

pub fn invert_mod2k_vartime(&self, k: u32) -> (BoxedUint, Choice)

Computes 1/self mod 2^k. This method is constant-time w.r.t. self but not k.

If the inverse does not exist (k > 0 and self is even, or k > bits_precision()), returns Choice::FALSE as the second element of the tuple, otherwise returns Choice::TRUE.

pub fn inv_mod2k(&self, k: u32) -> (BoxedUint, Choice)

👎Deprecated since 0.7.0:

please use invert_mod2k instead

Computes 1/self mod 2^k.

If the inverse does not exist (k > 0 and self is even, or k > bits_precision()), returns Choice::FALSE as the second element of the tuple, otherwise returns Choice::TRUE.

pub fn invert_mod2k(&self, k: u32) -> (BoxedUint, Choice)

Computes 1/self mod 2^k.

If the inverse does not exist (k > 0 and self is even, or k > bits_precision()), returns Choice::FALSE as the second element of the tuple, otherwise returns Choice::TRUE.

pub fn inv_mod(&self, modulus: &BoxedUint) -> CtOption<BoxedUint>

👎Deprecated since 0.7.0:

please use invert_mod instead

Computes the multiplicative inverse of self mod modulus

self and modulus must have the same number of limbs, or the function will panic

TODO: maybe some better documentation is needed

pub fn invert_mod(&self, modulus: &NonZero<BoxedUint>) -> CtOption<BoxedUint>

Computes the multiplicative inverse of self mod modulus

self and modulus must have the same number of limbs, or the function will panic

TODO: maybe some better documentation is needed

impl BoxedUint

pub fn mul(&self, rhs: impl AsRef<UintRef>) -> BoxedUint

👎Deprecated since 0.7.0:

please use concatenating_mul

Multiply self by rhs.

Returns a widened output with a limb count equal to the sums of the input limb counts.

pub fn wrapping_mul(&self, rhs: impl AsRef<UintRef>) -> BoxedUint

Perform wrapping multiplication, wrapping to the width of self.

pub fn checked_mul(&self, rhs: impl AsRef<UintRef>) -> CtOption<BoxedUint>

Multiply self by rhs, wrapping to the width of self. Returns CtOption::None if the result overflowed the precision of self.

pub fn saturating_mul(&self, rhs: impl AsRef<UintRef>) -> BoxedUint

Perform saturating multiplication, returning MAX on overflow.

pub fn square(&self) -> BoxedUint

👎Deprecated since 0.7.0:

please use concatenating_square

Multiply self by itself.

pub fn wrapping_square(&self) -> BoxedUint

Multiply self by itself, wrapping to the width of self.

pub fn checked_square(&self) -> CtOption<BoxedUint>

Multiply self by itself, wrapping to the width of self. Returns CtOption::None if the result overflowed the precision of self.

pub fn saturating_square(&self) -> BoxedUint

Perform saturating squaring, returning MAX on overflow.

impl BoxedUint

pub fn mul_mod(&self, rhs: &BoxedUint, p: &NonZero<BoxedUint>) -> BoxedUint

Computes self * rhs mod p for non-zero p.

pub fn mul_mod_special(&self, rhs: &BoxedUint, c: Limb) -> BoxedUint

Computes self * rhs mod p 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.

pub fn square_mod(&self, p: &NonZero<BoxedUint>) -> BoxedUint

Computes self * self mod p.

pub fn square_mod_vartime(&self, p: &NonZero<BoxedUint>) -> BoxedUint

Computes self * self mod p in variable time with respect to p.

impl BoxedUint

pub fn wrapping_neg(&self) -> BoxedUint

Perform wrapping negation.

impl BoxedUint

pub fn neg_mod(&self, p: &NonZero<BoxedUint>) -> BoxedUint

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

pub fn neg_mod_special(&self, c: Limb) -> BoxedUint

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

impl BoxedUint

pub fn checked_pow(&self, exp: impl AsRef<UintRef>) -> CtOption<BoxedUint>

Computes self^exp, returning a CtOption which is none in the case of overflow.

pub fn checked_pow_bounded_exp( &self, exp: impl AsRef<UintRef>, exp_bits: u32, ) -> CtOption<BoxedUint>

Computes self^exp, returning a CtOption which is none in the case of overflow.

NOTE: exp_bits may be leaked in the time pattern.

Panics

• if exp_bits exceeds the capacity of rhs

pub fn checked_pow_vartime( &self, exp: impl AsRef<UintRef>, ) -> CtOption<BoxedUint>

Computes self^exp, returning a CtOption which is none in the case of overflow.

This method is variable time in the exponent exp only.

pub fn saturating_pow(&self, exp: impl AsRef<UintRef>) -> BoxedUint

Computes self^exp, returning a Self::MAX in the case of overflow.

pub fn saturating_pow_bounded_exp( &self, exp: impl AsRef<UintRef>, exp_bits: u32, ) -> BoxedUint

Computes self^exp, returning a Self::MAX in the case of overflow.

NOTE: exp_bits may be leaked in the time pattern.

Panics

• if exp_bits exceeds the capacity of rhs

pub fn saturating_pow_vartime(&self, exp: impl AsRef<UintRef>) -> BoxedUint

Computes self^exp, returning a Self::MAX in the case of overflow.

This method is variable time in the exponent exp.

pub fn wrapping_pow(&self, exp: impl AsRef<UintRef>) -> BoxedUint

Computes self^exp, discarding overflow.

pub fn wrapping_pow_bounded_exp( &self, exp: impl AsRef<UintRef>, exp_bits: u32, ) -> BoxedUint

Computes self^exp, discarding overflow.

NOTE: exp_bits may be leaked in the time pattern.

Panics

• if exp_bits exceeds the capacity of rhs

pub fn wrapping_pow_vartime(&self, exp: impl AsRef<UintRef>) -> BoxedUint

Computes self^exp, discarding overflow.

This method is variable time in the exponent exp only.

impl BoxedUint

pub fn pow_mod(&self, rhs: &BoxedUint, p: &Odd<BoxedUint>) -> BoxedUint

Computes self ^ rhs mod p for odd p.

impl BoxedUint

pub fn shl(&self, shift: u32) -> BoxedUint

Computes self << shift.

Panics

• if shift >= self.bits_precision().

pub fn shl_assign(&mut self, shift: u32)

Computes self <<= shift.

Panics

• if shift >= self.bits_precision().

pub fn overflowing_shl(&self, shift: u32) -> CtOption<BoxedUint>

Computes self << shift.

Returns self and a truthy Choice if shift >= self.bits_precision(), or the result and a falsy Choice otherwise.

pub fn overflowing_shl_vartime(&self, shift: u32) -> Option<BoxedUint>

Computes self << shift in variable-time.

Returns None if shift >= self.bits_precision(), otherwise the shifted result.

pub fn overflowing_shl_assign(&mut self, shift: u32) -> Choice

Computes self <<= shift.

Returns a truthy Choice if shift >= self.bits_precision() or a falsy Choice otherwise.

pub fn overflowing_shl_assign_vartime(&mut self, shift: u32) -> bool

Computes self <<= shift in variable-time.

If shift >= self.bits_precision(), shifts self in place and returns false. Otherwise returns true and leaves self unmodified.

pub fn unbounded_shl(&self, shift: u32) -> BoxedUint

Computes self << shift in a panic-free manner, producing zero in the case of overflow.

pub fn unbounded_shl_assign(&mut self, shift: u32)

Computes self <<= shift in a panic-free manner, producing zero in the case of overflow.

pub fn unbounded_shl_vartime(&self, shift: u32) -> BoxedUint

Computes self << shift in variable-time in a panic-free manner, producing zero in the case of overflow.

pub fn unbounded_shl_assign_vartime(&mut self, shift: u32)

Computes self <<= shift in variable-time in a panic-free manner, producing zero in the case of overflow.

pub fn wrapping_shl(&self, shift: u32) -> BoxedUint

Computes self << shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

pub fn wrapping_shl_assign(&mut self, shift: u32)

Computes self <<= shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

pub fn wrapping_shl_vartime(&self, shift: u32) -> BoxedUint

Computes self << shift in variable-time in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

pub fn wrapping_shl_assign_vartime(&mut self, shift: u32)

Computes self <<= shift in variable-time in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

pub fn shl_vartime(&self, shift: u32) -> Option<BoxedUint>

Computes self << shift. Returns None if shift >= self.bits_precision().

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

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

impl BoxedUint

pub fn shr(&self, shift: u32) -> BoxedUint

Computes self >> shift.

Panics

• if shift >= self.bits_precision().

pub fn shr_assign(&mut self, shift: u32)

Computes self >>= shift.

Panics

• if shift >= self.bits_precision().

pub fn overflowing_shr(&self, shift: u32) -> CtOption<BoxedUint>

Computes self >> shift.

Returns self and a truthy Choice if shift >= self.bits_precision(), or the result and a falsy Choice otherwise.

pub fn overflowing_shr_vartime(&self, shift: u32) -> Option<BoxedUint>

Computes self >> shift in variable-time.

Returns None if shift >= self.bits_precision(), otherwise the shifted result.

pub fn overflowing_shr_assign(&mut self, shift: u32) -> Choice

Computes self >>= shift.

Returns a truthy Choice if shift >= self.bits_precision() or a falsy Choice otherwise.

pub fn overflowing_shr_assign_vartime(&mut self, shift: u32) -> bool

Computes self >>= shift in variable-time.

If shift >= self.bits_precision(), shifts self in place and returns false. Otherwise returns true and leaves self unmodified.

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

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

pub fn unbounded_shr(&self, shift: u32) -> BoxedUint

Computes self >> shift in a panic-free manner, producing zero in the case of overflow.

pub fn unbounded_shr_assign(&mut self, shift: u32)

Computes self >>= shift in a panic-free manner, producing zero in the case of overflow.

pub fn unbounded_shr_vartime(&self, shift: u32) -> BoxedUint

Computes self >> shift in variable-time in a panic-free manner, producing zero in the case of overflow.

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

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

pub fn unbounded_shr_assign_vartime(&mut self, shift: u32)

Computes self >>= shift in variable-time in a panic-free manner, producing zero in the case of overflow.

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

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

pub fn wrapping_shr(&self, shift: u32) -> BoxedUint

Computes self >> shift in a panic-free manner, reducing shift modulo the type’s width.

pub fn wrapping_shr_assign(&mut self, shift: u32)

Computes self >>= shift in a panic-free manner, reducing shift modulo the type’s width.

pub fn wrapping_shr_vartime(&self, shift: u32) -> BoxedUint

Computes self >> shift in variable-time in a panic-free manner, reducing shift modulo the type’s width.

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

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

pub fn wrapping_shr_assign_vartime(&mut self, shift: u32)

Computes self >>= shift in variable-time in a panic-free manner, reducing shift modulo the type’s width.

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

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

pub fn shr_vartime(&self, shift: u32) -> Option<BoxedUint>

Computes self >> shift. Returns None if shift >= self.bits_precision().

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

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

impl BoxedUint

pub fn sqrt(&self) -> BoxedUint

👎Deprecated since 0.7.0:

please use floor_sqrt instead

Computes floor(√(self)) in constant time.

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

pub fn floor_sqrt(&self) -> BoxedUint

Computes √(self) in constant time.

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

pub fn sqrt_vartime(&self) -> BoxedUint

👎Deprecated since 0.7.0:

please use floor_sqrt_vartime instead

Computes floor(√(self)).

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

Variable time with respect to self.

pub fn floor_sqrt_vartime(&self) -> BoxedUint

Computes √(self).

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

Variable time with respect to self.

pub fn wrapping_sqrt(&self) -> BoxedUint

Wrapped sqrt is just floor(√(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 wrapping_sqrt_vartime(&self) -> BoxedUint

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

Variable time with respect to self.

pub fn checked_sqrt(&self) -> CtOption<BoxedUint>

Perform checked sqrt, returning a CtOption which is_some only if the square root is exact.

pub fn checked_sqrt_vartime(&self) -> Option<BoxedUint>

Perform checked sqrt, returning an Option which is_some only if the square root is exact.

Variable time with respect to self.

impl BoxedUint

pub fn sbb(&self, rhs: &BoxedUint, borrow: Limb) -> (BoxedUint, Limb)

👎Deprecated since 0.7.0:

please use borrowing_sub instead

Computes self - (rhs + borrow), returning the result along with the new borrow.

pub fn borrowing_sub( &self, rhs: impl AsRef<UintRef>, borrow: Limb, ) -> (BoxedUint, Limb)

Computes self - (rhs + borrow), returning the result along with the new borrow.

The result is widened to the same width as the widest input.

pub fn sbb_assign(&mut self, rhs: impl AsRef<[Limb]>, borrow: Limb) -> Limb

👎Deprecated since 0.7.0:

please use borrowing_sub_assign instead

Computes a - (b + borrow) in-place, returning the new borrow.

Panics

• if rhs has a larger precision than self.

pub fn underflowing_sub(&self, rhs: impl AsRef<UintRef>) -> (BoxedUint, Choice)

Computes self - rhs, returning a tuple of the difference along with a Choice which indicates whether an underflow occurred.

If an underflow occurred, then the wrapped value is returned.

pub fn underflowing_sub_assign(&mut self, rhs: impl AsRef<UintRef>) -> Choice

Subtracts rhs from self, returning a Choice which indicates whether an underflow occurred.

If an underflow occurred, then the wrapped value is returned.

pub fn wrapping_sub(&self, rhs: impl AsRef<UintRef>) -> BoxedUint

Perform wrapping subtraction, discarding underflow.

pub fn wrapping_sub_assign(&mut self, rhs: impl AsRef<UintRef>)

Perform wrapping subtraction of rhs from self, discarding underflow.

impl BoxedUint

pub fn sub_mod(&self, rhs: &BoxedUint, p: &NonZero<BoxedUint>) -> BoxedUint

Computes self - rhs mod p.

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

pub fn sub_mod_special(&self, rhs: &BoxedUint, c: Limb) -> BoxedUint

Computes self - rhs mod p 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 BoxedUint

pub fn zero() -> BoxedUint

Get the value 0 represented as succinctly as possible.

pub fn zero_with_precision(at_least_bits_precision: u32) -> BoxedUint

Get the value 0 with the given number of bits of precision.

at_least_bits_precision is rounded up to a multiple of Limb::BITS.

pub fn one() -> BoxedUint

Get the value 1, represented as succinctly as possible.

pub fn one_with_precision(at_least_bits_precision: u32) -> BoxedUint

Get the value 1 with the given number of bits of precision.

at_least_bits_precision is rounded up to a multiple of Limb::BITS.

pub fn is_zero(&self) -> Choice

Is this BoxedUint equal to zero?

pub fn is_nonzero(&self) -> Choice

Is this BoxedUint NOT equal to zero?

pub fn is_one(&self) -> Choice

Is this BoxedUint equal to one?

pub fn max(at_least_bits_precision: u32) -> BoxedUint

Get the maximum value for a BoxedUint created with at_least_bits_precision precision bits requested.

That is, returns the value 2^self.bits_precision() - 1.

pub fn from_words(words: impl IntoIterator<Item = u64>) -> BoxedUint

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

pub fn from_words_with_precision( words: impl IntoIterator<Item = u64>, at_least_bits_precision: u32, ) -> BoxedUint

Create a BoxedUint from an array of Words (i.e. word-sized unsigned integers), specifying the precision of the result. Any words above the given precision will be dropped.

pub fn to_words(&self) -> Box<[u64]>

Create a boxed slice of Words (i.e. word-sized unsigned integers) from a BoxedUint.

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

Borrow the inner limbs as a slice of Words.

pub fn as_mut_words(&mut self) -> &mut [u64]

Borrow the inner limbs as a mutable slice of Words.

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

👎Deprecated since 0.7.0:

please use as_mut_words instead

Borrow the inner limbs as a mutable slice of Words.

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

Borrow the limbs of this BoxedUint.

pub fn as_mut_limbs(&mut self) -> &mut [Limb]

Borrow the limbs of this BoxedUint mutably.

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

👎Deprecated since 0.7.0:

please use as_mut_limbs instead

Borrow the limbs of this BoxedUint mutably.

pub fn to_limbs(&self) -> Box<[Limb]>

Convert this BoxedUint into its inner limbs.

pub fn into_limbs(self) -> Box<[Limb]>

Convert this BoxedUint into its inner limbs.

pub const fn as_uint_ref(&self) -> &UintRef

Borrow the limbs of this BoxedUint as a UintRef.

pub const fn as_mut_uint_ref(&mut self) -> &mut UintRef

Mutably borrow the limbs of this BoxedUint as a UintRef.

pub fn nlimbs(&self) -> usize

Get the number of limbs in this BoxedUint.

pub fn to_nz(&self) -> CtOption<NonZero<BoxedUint>>

Convert to a NonZero<BoxedUint>.

Returns some if the original value is non-zero, and false otherwise.

pub fn to_odd(&self) -> CtOption<Odd<BoxedUint>>

Convert to an Odd<BoxedUint>.

Returns some if the original value is odd, and false otherwise.

pub fn into_nz(self) -> CtOption<NonZero<BoxedUint>>

Convert to a NonZero<BoxedUint>.

Returns some if the original value is non-zero, and false otherwise.

pub fn into_odd(self) -> CtOption<Odd<BoxedUint>>

Convert to an Odd<BoxedUint>.

Returns some if the original value is odd, and false otherwise.

pub fn widen(&self, at_least_bits_precision: u32) -> BoxedUint

👎Deprecated since 0.7.0:

please use resize instead

Widen this type’s precision to the given number of bits.

Panics

• if at_least_bits_precision is smaller than the current precision.

pub fn shorten(&self, at_least_bits_precision: u32) -> BoxedUint

👎Deprecated since 0.7.0:

please use resize instead

Shortens this type’s precision to the given number of bits.

Panics

• if at_least_bits_precision is larger than the current precision.

Trait Implementations

impl<Rhs> Add<Rhs> for &BoxedUint

where Rhs: AsRef<UintRef>,

type Output = BoxedUint

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> BoxedUint

Performs the + operation.

impl<Rhs> Add<Rhs> for BoxedUint

where Rhs: AsRef<UintRef>,

type Output = BoxedUint

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> BoxedUint

Performs the + operation.

impl Add<u128> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> BoxedUint

Performs the + operation.

impl Add<u128> for BoxedUint

type Output = BoxedUint

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> BoxedUint

Performs the + operation.

impl Add<u16> for &BoxedUint

type Output = <&BoxedUint as Add<Uint<crypto_bigint::::uint::U64::{constant#0}>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> <&BoxedUint as Add<u16>>::Output

Performs the + operation.

impl Add<u16> for BoxedUint

type Output = <BoxedUint as Add<Uint<crypto_bigint::::uint::U64::{constant#0}>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> <BoxedUint as Add<u16>>::Output

Performs the + operation.

impl Add<u32> for &BoxedUint

type Output = <&BoxedUint as Add<Uint<crypto_bigint::::uint::U64::{constant#0}>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> <&BoxedUint as Add<u32>>::Output

Performs the + operation.

impl Add<u32> for BoxedUint

type Output = <BoxedUint as Add<Uint<crypto_bigint::::uint::U64::{constant#0}>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> <BoxedUint as Add<u32>>::Output

Performs the + operation.

impl Add<u64> for &BoxedUint

type Output = <&BoxedUint as Add<Uint<crypto_bigint::::uint::U64::{constant#0}>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> <&BoxedUint as Add<u64>>::Output

Performs the + operation.

impl Add<u64> for BoxedUint

type Output = <BoxedUint as Add<Uint<crypto_bigint::::uint::U64::{constant#0}>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> <BoxedUint as Add<u64>>::Output

Performs the + operation.

impl Add<u8> for &BoxedUint

type Output = <&BoxedUint as Add<Uint<crypto_bigint::::uint::U64::{constant#0}>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> <&BoxedUint as Add<u8>>::Output

Performs the + operation.

impl Add<u8> for BoxedUint

type Output = <BoxedUint as Add<Uint<crypto_bigint::::uint::U64::{constant#0}>>>::Output

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> <BoxedUint as Add<u8>>::Output

Performs the + operation.

impl<Rhs> AddAssign<Rhs> for BoxedUint

where Rhs: AsRef<UintRef>,

fn add_assign(&mut self, rhs: Rhs)

Performs the += operation.

impl AddAssign<u128> for BoxedUint

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl AddAssign<u16> for BoxedUint

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl AddAssign<u32> for BoxedUint

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AddAssign<u64> for BoxedUint

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl AddAssign<u8> for BoxedUint

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl AddMod for BoxedUint

type Output = BoxedUint

Output type.

fn add_mod(&self, rhs: &BoxedUint, p: &NonZero<BoxedUint>) -> BoxedUint

Compute self + rhs mod p.

impl AsMut<[Limb]> for BoxedUint

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

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

impl AsMut<[u64]> for BoxedUint

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

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

impl AsMut<UintRef> for BoxedUint

fn as_mut(&mut self) -> &mut UintRef

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

impl AsRef<[Limb]> for BoxedUint

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

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

impl AsRef<[u64]> for BoxedUint

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

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

impl AsRef<UintRef> for BoxedUint

fn as_ref(&self) -> &UintRef

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

impl Binary for BoxedUint

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

Formats the value using the given formatter.

impl BitAnd<&BoxedUint> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the & operator.

fn bitand(self, rhs: &BoxedUint) -> BoxedUint

Performs the & operation.

impl BitAnd<&BoxedUint> for BoxedUint

type Output = BoxedUint

The resulting type after applying the & operator.

fn bitand(self, rhs: &BoxedUint) -> BoxedUint

Performs the & operation.

impl BitAnd<BoxedUint> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the & operator.

fn bitand(self, rhs: BoxedUint) -> BoxedUint

Performs the & operation.

impl BitAnd for BoxedUint

type Output = BoxedUint

The resulting type after applying the & operator.

fn bitand(self, rhs: BoxedUint) -> BoxedUint

Performs the & operation.

impl BitAndAssign<&BoxedUint> for BoxedUint

fn bitand_assign(&mut self, other: &BoxedUint)

Performs the &= operation.

impl BitAndAssign for BoxedUint

fn bitand_assign(&mut self, other: BoxedUint)

Performs the &= operation.

impl BitOps for BoxedUint

fn bits_precision(&self) -> u32

Precision of this integer in bits.

fn bytes_precision(&self) -> usize

Precision of this integer in bytes.

fn leading_zeros(&self) -> u32

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

fn bits(&self) -> u32

Calculate the number of bits required to represent a given number.

fn bit(&self, index: u32) -> Choice

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

fn set_bit(&mut self, index: u32, bit_value: Choice)

Sets the bit at index to 0 or 1 depending on the value of bit_value.

fn trailing_zeros(&self) -> u32

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

fn trailing_ones(&self) -> u32

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

fn bit_vartime(&self, index: u32) -> bool

Returns true if the bit at position index is set, false otherwise.

fn bits_vartime(&self) -> u32

Calculate the number of bits required to represent a given number in variable-time with respect to self.

fn set_bit_vartime(&mut self, index: u32, bit_value: bool)

Sets the bit at index to 0 or 1 depending on the value of bit_value, variable time in self.

fn trailing_zeros_vartime(&self) -> u32

Calculate the number of trailing zeros in the binary representation of this number in variable-time with respect to self.

fn trailing_ones_vartime(&self) -> u32

Calculate the number of trailing ones in the binary representation of this number, variable time in self.

fn log2_bits(&self) -> u32

floor(log2(self.bits_precision())).

fn leading_zeros_vartime(&self) -> u32

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

impl BitOr<&BoxedUint> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the | operator.

fn bitor(self, rhs: &BoxedUint) -> BoxedUint

Performs the | operation.

impl BitOr<&BoxedUint> for BoxedUint

type Output = BoxedUint

The resulting type after applying the | operator.

fn bitor(self, rhs: &BoxedUint) -> BoxedUint

Performs the | operation.

impl BitOr<BoxedUint> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the | operator.

fn bitor(self, rhs: BoxedUint) -> BoxedUint

Performs the | operation.

impl BitOr for BoxedUint

type Output = BoxedUint

The resulting type after applying the | operator.

fn bitor(self, rhs: BoxedUint) -> BoxedUint

Performs the | operation.

impl BitOrAssign<&BoxedUint> for BoxedUint

fn bitor_assign(&mut self, other: &BoxedUint)

Performs the |= operation.

impl BitOrAssign for BoxedUint

fn bitor_assign(&mut self, other: BoxedUint)

Performs the |= operation.

impl BitXor<&BoxedUint> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &BoxedUint) -> BoxedUint

Performs the ^ operation.

impl BitXor<&BoxedUint> for BoxedUint

type Output = BoxedUint

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &BoxedUint) -> BoxedUint

Performs the ^ operation.

impl BitXor<BoxedUint> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BoxedUint) -> BoxedUint

Performs the ^ operation.

impl BitXor for BoxedUint

type Output = BoxedUint

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: BoxedUint) -> BoxedUint

Performs the ^ operation.

impl BitXorAssign<&BoxedUint> for BoxedUint

fn bitxor_assign(&mut self, other: &BoxedUint)

Performs the ^= operation.

impl BitXorAssign for BoxedUint

fn bitxor_assign(&mut self, other: BoxedUint)

Performs the ^= operation.

impl Borrow<UintRef> for BoxedUint

fn borrow(&self) -> &UintRef

Immutably borrows from an owned value.

impl BorrowMut<UintRef> for BoxedUint

fn borrow_mut(&mut self) -> &mut UintRef

Mutably borrows from an owned value.

impl<Rhs> CheckedAdd<Rhs> for BoxedUint

where Rhs: AsRef<UintRef>,

fn checked_add(&self, rhs: &Rhs) -> CtOption<BoxedUint>

Perform checked addition, returning a CtOption which is_some only if the operation did not overflow.

impl<Rhs> CheckedDiv<Rhs> for BoxedUint

where Rhs: AsRef<UintRef>,

fn checked_div(&self, rhs: &Rhs) -> CtOption<BoxedUint>

Perform checked division, returning a CtOption which is_some only if the divisor is non-zero.

impl<Rhs> CheckedMul<Rhs> for BoxedUint

where Rhs: AsRef<UintRef>,

fn checked_mul(&self, rhs: &Rhs) -> CtOption<BoxedUint>

Perform checked multiplication, returning a CtOption which is_some only if the operation did not overflow.

impl CheckedSquareRoot for BoxedUint

type Output = BoxedUint

Output of the square root operation.

fn checked_sqrt(&self) -> CtOption<<BoxedUint as CheckedSquareRoot>::Output>

Computes sqrt(self), returning none if no root exists.

fn checked_sqrt_vartime( &self, ) -> Option<<BoxedUint as CheckedSquareRoot>::Output>

Computes sqrt(self), returning none if no root exists.

impl<Rhs> CheckedSub<Rhs> for BoxedUint

where Rhs: AsRef<UintRef>,

fn checked_sub(&self, rhs: &Rhs) -> CtOption<BoxedUint>

Perform checked subtraction, returning a CtOption which is_some only if the operation did not underflow.

impl Clone for BoxedUint

fn clone(&self) -> BoxedUint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Rhs> ConcatenatingMul<Rhs> for BoxedUint

where Rhs: AsRef<UintRef>,

type Output = BoxedUint

Output of the widening multiplication.

fn concatenating_mul(&self, rhs: Rhs) -> BoxedUint

Perform widening multiplication.

impl ConcatenatingSquare for BoxedUint

type Output = BoxedUint

Output of the widening multiplication.

fn concatenating_square(&self) -> BoxedUint

Perform widening squaring.

impl CtAssign for BoxedUint

fn ct_assign(&mut self, other: &BoxedUint, choice: Choice)

Conditionally assign src to self if choice is Choice::TRUE.

impl CtAssignSlice for BoxedUint

fn ct_assign_slice(dst: &mut [Self], src: &[Self], choice: Choice)

Conditionally assign src to dst if choice is Choice::TRUE, or leave it unchanged for Choice::FALSE.

impl<Rhs> CtEq<Rhs> for BoxedUint

where Rhs: AsRef<UintRef> + ?Sized,

fn ct_eq(&self, other: &Rhs) -> Choice

Determine if self is equal to other in constant-time.

fn ct_ne(&self, other: &Rhs) -> Choice

Determine if self is NOT equal to other in constant-time.

impl CtEqSlice for BoxedUint

fn ct_eq_slice(a: &[Self], b: &[Self]) -> Choice

Determine if a is equal to b in constant-time.

fn ct_ne_slice(a: &[Self], b: &[Self]) -> Choice

Determine if a is NOT equal to b in constant-time.

impl CtGt for BoxedUint

fn ct_gt(&self, other: &BoxedUint) -> Choice

Compute whether self > other in constant time.

impl CtLt for BoxedUint

fn ct_lt(&self, other: &BoxedUint) -> Choice

Compute whether self < other in constant time.

impl CtNeg for BoxedUint

fn ct_neg(&self, choice: Choice) -> BoxedUint

Conditionally negate self, returning -self if choice is Choice::TRUE, or self otherwise.

fn ct_neg_assign(&mut self, choice: Choice)

Conditionally negate self in-place, replacing it with -self if choice is Choice::TRUE.

impl CtSelect for BoxedUint

fn ct_select(&self, other: &BoxedUint, choice: Choice) -> BoxedUint

Select between self and other based on choice, returning a copy of the value.

fn ct_swap(&mut self, other: &mut BoxedUint, choice: Choice)

Conditionally swap self and other if choice is Choice::TRUE.

impl Debug for BoxedUint

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

Formats the value using the given formatter.

impl Default for BoxedUint

fn default() -> BoxedUint

Returns the “default value” for a type.

impl Display for BoxedUint

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

Formats the value using the given formatter.

impl<Rhs> Div<&NonZero<Rhs>> for &BoxedUint

where Rhs: ToUnsigned + ?Sized,

type Output = BoxedUint

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<Rhs>) -> <&BoxedUint as Div<&NonZero<Rhs>>>::Output

Performs the / operation.

impl<Rhs> Div<&NonZero<Rhs>> for BoxedUint

where Rhs: ToUnsigned + ?Sized,

type Output = BoxedUint

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<Rhs>) -> <BoxedUint as Div<&NonZero<Rhs>>>::Output

Performs the / operation.

impl<Rhs> Div<NonZero<Rhs>> for &BoxedUint

where Rhs: AsMut<UintRef>,

type Output = BoxedUint

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Rhs>) -> <&BoxedUint as Div<NonZero<Rhs>>>::Output

Performs the / operation.

impl<Rhs> Div<NonZero<Rhs>> for BoxedUint

where Rhs: AsMut<UintRef>,

type Output = BoxedUint

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Rhs>) -> <BoxedUint as Div<NonZero<Rhs>>>::Output

Performs the / operation.

impl<Rhs> DivAssign<&NonZero<Rhs>> for BoxedUint

where Rhs: ToUnsigned + ?Sized,

fn div_assign(&mut self, rhs: &NonZero<Rhs>)

Performs the /= operation.

impl<Rhs> DivAssign<NonZero<Rhs>> for BoxedUint

where Rhs: AsMut<UintRef>,

fn div_assign(&mut self, rhs: NonZero<Rhs>)

Performs the /= operation.

impl DivRemLimb for BoxedUint

fn div_rem_limb_with_reciprocal( &self, reciprocal: &Reciprocal, ) -> (BoxedUint, Limb)

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

fn div_rem_limb(&self, rhs: NonZero<Limb>) -> (Self, Limb)

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

impl DivVartime for BoxedUint

fn div_vartime(&self, rhs: &NonZero<BoxedUint>) -> BoxedUint

Computes self / rhs in variable time.

impl Encoding for BoxedUint

type Repr = Box<[u8]>

Byte array representation.

fn to_be_bytes(&self) -> <BoxedUint as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes(&self) -> <BoxedUint as Encoding>::Repr

Encode to little endian bytes.

fn from_be_bytes(bytes: <BoxedUint as Encoding>::Repr) -> BoxedUint

Decode from big endian bytes.

fn from_le_bytes(bytes: <BoxedUint as Encoding>::Repr) -> BoxedUint

Decode from little endian bytes.

impl FloorSquareRoot for BoxedUint

fn floor_sqrt(&self) -> BoxedUint

Computes floor(sqrt(self)).

fn floor_sqrt_vartime(&self) -> BoxedUint

Computes floor(sqrt(self)).

impl From<&[Limb]> for BoxedUint

fn from(limbs: &[Limb]) -> BoxedUint

Converts to this type from the input type.

impl From<&BoxedUint> for Mpint

Available on crate feature alloc only.

fn from(uint: &Uint) -> Mpint

Converts to this type from the input type.

impl<const LIMBS: usize> From<&Odd<Uint<LIMBS>>> for BoxedUint

fn from(uint: &Odd<Uint<LIMBS>>) -> BoxedUint

Converts to this type from the input type.

impl<const LIMBS: usize> From<&Uint<LIMBS>> for BoxedUint

fn from(uint: &Uint<LIMBS>) -> BoxedUint

Converts to this type from the input type.

impl From<&UintRef> for BoxedUint

fn from(uint_ref: &UintRef) -> BoxedUint

Converts to this type from the input type.

impl From<Box<[Limb]>> for BoxedUint

fn from(limbs: Box<[Limb]>) -> BoxedUint

Converts to this type from the input type.

impl From<BoxedUint> for Mpint

Available on crate feature alloc only.

fn from(uint: Uint) -> Mpint

Converts to this type from the input type.

impl From<Limb> for BoxedUint

fn from(limb: Limb) -> BoxedUint

Converts to this type from the input type.

impl<const LIMBS: usize> From<Odd<Uint<LIMBS>>> for BoxedUint

fn from(uint: Odd<Uint<LIMBS>>) -> BoxedUint

Converts to this type from the input type.

impl<const LIMBS: usize> From<Uint<LIMBS>> for BoxedUint

fn from(uint: Uint<LIMBS>) -> BoxedUint

Converts to this type from the input type.

impl From<Vec<Limb>> for BoxedUint

fn from(limbs: Vec<Limb>) -> BoxedUint

Converts to this type from the input type.

impl From<Vec<u64>> for BoxedUint

fn from(words: Vec<u64>) -> BoxedUint

Converts to this type from the input type.

impl From<u128> for BoxedUint

fn from(n: u128) -> BoxedUint

Converts to this type from the input type.

impl From<u16> for BoxedUint

fn from(n: u16) -> BoxedUint

Converts to this type from the input type.

impl From<u32> for BoxedUint

fn from(n: u32) -> BoxedUint

Converts to this type from the input type.

impl From<u64> for BoxedUint

fn from(n: u64) -> BoxedUint

Converts to this type from the input type.

impl From<u8> for BoxedUint

fn from(n: u8) -> BoxedUint

Converts to this type from the input type.

impl Gcd for BoxedUint

fn gcd(&self, rhs: &BoxedUint) -> BoxedUint

Compute the greatest common divisor (GCD) of this number and another.

type Output = BoxedUint

Output type.

fn gcd_vartime(&self, rhs: &BoxedUint) -> <BoxedUint as Gcd>::Output

Compute the greatest common divisor of self and rhs in variable time.

impl Integer for BoxedUint

fn as_limbs(&self) -> &[Limb]

Borrow the raw limbs used to represent this integer.

fn as_mut_limbs(&mut self) -> &mut [Limb]

Mutably borrow the raw limbs used to represent this integer.

fn nlimbs(&self) -> usize

Number of limbs in this integer.

fn is_odd(&self) -> Choice

Is this integer value an odd number?

fn is_even(&self) -> Choice

Is this integer value an even number?

impl InvertMod for BoxedUint

type Output = BoxedUint

Output type.

fn invert_mod(&self, modulus: &NonZero<BoxedUint>) -> CtOption<BoxedUint>

Compute 1 / self mod p.

impl LowerHex for BoxedUint

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

Formats the value using the given formatter.

impl<Rhs> Mul<Rhs> for &BoxedUint

where Rhs: AsRef<UintRef>,

type Output = BoxedUint

The resulting type after applying the * operator.

fn mul(self, rhs: Rhs) -> <&BoxedUint as Mul<Rhs>>::Output

Performs the * operation.

impl<Rhs> Mul<Rhs> for BoxedUint

where Rhs: AsRef<UintRef>,

type Output = BoxedUint

The resulting type after applying the * operator.

fn mul(self, rhs: Rhs) -> BoxedUint

Performs the * operation.

impl<Rhs> MulAssign<Rhs> for BoxedUint

where Rhs: AsRef<UintRef>,

fn mul_assign(&mut self, rhs: Rhs)

Performs the *= operation.

impl MulMod for BoxedUint

type Output = BoxedUint

Output type.

fn mul_mod(&self, rhs: &BoxedUint, p: &NonZero<BoxedUint>) -> BoxedUint

Compute self * rhs mod p.

impl NegMod for BoxedUint

type Output = BoxedUint

Output type.

fn neg_mod(&self, p: &NonZero<BoxedUint>) -> BoxedUint

Compute -self mod p.

impl Not for BoxedUint

type Output = BoxedUint

The resulting type after applying the ! operator.

fn not(self) -> BoxedUint

Performs the unary ! operation.

impl One for BoxedUint

fn one() -> BoxedUint

Returns the multiplicative identity element of Self, 1.

fn one_like(other: &BoxedUint) -> BoxedUint

Return the value 0 with the same precision as other.

fn is_one(&self) -> Choice

Determine if this value is equal to 1.

fn set_one(&mut self)

Set self to its multiplicative identity, i.e. Self::one.

impl One for BoxedUint

fn one() -> BoxedUint

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl Ord for BoxedUint

fn cmp(&self, other: &BoxedUint) -> 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 PartialEq<Odd<BoxedUint>> for BoxedUint

Available on crate feature alloc only.

fn eq(&self, other: &Odd<BoxedUint>) -> 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<Rhs> PartialEq<Rhs> for BoxedUint

where Rhs: AsRef<UintRef> + ?Sized,

fn eq(&self, other: &Rhs) -> 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 PartialOrd<Odd<BoxedUint>> for BoxedUint

Available on crate feature alloc only.

fn partial_cmp(&self, other: &Odd<BoxedUint>) -> 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<Rhs> PartialOrd<Rhs> for BoxedUint

where Rhs: AsRef<UintRef> + ?Sized,

fn partial_cmp(&self, other: &Rhs) -> 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<Rhs> Rem<&NonZero<Rhs>> for &BoxedUint

where Rhs: ToUnsigned + ?Sized,

type Output = <Rhs as ToUnsigned>::Unsigned

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<Rhs>) -> <&BoxedUint as Rem<&NonZero<Rhs>>>::Output

Performs the % operation.

impl<Rhs> Rem<&NonZero<Rhs>> for BoxedUint

where Rhs: ToUnsigned + ?Sized,

type Output = <Rhs as ToUnsigned>::Unsigned

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<Rhs>) -> <BoxedUint as Rem<&NonZero<Rhs>>>::Output

Performs the % operation.

impl<Rhs> Rem<NonZero<Rhs>> for &BoxedUint

where Rhs: AsMut<UintRef>,

type Output = Rhs

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Rhs>) -> <&BoxedUint as Rem<NonZero<Rhs>>>::Output

Performs the % operation.

impl<Rhs> Rem<NonZero<Rhs>> for BoxedUint

where Rhs: AsMut<UintRef>,

type Output = Rhs

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Rhs>) -> <BoxedUint as Rem<NonZero<Rhs>>>::Output

Performs the % operation.

impl<Rhs> RemAssign<&NonZero<Rhs>> for BoxedUint

where Rhs: AsRef<UintRef> + ?Sized,

fn rem_assign(&mut self, rhs: &NonZero<Rhs>)

Performs the %= operation.

impl<Rhs> RemAssign<NonZero<Rhs>> for BoxedUint

where Rhs: AsRef<UintRef>,

fn rem_assign(&mut self, rhs: NonZero<Rhs>)

Performs the %= operation.

impl RemLimb for BoxedUint

fn rem_limb_with_reciprocal(&self, reciprocal: &Reciprocal) -> Limb

Computes self % rhs.

fn rem_limb(&self, rhs: NonZero<Limb>) -> Limb

Computes self % rhs using a pre-made reciprocal.

impl<Rhs> RemMixed<Rhs> for BoxedUint

where Rhs: Unsigned,

fn rem_mixed(&self, reductor: &NonZero<Rhs>) -> Rhs

Calculate the remainder of self by the reductor.

impl Resize for &BoxedUint

type Output = BoxedUint

The result of the resizing.

fn resize_unchecked( self, at_least_bits_precision: u32, ) -> <&BoxedUint as Resize>::Output

Resizes to the minimum storage that fits at_least_bits_precision without checking if the bit size of self is larger than at_least_bits_precision.

fn try_resize(self, at_least_bits_precision: u32) -> Option<BoxedUint>

Resizes to the minimum storage that fits at_least_bits_precision returning None if the bit size of self is larger than at_least_bits_precision.

fn resize(self, at_least_bits_precision: u32) -> Self::Output

Resizes to the minimum storage that fits at_least_bits_precision panicking if the bit size of self is larger than at_least_bits_precision.

impl Resize for BoxedUint

type Output = BoxedUint

The result of the resizing.

fn resize_unchecked( self, at_least_bits_precision: u32, ) -> <BoxedUint as Resize>::Output

Resizes to the minimum storage that fits at_least_bits_precision without checking if the bit size of self is larger than at_least_bits_precision.

fn try_resize(self, at_least_bits_precision: u32) -> Option<BoxedUint>

Resizes to the minimum storage that fits at_least_bits_precision returning None if the bit size of self is larger than at_least_bits_precision.

fn resize(self, at_least_bits_precision: u32) -> Self::Output

Resizes to the minimum storage that fits at_least_bits_precision panicking if the bit size of self is larger than at_least_bits_precision.

impl Shl<i32> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the << operator.

fn shl(self, shift: i32) -> BoxedUint

Performs the << operation.

impl Shl<i32> for BoxedUint

type Output = BoxedUint

The resulting type after applying the << operator.

fn shl(self, shift: i32) -> BoxedUint

Performs the << operation.

impl Shl<u32> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the << operator.

fn shl(self, shift: u32) -> BoxedUint

Performs the << operation.

impl Shl<u32> for BoxedUint

type Output = BoxedUint

The resulting type after applying the << operator.

fn shl(self, shift: u32) -> BoxedUint

Performs the << operation.

impl Shl<usize> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the << operator.

fn shl(self, shift: usize) -> BoxedUint

Performs the << operation.

impl Shl<usize> for BoxedUint

type Output = BoxedUint

The resulting type after applying the << operator.

fn shl(self, shift: usize) -> BoxedUint

Performs the << operation.

impl ShlAssign<i32> for BoxedUint

fn shl_assign(&mut self, shift: i32)

Performs the <<= operation.

impl ShlAssign<u32> for BoxedUint

fn shl_assign(&mut self, shift: u32)

Performs the <<= operation.

impl ShlAssign<usize> for BoxedUint

fn shl_assign(&mut self, shift: usize)

Performs the <<= operation.

impl ShlVartime for BoxedUint

fn overflowing_shl_vartime(&self, shift: u32) -> Option<BoxedUint>

Computes self << shift.

fn unbounded_shl_vartime(&self, shift: u32) -> BoxedUint

Computes self << shift.

fn wrapping_shl_vartime(&self, shift: u32) -> BoxedUint

Computes self << shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

impl Shr<i32> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the >> operator.

fn shr(self, shift: i32) -> BoxedUint

Performs the >> operation.

impl Shr<i32> for BoxedUint

type Output = BoxedUint

The resulting type after applying the >> operator.

fn shr(self, shift: i32) -> BoxedUint

Performs the >> operation.

impl Shr<u32> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the >> operator.

fn shr(self, shift: u32) -> BoxedUint

Performs the >> operation.

impl Shr<u32> for BoxedUint

type Output = BoxedUint

The resulting type after applying the >> operator.

fn shr(self, shift: u32) -> BoxedUint

Performs the >> operation.

impl Shr<usize> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the >> operator.

fn shr(self, shift: usize) -> BoxedUint

Performs the >> operation.

impl Shr<usize> for BoxedUint

type Output = BoxedUint

The resulting type after applying the >> operator.

fn shr(self, shift: usize) -> BoxedUint

Performs the >> operation.

impl ShrAssign<i32> for BoxedUint

fn shr_assign(&mut self, shift: i32)

Performs the >>= operation.

impl ShrAssign<u32> for BoxedUint

fn shr_assign(&mut self, shift: u32)

Performs the >>= operation.

impl ShrAssign<usize> for BoxedUint

fn shr_assign(&mut self, shift: usize)

Performs the >>= operation.

impl ShrVartime for BoxedUint

fn overflowing_shr_vartime(&self, shift: u32) -> Option<BoxedUint>

Computes self >> shift.

fn unbounded_shr_vartime(&self, shift: u32) -> BoxedUint

Computes self >> shift.

fn wrapping_shr_vartime(&self, shift: u32) -> BoxedUint

Computes self >> shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

impl SquareMod for BoxedUint

type Output = BoxedUint

Output type.

fn square_mod(&self, p: &NonZero<BoxedUint>) -> BoxedUint

Compute self * self mod p.

impl<Rhs> Sub<Rhs> for &BoxedUint

where Rhs: AsRef<UintRef>,

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: Rhs) -> BoxedUint

Performs the - operation.

impl<Rhs> Sub<Rhs> for BoxedUint

where Rhs: AsRef<UintRef>,

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: Rhs) -> BoxedUint

Performs the - operation.

impl Sub<u128> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> BoxedUint

Performs the - operation.

impl Sub<u128> for BoxedUint

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> BoxedUint

Performs the - operation.

impl Sub<u16> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> BoxedUint

Performs the - operation.

impl Sub<u16> for BoxedUint

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> BoxedUint

Performs the - operation.

impl Sub<u32> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> BoxedUint

Performs the - operation.

impl Sub<u32> for BoxedUint

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> BoxedUint

Performs the - operation.

impl Sub<u64> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> BoxedUint

Performs the - operation.

impl Sub<u64> for BoxedUint

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> BoxedUint

Performs the - operation.

impl Sub<u8> for &BoxedUint

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> BoxedUint

Performs the - operation.

impl Sub<u8> for BoxedUint

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> BoxedUint

Performs the - operation.

impl<Rhs> SubAssign<Rhs> for BoxedUint

where Rhs: AsRef<UintRef>,

fn sub_assign(&mut self, rhs: Rhs)

Performs the -= operation.

impl SubAssign<u128> for BoxedUint

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl SubAssign<u16> for BoxedUint

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl SubAssign<u32> for BoxedUint

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl SubAssign<u64> for BoxedUint

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl SubAssign<u8> for BoxedUint

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl SubMod for BoxedUint

type Output = BoxedUint

Output type.

fn sub_mod(&self, rhs: &BoxedUint, p: &NonZero<BoxedUint>) -> BoxedUint

Compute self - rhs mod p.

impl TryFrom<&Mpint> for Uint

Available on crate feature alloc only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(mpint: &Mpint) -> Result<Uint>

Performs the conversion.

impl TryFrom<Mpint> for Uint

Available on crate feature alloc only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(mpint: Mpint) -> Result<Uint>

Performs the conversion.

impl Unsigned for BoxedUint

fn as_uint_ref(&self) -> &UintRef

Borrow the limbs of this unsigned integer as a UintRef.

fn as_mut_uint_ref(&mut self) -> &mut UintRef

Mutably borrow the limbs of this unsigned integer as a UintRef.

fn from_limb_like(limb: Limb, other: &BoxedUint) -> BoxedUint

Returns an integer with the first limb set to limb, and the same precision as other.

impl UnsignedWithMontyForm for BoxedUint

type MontyForm = BoxedMontyForm

The corresponding Montgomery representation, optimized for the performance of modular operations at the price of a conversion overhead.

impl UpperHex for BoxedUint

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

Formats the value using the given formatter.

impl WrappingAdd for BoxedUint

fn wrapping_add(&self, v: &BoxedUint) -> BoxedUint

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

impl WrappingMul for BoxedUint

fn wrapping_mul(&self, v: &BoxedUint) -> BoxedUint

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

impl WrappingNeg for BoxedUint

fn wrapping_neg(&self) -> BoxedUint

Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.

impl WrappingShl for BoxedUint

fn wrapping_shl(&self, shift: u32) -> BoxedUint

Panic-free bitwise shift-left; yields self << mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl WrappingShr for BoxedUint

fn wrapping_shr(&self, shift: u32) -> BoxedUint

Panic-free bitwise shift-right; yields self >> mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl WrappingSub for BoxedUint

fn wrapping_sub(&self, v: &BoxedUint) -> BoxedUint

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

impl Zero for BoxedUint

fn zero() -> BoxedUint

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> Choice

Determine if this value is equal to 0.

fn set_zero(&mut self)

Set self to its additive identity, i.e. Self::zero.

fn zero_like(other: &Self) -> Self

where Self: Clone,

Return the value 0 with the same precision as other.

impl Zero for BoxedUint

fn zero() -> BoxedUint

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Eq for BoxedUint