Struct Uint 

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

The ring of numbers modulo $2^{\mathtt{BITS}}$.

Uint implements nearly all traits and methods from the std unsigned integer types, including most nightly only ones.

Notable differences from std uint types.

• The operators +, -, *, etc. using wrapping math by default. The std operators panic on overflow in debug, and are undefined in release, see reference.
• The Uint::checked_shl, Uint::overflowing_shl, etc return overflow when non-zero bits are shifted out. In std they return overflow when the shift amount is greater than the bit size.
• Some methods like u64::div_euclid and u64::rem_euclid are left out because they are meaningless or redundant for unsigned integers. Std has them for compatibility with their signed integers.
• Many functions that are const in std are not in Uint.
• Uint::to_le_bytes and Uint::to_be_bytes require the output size to be provided as a const-generic argument. They will runtime panic if the provided size is incorrect.
• Uint::widening_mul takes as argument an Uint of arbitrary size and returns a result that is sized to fit the product without overflow (i.e. the sum of the bit sizes of self and the argument). The std version requires same-sized arguments and returns a pair of lower and higher bits.

Implementations

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn abs_diff(self, other: Self) -> Self

Computes the absolute difference between self and other.

Returns $\left\vert \mathtt{self} - \mathtt{other} \right\vert$.

pub const fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occurred.

pub const fn checked_neg(self) -> Option<Self>

Computes -self, returning None unless self == 0.

pub const fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occurred.

pub const fn overflowing_add(self, rhs: Self) -> (Self, bool)

Calculates $\mod{\mathtt{self} + \mathtt{rhs}}_{2^{BITS}}$.

Returns a tuple of the addition along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

pub const fn overflowing_neg(self) -> (Self, bool)

Calculates $\mod{-\mathtt{self}}_{2^{BITS}}$.

Returns !self + 1 using wrapping operations to return the value that represents the negation of this unsigned value. Note that for positive unsigned values overflow always occurs, but negating 0 does not overflow.

pub const fn overflowing_sub(self, rhs: Self) -> (Self, bool)

Calculates $\mod{\mathtt{self} - \mathtt{rhs}}_{2^{BITS}}$.

Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

pub const fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub const fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing

pub const fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub const fn wrapping_neg(self) -> Self

Computes -self, wrapping around at the boundary of the type.

pub const fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn to_base_le(&self, base: u64) -> impl Iterator<Item = u64>

Returns an iterator over the base base digits of the number in little-endian order.

Pro tip: instead of setting base = 10, set it to the highest power of 10 that still fits u64. This way much fewer iterations are required to extract all the digits.

Panics

Panics if the base is less than 2.

pub fn to_base_be(&self, base: u64) -> impl Iterator<Item = u64>

Returns an iterator over the base base digits of the number in big-endian order.

Pro tip: instead of setting base = 10, set it to the highest power of 10 that still fits u64. This way much fewer iterations are required to extract all the digits.

Use to_base_be_2 to extract the maximum number of digits at once more efficiently.

Panics

Panics if the base is less than 2.

Examples

let n = ruint::aliases::U64::from(1234);
assert_eq!(n.to_base_be(10).collect::<Vec<_>>(), [1, 2, 3, 4]);
assert_eq!(n.to_base_be(1000000).collect::<Vec<_>>(), [1234]);

// `to_base_be_2` always returns digits maximally packed into `u64`s.
assert_eq!(n.to_base_be_2(10).collect::<Vec<_>>(), [1234]);
assert_eq!(n.to_base_be_2(1000000).collect::<Vec<_>>(), [1234]);

pub fn to_base_be_2(&self, base: u64) -> impl Iterator<Item = u64>

Returns an iterator over the base base digits of the number in big-endian order.

Always returns digits maximally packed into u64s. Unlike to_base_be, this method:

• never heap-allocates memory, so it’s always faster
• always returns digits maximally packed into u64s, so passing the constant base like 2, 8, instead of the highest power that fits in u64 is not needed

Panics

Panics if the base is less than 2.

Examples

See to_base_be.

pub fn from_base_le<I>(base: u64, digits: I) -> Result<Self, BaseConvertError>

where I: IntoIterator<Item = u64>,

Constructs the Uint from digits in the base base in little-endian.

Errors

• BaseConvertError::InvalidBase if the base is less than 2.
• BaseConvertError::InvalidDigit if a digit is out of range.
• BaseConvertError::Overflow if the number is too large to fit.

pub fn from_base_be<I: IntoIterator<Item = u64>>( base: u64, digits: I, ) -> Result<Self, BaseConvertError>

Constructs the Uint from digits in the base base in big-endian.

Errors

• BaseConvertError::InvalidBase if the base is less than 2.
• BaseConvertError::InvalidDigit if a digit is out of range.
• BaseConvertError::Overflow if the number is too large to fit.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

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

Returns whether a specific bit is set.

Returns false if index exceeds the bit width of the number.

pub const fn set_bit(&mut self, index: usize, value: bool)

Sets a specific bit to a value.

pub const fn byte(&self, index: usize) -> u8

Returns a specific byte. The byte at index 0 is the least significant byte (little endian).

Panics

Panics if index is greater than or equal to the byte width of the number.

Examples

let x = uint!(0x1234567890_U64);
let bytes = [
    x.byte(0), // 0x90
    x.byte(1), // 0x78
    x.byte(2), // 0x56
    x.byte(3), // 0x34
    x.byte(4), // 0x12
    x.byte(5), // 0x00
    x.byte(6), // 0x00
    x.byte(7), // 0x00
];
assert_eq!(bytes, x.to_le_bytes());

Panics if out of range.

let x = uint!(0x1234567890_U64);
let _ = x.byte(8);

pub const fn checked_byte(&self, index: usize) -> Option<u8>

Returns a specific byte, or None if index is out of range. The byte at index 0 is the least significant byte (little endian).

Examples

let x = uint!(0x1234567890_U64);
assert_eq!(x.checked_byte(0), Some(0x90));
assert_eq!(x.checked_byte(7), Some(0x00));
// Out of range
assert_eq!(x.checked_byte(8), None);

pub fn reverse_bits(self) -> Self

Reverses the order of bits in the integer. The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

pub const fn not(self) -> Self

Inverts all the bits in the integer.

pub const fn leading_zeros(&self) -> usize

Returns the number of leading zeros in the binary representation of self.

pub const fn leading_ones(&self) -> usize

Returns the number of leading ones in the binary representation of self.

pub fn trailing_zeros(&self) -> usize

Returns the number of trailing zeros in the binary representation of self.

pub fn trailing_ones(&self) -> usize

Returns the number of trailing ones in the binary representation of self.

pub const fn count_ones(&self) -> usize

Returns the number of ones in the binary representation of self.

pub const fn count_zeros(&self) -> usize

Returns the number of zeros in the binary representation of self.

pub const fn bit_len(&self) -> usize

Returns the dynamic length of this number in bits, ignoring leading zeros.

For the maximum length of the type, use Uint::BITS.

pub const fn byte_len(&self) -> usize

Returns the dynamic length of this number in bytes, ignoring leading zeros.

For the maximum length of the type, use Uint::BYTES.

pub fn most_significant_bits(&self) -> (u64, usize)

Returns the most significant 64 bits of the number and the exponent.

Given return value $(\mathtt{bits}, \mathtt{exponent})$, the self can be approximated as

$$ \mathtt{self} ≈ \mathtt{bits} ⋅ 2^\mathtt{exponent} $$

If self is $<≥> 2^{63}$, then exponent will be zero and bits will have leading zeros.

pub const fn checked_shl(self, rhs: usize) -> Option<Self>

Checked left shift by rhs bits.

Returns $\mathtt{self} ⋅ 2^{\mathtt{rhs}}$ or None if the result would $≥ 2^{\mathtt{BITS}}$. That is, it returns None if the bits shifted out would be non-zero.

Note: This differs from u64::checked_shl which returns None if the shift is larger than BITS (which is IMHO not very useful).

pub const fn saturating_shl(self, rhs: usize) -> Self

Saturating left shift by rhs bits.

Returns $\mathtt{self} ⋅ 2^{\mathtt{rhs}}$ or Uint::MAX if the result would $≥ 2^{\mathtt{BITS}}$. That is, it returns Uint::MAX if the bits shifted out would be non-zero.

pub const fn overflowing_shl(self, rhs: usize) -> (Self, bool)

Left shift by rhs bits with overflow detection.

Returns $\mod{\mathtt{value} ⋅ 2^{\mathtt{rhs}}}_{2^{\mathtt{BITS}}}$. If the product is $≥ 2^{\mathtt{BITS}}$ it returns true. That is, it returns true if the bits shifted out are non-zero.

Note: This differs from u64::overflowing_shl which returns true if the shift is larger than BITS (which is IMHO not very useful).

pub const fn wrapping_shl(self, rhs: usize) -> Self

Left shift by rhs bits.

Returns $\mod{\mathtt{value} ⋅ 2^{\mathtt{rhs}}}_{2^{\mathtt{BITS}}}$.

Note: This differs from u64::wrapping_shl which first reduces rhs by BITS (which is IMHO not very useful).

pub const fn checked_shr(self, rhs: usize) -> Option<Self>

Checked right shift by rhs bits.

$$ \frac{\mathtt{self}}{2^{\mathtt{rhs}}} $$

Returns the above or None if the division is not exact. This is the same as

Note: This differs from u64::checked_shr which returns None if the shift is larger than BITS (which is IMHO not very useful).

pub const fn overflowing_shr(self, rhs: usize) -> (Self, bool)

Right shift by rhs bits with underflow detection.

$$ \floor{\frac{\mathtt{self}}{2^{\mathtt{rhs}}}} $$

Returns the above and false if the division was exact, and true if it was rounded down. This is the same as non-zero bits being shifted out.

Note: This differs from u64::overflowing_shr which returns true if the shift is larger than BITS (which is IMHO not very useful).

pub const fn wrapping_shr(self, rhs: usize) -> Self

Right shift by rhs bits.

$$ \mathtt{wrapping\_shr}(\mathtt{self}, \mathtt{rhs}) = \floor{\frac{\mathtt{self}}{2^{\mathtt{rhs}}}} $$

Note: This differs from u64::wrapping_shr which first reduces rhs by BITS (which is IMHO not very useful).

pub const fn arithmetic_shr(self, rhs: usize) -> Self

Arithmetic shift right by rhs bits.

pub const fn rotate_left(self, rhs: usize) -> Self

Shifts the bits to the left by a specified amount, rhs, wrapping the truncated bits to the end of the resulting integer.

pub const fn rotate_right(self, rhs: usize) -> Self

Shifts the bits to the right by a specified amount, rhs, wrapping the truncated bits to the beginning of the resulting integer.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub const fn bitor(self, rhs: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Returns the bitwise | of the two numbers.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

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

Returns the bitwise & of the two numbers.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

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

Returns the bitwise ^ of the two numbers.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub const BYTES: usize

The size of this integer type in bytes. Note that some bits may be forced zero if BITS is not cleanly divisible by eight.

pub const fn as_le_slice(&self) -> &[u8]

Available on little-endian only.

Access the underlying store as a little-endian slice of bytes.

Only available on little-endian targets.

If BITS does not evenly divide 8, it is padded with zero bits in the most significant position.

pub const unsafe fn as_le_slice_mut(&mut self) -> &mut [u8]

Available on little-endian only.

Access the underlying store as a mutable little-endian slice of bytes.

Only available on litte-endian targets.

Safety

If BITS does not evenly divide 8, it is padded with zero bits in the most significant position. Setting those bits puts the Uint in an invalid state.

pub fn as_le_bytes(&self) -> Cow<'_, [u8]>

Available on crate feature alloc only.

Access the underlying store as a little-endian bytes.

Uses an optimized implementation on little-endian targets.

pub fn as_le_bytes_trimmed(&self) -> Cow<'_, [u8]>

Available on crate feature alloc only.

Access the underlying store as a little-endian bytes with trailing zeros removed.

Uses an optimized implementation on little-endian targets.

pub const fn to_le_bytes<const BYTES: usize>(&self) -> [u8; BYTES]

Converts the Uint to a little-endian byte array of size exactly Self::BYTES.

Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

pub fn to_le_bytes_vec(&self) -> Vec<u8>

Available on crate feature alloc only.

Converts the Uint to a little-endian byte vector of size exactly Self::BYTES.

This method is useful when Self::to_le_bytes can not be used because byte size is not known compile time.

pub fn to_le_bytes_trimmed_vec(&self) -> Vec<u8>

Available on crate feature alloc only.

Converts the Uint to a little-endian byte vector with trailing zeros bytes removed.

pub const fn to_be_bytes<const BYTES: usize>(&self) -> [u8; BYTES]

Converts the Uint to a big-endian byte array of size exactly Self::BYTES.

Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

pub fn to_be_bytes_vec(&self) -> Vec<u8>

Available on crate feature alloc only.

Converts the Uint to a big-endian byte vector of size exactly Self::BYTES.

This method is useful when Self::to_be_bytes can not be used because byte size is not known compile time.

pub fn to_be_bytes_trimmed_vec(&self) -> Vec<u8>

Available on crate feature alloc only.

Converts the Uint to a big-endian byte vector with leading zeros bytes removed.

pub const fn from_be_bytes<const BYTES: usize>(bytes: [u8; BYTES]) -> Self

Converts a big-endian byte array of size exactly Self::BYTES to Uint.

Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

Panics if the value is too large for the bit-size of the Uint.

pub const fn from_be_slice(bytes: &[u8]) -> Self

Creates a new integer from a big endian slice of bytes.

The slice is interpreted as a big endian number, and must be at most Self::BYTES long.

Panics

Panics if the value is larger than fits the Uint.

pub const fn try_from_be_slice(bytes: &[u8]) -> Option<Self>

Creates a new integer from a big endian slice of bytes.

The slice is interpreted as a big endian number, and must be at most Self::BYTES long.

Returns None if the value is larger than fits the Uint.

pub const fn from_le_bytes<const BYTES: usize>(bytes: [u8; BYTES]) -> Self

Converts a little-endian byte array of size exactly Self::BYTES to Uint.

Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

Panics if the value is too large for the bit-size of the Uint.

pub const fn from_le_slice(bytes: &[u8]) -> Self

Creates a new integer from a little endian slice of bytes.

The slice is interpreted as a little endian number, and must be at most Self::BYTES long.

Panics

Panics if the value is larger than fits the Uint.

pub const fn try_from_le_slice(bytes: &[u8]) -> Option<Self>

Creates a new integer from a little endian slice of bytes.

The slice is interpreted as a little endian number, and must be at most Self::BYTES long.

Returns None if the value is larger than fits the Uint.

pub fn copy_le_bytes_to(&self, buf: &mut [u8]) -> usize

Writes the little-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Panics

Panics if the buffer is not large enough to hold Self::BYTES bytes.

Returns

The number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn checked_copy_le_bytes_to(&self, buf: &mut [u8]) -> Option<usize>

Writes the little-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Returns

None, if the buffer is not large enough to hold Self::BYTES bytes, and does not modify the buffer.

Some with the number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn copy_be_bytes_to(&self, buf: &mut [u8]) -> usize

Writes the big-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Panics

Panics if the buffer is not large enough to hold Self::BYTES bytes.

Returns

The number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn checked_copy_be_bytes_to(&self, buf: &mut [u8]) -> Option<usize>

Writes the big-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

Returns

None, if the buffer is not large enough to hold Self::BYTES bytes, and does not modify the buffer.

Some with the number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn is_zero(&self) -> bool

Returns true if the value is zero.

pub const fn const_is_zero(&self) -> bool

Returns true if the value is zero.

Note that this currently might perform worse than is_zero.

pub const fn const_eq(&self, other: &Self) -> bool

Returns true if self equals other.

Note that this currently might perform worse than the derived PartialEq (== operator).

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if rhs == 0.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if rhs == 0.

pub fn div_ceil(self, rhs: Self) -> Self

Computes self / rhs rounding up.

Panics

Panics if rhs == 0.

pub fn div_rem(self, rhs: Self) -> (Self, Self)

Computes self / rhs and self % rhs.

Panics

Panics if rhs == 0.

pub fn wrapping_div(self, rhs: Self) -> Self

Computes self / rhs rounding down.

Panics

Panics if rhs == 0.

pub fn wrapping_rem(self, rhs: Self) -> Self

Computes self % rhs.

Panics

Panics if rhs == 0.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn from<T>(value: T) -> Self

where Self: UintTryFrom<T>,

Construct a new Uint from the value.

Panics

Panics if the conversion fails, for example if the value is too large for the bit-size of the Uint. The panic will be attributed to the call site.

Examples

assert_eq!(U8::from(142_u16), 142_U8);
assert_eq!(U64::from(0x7014b4c2d1f2_U256), 0x7014b4c2d1f2_U64);
assert_eq!(U64::from(3.145), 3_U64);

pub fn saturating_from<T>(value: T) -> Self

where Self: UintTryFrom<T>,

Construct a new Uint from the value saturating the value to the minimum or maximum value of the Uint.

If the value is not a number (like f64::NAN), then the result is set zero.

Examples

assert_eq!(U8::saturating_from(300_u16), 255_U8);
assert_eq!(U8::saturating_from(-10_i16), 0_U8);
assert_eq!(U32::saturating_from(0x7014b4c2d1f2_U256), U32::MAX);

pub fn wrapping_from<T>(value: T) -> Self

where Self: UintTryFrom<T>,

Construct a new Uint from the value saturating the value to the minimum or maximum value of the Uint.

If the value is not a number (like f64::NAN), then the result is set zero.

Examples

assert_eq!(U8::wrapping_from(300_u16), 44_U8);
assert_eq!(U8::wrapping_from(-10_i16), 246_U8);
assert_eq!(U32::wrapping_from(0x7014b4c2d1f2_U256), 0xb4c2d1f2_U32);

pub fn to<T>(&self) -> T

where Self: UintTryTo<T>, T: Debug,

Panics

Panics if the conversion fails, for example if the value is too large for the bit-size of the target type.

Examples

assert_eq!(300_U12.to::<i16>(), 300_i16);
assert_eq!(300_U12.to::<U256>(), 300_U256);

pub fn wrapping_to<T>(&self) -> T

where Self: UintTryTo<T>,

Examples

assert_eq!(300_U12.wrapping_to::<i8>(), 44_i8);
assert_eq!(255_U32.wrapping_to::<i8>(), -1_i8);
assert_eq!(0x1337cafec0d3_U256.wrapping_to::<U32>(), 0xcafec0d3_U32);

pub fn saturating_to<T>(&self) -> T

where Self: UintTryTo<T>,

Examples

assert_eq!(300_U12.saturating_to::<i16>(), 300_i16);
assert_eq!(255_U32.saturating_to::<i8>(), 127);
assert_eq!(0x1337cafec0d3_U256.saturating_to::<U32>(), U32::MAX);

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn gcd(self, other: Self) -> Self

Compute the greatest common divisor of two Uints.

Examples

assert_eq!(0_U128.gcd(0_U128), 0_U128);

pub fn lcm(self, other: Self) -> Option<Self>

Compute the least common multiple of two Uints or None if the result would be too large.

pub fn gcd_extended(self, other: Self) -> (Self, Self, Self, bool)

⚠️ Compute the greatest common divisor and the Bézout coefficients.

Warning. This is API is unstable and may change in a minor release.

Returns $(\mathtt{gcd}, \mathtt{x}, \mathtt{y}, \mathtt{sign})$ such that

$$ \gcd(\mathtt{self}, \mathtt{other}) = \mathtt{gcd} = \begin{cases} \mathtt{self} · \mathtt{x} - \mathtt{other} . \mathtt{y} & \mathtt{sign} \\ \mathtt{other} · \mathtt{y} - \mathtt{self} · \mathtt{x} & ¬\mathtt{sign} \end{cases} $$

Note that the intermediate products may overflow, even though the result after subtraction will fit in the bit size of the Uint.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn checked_log(self, base: Self) -> Option<usize>

Available on crate feature std only.

Returns the logarithm of the number, rounded down.

Returns None if the base is less than two, or this number is zero.

pub fn checked_log10(self) -> Option<usize>

Available on crate feature std only.

Returns the base 10 logarithm of the number, rounded down.

Returns None if the number is zero.

pub fn checked_log2(self) -> Option<usize>

Available on crate feature std only.

Returns the base 2 logarithm of the number, rounded down.

This is equivalent to the index of the highest set bit.

Returns None if the number is zero.

pub fn log(self, base: Self) -> usize

Available on crate feature std only.

Returns the logarithm of the number, rounded down.

Panics

Panics if the base is less than 2 or if the number is zero.

pub fn log10(self) -> usize

Available on crate feature std only.

Returns the base 10 logarithm of the number, rounded down.

Panics

Panics if the base if the number is zero.

pub fn log2(self) -> usize

Available on crate feature std only.

Returns the base 2 logarithm of the number, rounded down.

Panics

Panics if the base if the number is zero.

pub fn approx_log(self, base: f64) -> f64

Available on crate feature std only.

Double precision logarithm.

pub fn approx_log2(self) -> f64

Available on crate feature std only.

Double precision binary logarithm.

Examples

assert_eq!(0_U64.approx_log2(), f64::NEG_INFINITY);
assert_eq!(1_U64.approx_log2(), 0.0);
assert_eq!(2_U64.approx_log2(), 1.0);
assert_eq!(U64::MAX.approx_log2(), 64.0);

pub fn approx_log10(self) -> f64

Available on crate feature std only.

Double precision decimal logarithm.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn reduce_mod(self, modulus: Self) -> Self

⚠️ Compute $\mod{\mathtt{self}}_{\mathtt{modulus}}$.

Warning. This function is not part of the stable API.

Returns zero if the modulus is zero.

pub fn add_mod(self, rhs: Self, modulus: Self) -> Self

Compute $\mod{\mathtt{self} + \mathtt{rhs}}_{\mathtt{modulus}}$.

Returns zero if the modulus is zero.

pub fn mul_mod(self, rhs: Self, modulus: Self) -> Self

Compute $\mod{\mathtt{self} ⋅ \mathtt{rhs}}_{\mathtt{modulus}}$.

Returns zero if the modulus is zero.

See mul_redc for a faster variant at the cost of some pre-computation.

pub fn pow_mod(self, exp: Self, modulus: Self) -> Self

Compute $\mod{\mathtt{self}^{\mathtt{rhs}}}_{\mathtt{modulus}}$.

Returns zero if the modulus is zero.

pub fn inv_mod(self, modulus: Self) -> Option<Self>

Compute $\mod{\mathtt{self}^{-1}}_{\mathtt{modulus}}$.

Returns None if the inverse does not exist.

pub fn mul_redc(self, other: Self, modulus: Self, inv: u64) -> Self

Montgomery multiplication.

Requires self and other to be less than modulus.

Computes

$$ \mod{\frac{\mathtt{self} ⋅ \mathtt{other}}{ 2^{64 · \mathtt{LIMBS}}}}_{\mathtt{modulus}} $$

This is useful because it can be computed notably faster than mul_mod. Many computations can be done by pre-multiplying values with $R = 2^{64 · \mathtt{LIMBS}}$ and then using mul_redc instead of mul_mod.

For this algorithm to work, it needs an extra parameter inv which must be set to

$$ \mathtt{inv} = \mod{\frac{-1}{\mathtt{modulus}} }_{2^{64}} $$

The inv value only exists for odd values of modulus. It can be computed using inv_ring from U64.

let inv = U64::wrapping_from(modulus).inv_ring().unwrap().wrapping_neg().to();
let prod = 5_U256.mul_redc(6_U256, modulus, inv);

Panics

Panics if inv is not correct in debug mode.

pub fn square_redc(self, modulus: Self, inv: u64) -> Self

Montgomery squaring.

See Self::mul_redc.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occurred.

pub fn overflowing_mul(self, rhs: Self) -> (Self, bool)

Calculates the multiplication of self and rhs.

Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

Examples

assert_eq!(1_U1.overflowing_mul(1_U1), (1_U1, false));
assert_eq!(
    0x010000000000000000_U65.overflowing_mul(0x010000000000000000_U65),
    (0x000000000000000000_U65, true)
);

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

pub fn inv_ring(self) -> Option<Self>

Computes the inverse modulo $2^{\mathtt{BITS}}$ of self, returning None if the inverse does not exist.

pub fn widening_mul<const BITS_RHS: usize, const LIMBS_RHS: usize, const BITS_RES: usize, const LIMBS_RES: usize>( self, rhs: Uint<BITS_RHS, LIMBS_RHS>, ) -> Uint<BITS_RES, LIMBS_RES>

Calculates the complete product self * rhs without the possibility to overflow.

The argument rhs can be any size Uint, the result size is the sum of the bit-sizes of self and rhs.

Panics

This function will runtime panic of the const generic arguments are incorrect.

Examples

assert_eq!(0_U0.widening_mul(0_U0), 0_U0);
assert_eq!(1_U1.widening_mul(1_U1), 1_U2);
assert_eq!(3_U2.widening_mul(7_U3), 21_U5);

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn checked_pow(self, exp: Self) -> Option<Self>

Raises self to the power of exp.

Returns None if the result would overflow.

pub fn overflowing_pow(self, exp: Self) -> (Self, bool)

Raises self to the power of exp and if the result would overflow.

Examples

assert_eq!(
    36_U64.overflowing_pow(12_U64),
    (0x41c21cb8e1000000_U64, false)
);
assert_eq!(
    36_U64.overflowing_pow(13_U64),
    (0x3f4c09ffa4000000_U64, true)
);
assert_eq!(
    36_U68.overflowing_pow(13_U68),
    (0x093f4c09ffa4000000_U68, false)
);
assert_eq!(16_U65.overflowing_pow(32_U65), (0_U65, true));

Small cases:

assert_eq!(0_U0.overflowing_pow(0_U0), (0_U0, false));
assert_eq!(0_U1.overflowing_pow(0_U1), (1_U1, false));
assert_eq!(0_U1.overflowing_pow(1_U1), (0_U1, false));
assert_eq!(1_U1.overflowing_pow(0_U1), (1_U1, false));
assert_eq!(1_U1.overflowing_pow(1_U1), (1_U1, false));

pub fn pow(self, exp: Self) -> Self

Raises self to the power of exp, wrapping around on overflow.

pub fn saturating_pow(self, exp: Self) -> Self

Raises self to the power of exp, saturating on overflow.

pub fn wrapping_pow(self, exp: Self) -> Self

Raises self to the power of exp, wrapping around on overflow.

pub fn approx_pow2(exp: f64) -> Option<Self>

Available on crate feature std only.

Construct from double precision binary logarithm.

Examples

assert_eq!(U64::approx_pow2(-2.0), Some(0_U64));
assert_eq!(U64::approx_pow2(-1.0), Some(1_U64));
assert_eq!(U64::approx_pow2(0.0), Some(1_U64));
assert_eq!(U64::approx_pow2(1.0), Some(2_U64));
assert_eq!(U64::approx_pow2(1.6), Some(3_U64));
assert_eq!(U64::approx_pow2(2.0), Some(4_U64));
assert_eq!(U64::approx_pow2(64.0), None);
assert_eq!(U64::approx_pow2(10.385), Some(1337_U64));

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn root(self, degree: usize) -> Self

Available on crate feature std only.

Computes the floor of the degree-th root of the number.

$$ \floor{\sqrt[\mathtt{degree}]{\mathtt{self}}} $$

Panics

Panics if degree is zero.

Examples

assert_eq!(0_U64.root(2), 0_U64);
assert_eq!(1_U64.root(63), 1_U64);
assert_eq!(0x0032da8b0f88575d_U63.root(64), 1_U63);
assert_eq!(0x1756800000000000_U63.root(34), 3_U63);

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub const fn is_power_of_two(self) -> bool

Returns true if and only if self == 2^k for some k.

pub const fn next_power_of_two(self) -> Self

Returns the smallest power of two greater than or equal to self.

Panics

Panics if the value overlfows.

pub const fn checked_next_power_of_two(self) -> Option<Self>

Returns the smallest power of two greater than or equal to self. If the next power of two is greater than the type’s maximum value, None is returned, otherwise the power of two is wrapped in Some.

Examples

assert_eq!(0_U64.checked_next_power_of_two(), Some(1_U64));
assert_eq!(1_U64.checked_next_power_of_two(), Some(1_U64));
assert_eq!(2_U64.checked_next_power_of_two(), Some(2_U64));
assert_eq!(3_U64.checked_next_power_of_two(), Some(4_U64));
assert_eq!(U64::MAX.checked_next_power_of_two(), None);

pub fn next_multiple_of(self, rhs: Self) -> Self

Calculates the smallest value greater than or equal to self that is a multiple of rhs.

Panics

This function will panic if rhs is 0 or the operation results in overflow.

pub fn checked_next_multiple_of(self, rhs: Self) -> Option<Self>

Calculates the smallest value greater than or equal to self that is a multiple of rhs. Returns None is rhs is zero or the operation would result in overflow.

Examples

assert_eq!(16_U64.checked_next_multiple_of(8_U64), Some(16_U64));
assert_eq!(23_U64.checked_next_multiple_of(8_U64), Some(24_U64));
assert_eq!(1_U64.checked_next_multiple_of(0_U64), None);
assert_eq!(U64::MAX.checked_next_multiple_of(2_U64), None);

assert_eq!(0_U0.checked_next_multiple_of(0_U0), None);
assert_eq!(0_U1.checked_next_multiple_of(0_U1), None);
assert_eq!(0_U1.checked_next_multiple_of(1_U1), Some(0_U1));
assert_eq!(1_U1.checked_next_multiple_of(0_U1), None);
assert_eq!(1_U1.checked_next_multiple_of(1_U1), Some(1_U1));

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn from_str_radix(src: &str, radix: u64) -> Result<Self, ParseError>

Parse a string into a Uint.

For bases 2 to 36, the case-agnostic alphabet 0—1, a—b is used and _ are ignored. For bases 37 to 64, the case-sensitive alphabet a—z, A—Z, 0—9, {+-}, {/,_} is used. That is, for base 64 it is compatible with all the common base64 variants.

Errors

• ParseError::InvalidDigit if the string contains a non-digit.
• ParseError::InvalidRadix if the radix is larger than 64.
• ParseError::BaseConvertError if Uint::from_base_be fails.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn random() -> Self

Available on crate features rand-09 and std only.

Creates a new Uint with the default cryptographic random number generator.

This is currently rand::rng().

pub fn random_with<R: RngCore + ?Sized>(rng: &mut R) -> Self

Available on crate feature rand-09 only.

Creates a new Uint with the given random number generator.

pub fn randomize(&mut self)

Available on crate features rand-09 and std only.

Fills this Uint with the default cryptographic random number generator.

See random for more details.

pub fn randomize_with<R: RngCore + ?Sized>(&mut self, rng: &mut R)

Available on crate feature rand-09 only.

Fills this Uint with the given random number generator.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub fn bit_ct(&self, index: usize) -> Choice

Available on crate feature subtle only.

Returns a Choice if the bit at index is set.

Constant time version of Uint::bit

Panics

Panics if index >= Self::BITS.

impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>

pub const LIMBS: usize

The size of this integer type in 64-bit limbs.

pub const MASK: u64

Bit mask for the last limb.

pub const BITS: usize = BITS

The size of this integer type in bits.

pub const ZERO: Self

The value zero. This is the only value that exists in all Uint types.

pub const ONE: Self

The value one. This is useful to have as a constant for use in const fn.

Zero if BITS is zero.

pub const MIN: Self = Self::ZERO

The smallest value that can be represented by this integer type. Synonym for Self::ZERO.

pub const MAX: Self

The largest value that can be represented by this integer type, $2^{\mathtt{BITS}} − 1$.

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

View the array of limbs.

pub const unsafe fn as_limbs_mut(&mut self) -> &mut [u64; LIMBS]

Access the array of limbs.

Safety

This function is unsafe because it allows setting a bit outside the bit size if the bit-size is not limb-aligned.

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

Convert to a array of limbs.

Limbs are least significant first.

pub const fn from_limbs(limbs: [u64; LIMBS]) -> Self

Construct a new integer from little-endian a array of limbs.

Panics

Panics it LIMBS is not equal to nlimbs(BITS).

Panics if the value is too large for the bit-size of the Uint.

pub fn from_limbs_slice(slice: &[u64]) -> Self

Construct a new integer from little-endian a slice of limbs.

Panics

Panics if the value is too large for the bit-size of the Uint.

pub fn checked_from_limbs_slice(slice: &[u64]) -> Option<Self>

Construct a new integer from little-endian a slice of limbs, or None if the value is too large for the Uint.

pub fn wrapping_from_limbs_slice(slice: &[u64]) -> Self

Construct a new Uint from a little-endian slice of limbs. Returns a potentially truncated value.

pub fn overflowing_from_limbs_slice(slice: &[u64]) -> (Self, bool)

Construct a new Uint from a little-endian slice of limbs. Returns a potentially truncated value and a boolean indicating whether the value was truncated.

pub fn saturating_from_limbs_slice(slice: &[u64]) -> Self

Construct a new Uint from a little-endian slice of limbs. Returns the maximum value if the value is too large for the Uint.

Trait Implementations

impl<const BITS: usize, const LIMBS: usize> Add<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the + operator.

fn add(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the + operation.

impl<const BITS: usize, const LIMBS: usize> Add<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the + operator.

fn add(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the + operation.

impl<const BITS: usize, const LIMBS: usize> Add<Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the + operator.

fn add(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the + operation.

impl<const BITS: usize, const LIMBS: usize> Add for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the + operator.

fn add(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the + operation.

impl<const BITS: usize, const LIMBS: usize> AddAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn add_assign(&mut self, rhs: &Uint<BITS, LIMBS>)

Performs the += operation.

impl<const BITS: usize, const LIMBS: usize> AddAssign for Uint<BITS, LIMBS>

fn add_assign(&mut self, rhs: Uint<BITS, LIMBS>)

Performs the += operation.

impl<'a, const BITS: usize, const LIMBS: usize> Arbitrary<'a> for Uint<BITS, LIMBS>

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(_depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<const BITS: usize, const LIMBS: usize> Arbitrary for Uint<BITS, LIMBS>

Available on crate feature proptest only.

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<<[u64; LIMBS] as Arbitrary>::Strategy, fn([u64; LIMBS]) -> Uint<BITS, LIMBS>>

The type of Strategy used to generate values of type Self.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

fn arbitrary_with((): Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

impl<const BITS: usize, const LIMBS: usize> Arbitrary for Uint<BITS, LIMBS>

Available on crate feature quickcheck only.

fn arbitrary(g: &mut Gen) -> Self

Return an arbitrary value.

fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

Return an iterator of values that are smaller than itself.

impl<const BITS: usize, const LIMBS: usize> Archive for Uint<BITS, LIMBS>

Available on crate feature rkyv only.

type Archived = ArchivedUint<BITS, LIMBS>

The archived representation of this type.

type Resolver = [(); LIMBS]

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<const BITS: usize, const LIMBS: usize> AsExpression<Binary> for &Uint<BITS, LIMBS>

Available on crate feature diesel only.

type Expression = Bound<Binary, &Uint<BITS, LIMBS>>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl<const BITS: usize, const LIMBS: usize> AsExpression<Binary> for Uint<BITS, LIMBS>

Available on crate feature diesel only.

type Expression = Bound<Binary, Uint<BITS, LIMBS>>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl<const BITS: usize, const LIMBS: usize> AsExpression<Nullable<Binary>> for &Uint<BITS, LIMBS>

Available on crate feature diesel only.

type Expression = Bound<Nullable<Binary>, &Uint<BITS, LIMBS>>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl<const BITS: usize, const LIMBS: usize> AsExpression<Nullable<Binary>> for Uint<BITS, LIMBS>

Available on crate feature diesel only.

type Expression = Bound<Nullable<Binary>, Uint<BITS, LIMBS>>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl<const BITS: usize, const LIMBS: usize> Binary for Uint<BITS, LIMBS>

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

Formats the value using the given formatter.

impl<const BITS: usize, const LIMBS: usize> BitAnd<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the & operation.

impl<const BITS: usize, const LIMBS: usize> BitAnd<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the & operation.

impl<const BITS: usize, const LIMBS: usize> BitAnd<Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the & operation.

impl<const BITS: usize, const LIMBS: usize> BitAnd for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the & operation.

impl<const BITS: usize, const LIMBS: usize> BitAndAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn bitand_assign(&mut self, rhs: &Uint<BITS, LIMBS>)

Performs the &= operation.

impl<const BITS: usize, const LIMBS: usize> BitAndAssign for Uint<BITS, LIMBS>

fn bitand_assign(&mut self, rhs: Uint<BITS, LIMBS>)

Performs the &= operation.

impl<const BITS: usize, const LIMBS: usize> BitOr<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the | operation.

impl<const BITS: usize, const LIMBS: usize> BitOr<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the | operation.

impl<const BITS: usize, const LIMBS: usize> BitOr<Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the | operation.

impl<const BITS: usize, const LIMBS: usize> BitOr for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the | operation.

impl<const BITS: usize, const LIMBS: usize> BitOrAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn bitor_assign(&mut self, rhs: &Uint<BITS, LIMBS>)

Performs the |= operation.

impl<const BITS: usize, const LIMBS: usize> BitOrAssign for Uint<BITS, LIMBS>

fn bitor_assign(&mut self, rhs: Uint<BITS, LIMBS>)

Performs the |= operation.

impl<const BITS: usize, const LIMBS: usize> BitXor<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the ^ operation.

impl<const BITS: usize, const LIMBS: usize> BitXor<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the ^ operation.

impl<const BITS: usize, const LIMBS: usize> BitXor<Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the ^ operation.

impl<const BITS: usize, const LIMBS: usize> BitXor for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the ^ operation.

impl<const BITS: usize, const LIMBS: usize> BitXorAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn bitxor_assign(&mut self, rhs: &Uint<BITS, LIMBS>)

Performs the ^= operation.

impl<const BITS: usize, const LIMBS: usize> BitXorAssign for Uint<BITS, LIMBS>

fn bitxor_assign(&mut self, rhs: Uint<BITS, LIMBS>)

Performs the ^= operation.

impl<'de, Context, const BITS: usize, const LIMBS: usize> BorrowDecode<'de, Context> for Uint<BITS, LIMBS>

Available on crate feature bincode-2 only.

fn borrow_decode<D: BorrowDecoder<'de, Context = Context>>( decoder: &mut D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl<const BITS: usize, const LIMBS: usize> BorshDeserialize for Uint<BITS, LIMBS>

Available on crate feature borsh only.

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl<const BITS: usize, const LIMBS: usize> BorshSerialize for Uint<BITS, LIMBS>

Available on crate feature borsh only.

fn serialize<W: Write>(&self, writer: &mut W) -> Result<()>

impl<const BITS: usize, const LIMBS: usize> Bounded for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

impl<const BITS: usize, const LIMBS: usize> CheckedAdd for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn checked_add(&self, other: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<const BITS: usize, const LIMBS: usize> CheckedDiv for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn checked_div(&self, other: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<const BITS: usize, const LIMBS: usize> CheckedEuclid for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn checked_div_euclid(&self, v: &Self) -> Option<Self>

Performs euclid division that returns None instead of panicking on division by zero and instead of wrapping around on underflow and overflow.

fn checked_rem_euclid(&self, v: &Self) -> Option<Self>

Finds the euclid remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

fn checked_div_rem_euclid(&self, v: &Self) -> Option<(Self, Self)>

Returns both the quotient and remainder from checked Euclidean division.

impl<const BITS: usize, const LIMBS: usize> CheckedMul for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn checked_mul(&self, other: &Self) -> Option<Self>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl<const BITS: usize, const LIMBS: usize> CheckedNeg for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn checked_neg(&self) -> Option<Self>

Negates a number, returning None for results that can’t be represented, like signed MIN values that can’t be positive, or non-zero unsigned values that can’t be negative.

impl<const BITS: usize, const LIMBS: usize> CheckedRem for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn checked_rem(&self, other: &Self) -> Option<Self>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<const BITS: usize, const LIMBS: usize> CheckedShl for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn checked_shl(&self, other: u32) -> Option<Self>

Checked shift left. Computes self << rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<const BITS: usize, const LIMBS: usize> CheckedShr for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn checked_shr(&self, other: u32) -> Option<Self>

Checked shift right. Computes self >> rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<const BITS: usize, const LIMBS: usize> CheckedSub for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn checked_sub(&self, other: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl<const BITS: usize, const LIMBS: usize> Clone for Uint<BITS, LIMBS>

fn clone(&self) -> Uint<BITS, LIMBS>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const BITS: usize, const LIMBS: usize> ConditionallySelectable for Uint<BITS, LIMBS>

Available on crate feature subtle only.

fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

fn conditional_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign other to self, according to choice.

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

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

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

Available on crate feature subtle only.

fn ct_eq(&self, rhs: &Self) -> Choice

Determine if two items are equal.

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

Determine if two items are NOT equal.

impl<const BITS: usize, const LIMBS: usize> ConstantTimeGreater for Uint<BITS, LIMBS>

Available on crate feature subtle only.

fn ct_gt(&self, rhs: &Self) -> Choice

Determine whether self > other.

impl<const BITS: usize, const LIMBS: usize> ConstantTimeLess for Uint<BITS, LIMBS>

Available on crate feature subtle only.

fn ct_lt(&self, rhs: &Self) -> Choice

Determine whether self < other.

impl<const BITS: usize, const LIMBS: usize> Debug for Uint<BITS, LIMBS>

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

Formats the value using the given formatter.

impl<const BITS: usize, const LIMBS: usize> Decodable for Uint<BITS, LIMBS>

Available on crate feature alloy-rlp only.

Allows a Uint to be deserialized from RLP.

See https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/

fn decode(buf: &mut &[u8]) -> Result<Self, Error>

Decodes the blob into the appropriate type. buf must be advanced past the decoded object.

impl<const BITS: usize, const LIMBS: usize> Decodable for Uint<BITS, LIMBS>

Available on crate feature fastrlp only.

Allows a Uint to be deserialized from RLP.

See https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/

fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError>

impl<const BITS: usize, const LIMBS: usize> Decodable for Uint<BITS, LIMBS>

Available on crate feature fastrlp-04 only.

Allows a Uint to be deserialized from RLP.

See https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/

fn decode(buf: &mut &[u8]) -> Result<Self, DecodeError>

impl<const BITS: usize, const LIMBS: usize> Decodable for Uint<BITS, LIMBS>

Available on crate feature rlp only.

Allows a Uint to be deserialized from RLP.

See https://eth.wiki/en/fundamentals/rlp

fn decode(s: &Rlp<'_>) -> Result<Self, DecoderError>

Decode a value from RLP bytes

impl<'a, const BITS: usize, const LIMBS: usize, DB: Database> Decode<'a, DB> for Uint<BITS, LIMBS>

where Vec<u8>: Decode<'a, DB>,

Available on crate feature sqlx only.

fn decode(value: <DB as Database>::ValueRef<'a>) -> Result<Self, BoxDynError>

Decode a new value of this type using a raw value from the database.

impl<Context, const BITS: usize, const LIMBS: usize> Decode<Context> for Uint<BITS, LIMBS>

Available on crate feature bincode-2 only.

fn decode<D: Decoder<Context = Context>>( decoder: &mut D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<const BITS: usize, const LIMBS: usize> Decode for Uint<BITS, LIMBS>

Available on crate feature parity-scale-codec only.

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<const BITS: usize, const LIMBS: usize> Decode for Uint<BITS, LIMBS>

Available on crate feature ssz only.

fn is_ssz_fixed_len() -> bool

Returns true if this object has a fixed-length.

fn ssz_fixed_len() -> usize

The number of bytes this object occupies in the fixed-length portion of the SSZ bytes.

fn from_ssz_bytes(bytes: &[u8]) -> Result<Self, DecodeError>

Attempts to decode Self from bytes, returning a DecodeError on failure.

impl<'a, const BITS: usize, const LIMBS: usize> DecodeValue<'a> for Uint<BITS, LIMBS>

Available on crate feature der only.

fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self>

Attempt to decode this message using the provided Reader.

impl<const BITS: usize, const LIMBS: usize> Default for Uint<BITS, LIMBS>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, const BITS: usize, const LIMBS: usize> Deserialize<'de> for Uint<BITS, LIMBS>

Available on crate feature serde only.

Deserialize human readable hex strings or byte arrays into Uint.

Hex strings can be upper/lower/mixed case, have an optional 0x prefix, and can be any length. They are interpreted big-endian.

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<D: Fallible + ?Sized, const BITS: usize, const LIMBS: usize> Deserialize<Uint<BITS, LIMBS>, D> for Archived<Uint<BITS, LIMBS>>

Available on crate feature rkyv only.

fn deserialize( &self, deserializer: &mut D, ) -> Result<Uint<BITS, LIMBS>, <D as Fallible>::Error>

Deserializes using the given deserializer

impl<const BITS: usize, const LIMBS: usize> Display for Uint<BITS, LIMBS>

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

Formats the value using the given formatter.

impl<const BITS: usize, const LIMBS: usize> Distribution<Uint<BITS, LIMBS>> for Standard

Available on crate feature rand only.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Uint<BITS, LIMBS>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<const BITS: usize, const LIMBS: usize> Distribution<Uint<BITS, LIMBS>> for StandardUniform

Available on crate feature rand-09 only.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Uint<BITS, LIMBS>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl<const BITS: usize, const LIMBS: usize> Div<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the / operation.

impl<const BITS: usize, const LIMBS: usize> Div<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the / operation.

impl<const BITS: usize, const LIMBS: usize> Div<Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the / operation.

impl<const BITS: usize, const LIMBS: usize> Div for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the / operation.

impl<const BITS: usize, const LIMBS: usize> DivAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn div_assign(&mut self, rhs: &Uint<BITS, LIMBS>)

Performs the /= operation.

impl<const BITS: usize, const LIMBS: usize> DivAssign for Uint<BITS, LIMBS>

fn div_assign(&mut self, rhs: Uint<BITS, LIMBS>)

Performs the /= operation.

impl<const BITS: usize, const LIMBS: usize> Encodable for Uint<BITS, LIMBS>

Available on crate feature alloy-rlp only.

Allows a Uint to be serialized as RLP.

See https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/

fn length(&self) -> usize

Returns the length of the encoding of this type in bytes.

fn encode(&self, out: &mut dyn BufMut)

Encodes the type into the out buffer.

impl<const BITS: usize, const LIMBS: usize> Encodable for Uint<BITS, LIMBS>

Available on crate feature fastrlp only.

Allows a Uint to be serialized as RLP.

See https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/

fn length(&self) -> usize

fn encode(&self, out: &mut dyn BufMut)

impl<const BITS: usize, const LIMBS: usize> Encodable for Uint<BITS, LIMBS>

Available on crate feature fastrlp-04 only.

Allows a Uint to be serialized as RLP.

See https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/

fn length(&self) -> usize

fn encode(&self, out: &mut dyn BufMut)

impl<const BITS: usize, const LIMBS: usize> Encodable for Uint<BITS, LIMBS>

Available on crate feature rlp only.

Allows a Uint to be serialized as RLP.

See https://eth.wiki/en/fundamentals/rlp

fn rlp_append(&self, s: &mut RlpStream)

Append a value to the stream

fn rlp_bytes(&self) -> BytesMut

Get rlp-encoded bytes for this instance

impl<'a, const BITS: usize, const LIMBS: usize, DB: Database> Encode<'a, DB> for Uint<BITS, LIMBS>

where Vec<u8>: Encode<'a, DB>,

Available on crate feature sqlx only.

fn encode_by_ref( &self, buf: &mut <DB as Database>::ArgumentBuffer<'a>, ) -> Result<IsNull, BoxDynError>

Writes the value of self into buf without moving self.

fn encode( self, buf: &mut <DB as Database>::ArgumentBuffer<'q>, ) -> Result<IsNull, Box<dyn Error + Send + Sync>>

where Self: Sized,

Writes the value of self into buf in the expected format for the database.

fn produces(&self) -> Option<<DB as Database>::TypeInfo>

fn size_hint(&self) -> usize

impl<const BITS: usize, const LIMBS: usize> Encode for Uint<BITS, LIMBS>

Available on crate feature bincode-2 only.

fn encode<E: Encoder>(&self, encoder: &mut E) -> Result<(), EncodeError>

Encode a given type.

impl<const BITS: usize, const LIMBS: usize> Encode for Uint<BITS, LIMBS>

Available on crate feature parity-scale-codec only.

fn size_hint(&self) -> usize

u32 prefix for compact encoding + bytes needed for LE bytes representation

fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R

Convert self to a slice and then invoke the given closure with it.

fn encode_to<T>(&self, dest: &mut T)

where T: Output + ?Sized,

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<const BITS: usize, const LIMBS: usize> Encode for Uint<BITS, LIMBS>

Available on crate feature ssz only.

fn is_ssz_fixed_len() -> bool

Returns true if this object has a fixed-length.

fn ssz_fixed_len() -> usize

The number of bytes this object occupies in the fixed-length portion of the SSZ bytes.

fn ssz_bytes_len(&self) -> usize

Returns the size (in bytes) when self is serialized.

fn ssz_append(&self, buf: &mut Vec<u8>)

Append the encoding self to buf.

fn as_ssz_bytes(&self) -> Vec<u8>

Returns the full-form encoding of this object.

impl<'a, const BITS: usize, const LIMBS: usize> EncodeAsRef<'a, Uint<BITS, LIMBS>> for CompactUint<BITS, LIMBS>

Available on crate feature parity-scale-codec only.

type RefType = CompactRefUint<'a, BITS, LIMBS>

The reference type that is used for encoding.

impl<const BITS: usize, const LIMBS: usize> EncodeValue for Uint<BITS, LIMBS>

Available on crate feature der only.

fn value_len(&self) -> Result<Length>

Compute the length of this value (sans [Tag]+Length header) when encoded as ASN.1 DER.

fn encode_value(&self, writer: &mut impl Writer) -> Result<()>

Encode value (sans [Tag]+Length header) as ASN.1 DER using the provided Writer.

fn header(&self) -> Result<Header, Error>

where Self: Tagged,

Get the Header used to encode this value.

impl<const BITS: usize, const LIMBS: usize> Euclid for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn div_euclid(&self, v: &Self) -> Self

Calculates Euclidean division, the matching method for rem_euclid.

fn rem_euclid(&self, v: &Self) -> Self

Calculates the least nonnegative remainder of self (mod v).

fn div_rem_euclid(&self, v: &Self) -> (Self, Self)

Returns both the quotient and remainder from Euclidean division.

impl<const BITS: usize, const LIMBS: usize> FixedTag for Uint<BITS, LIMBS>

Available on crate feature der only.

const TAG: Tag = Tag::Integer

ASN.1 tag

impl<'a, const BITS: usize, const LIMBS: usize> From<&'a ArchivedUint<BITS, LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature rkyv only.

fn from(archived: &'a ArchivedUint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&BigInt<LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature ark-ff-04 only.

fn from(value: &BigInt<LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&BigInt<LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature ark-ff-05 only.

fn from(value: &BigInt<LIMBS>) -> Self

Converts to this type from the input type.

impl From<&BigInteger128> for Uint<128, 2>

Available on crate feature ark-ff only.

fn from(value: &BigInteger128) -> Self

Converts to this type from the input type.

impl From<&BigInteger256> for Uint<256, 4>

Available on crate feature ark-ff only.

fn from(value: &BigInteger256) -> Self

Converts to this type from the input type.

impl From<&BigInteger320> for Uint<320, 5>

Available on crate feature ark-ff only.

fn from(value: &BigInteger320) -> Self

Converts to this type from the input type.

impl From<&BigInteger384> for Uint<384, 6>

Available on crate feature ark-ff only.

fn from(value: &BigInteger384) -> Self

Converts to this type from the input type.

impl From<&BigInteger448> for Uint<448, 7>

Available on crate feature ark-ff only.

fn from(value: &BigInteger448) -> Self

Converts to this type from the input type.

impl From<&BigInteger64> for Uint<64, 1>

Available on crate feature ark-ff only.

fn from(value: &BigInteger64) -> Self

Converts to this type from the input type.

impl From<&BigInteger768> for Uint<768, 12>

Available on crate feature ark-ff only.

fn from(value: &BigInteger768) -> Self

Converts to this type from the input type.

impl From<&BigInteger832> for Uint<832, 13>

Available on crate feature ark-ff only.

fn from(value: &BigInteger832) -> Self

Converts to this type from the input type.

impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> From<&Fp<P, LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature ark-ff-04 only.

fn from(value: &Fp<P, LIMBS>) -> Self

Converts to this type from the input type.

impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> From<&Fp<P, LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature ark-ff-05 only.

fn from(value: &Fp<P, LIMBS>) -> Self

Converts to this type from the input type.

impl<P: Fp256Parameters> From<&Fp256<P>> for Uint<256, 4>

Available on crate feature ark-ff only.

fn from(value: &Fp256<P>) -> Self

Converts to this type from the input type.

impl<P: Fp320Parameters> From<&Fp320<P>> for Uint<320, 5>

Available on crate feature ark-ff only.

fn from(value: &Fp320<P>) -> Self

Converts to this type from the input type.

impl<P: Fp384Parameters> From<&Fp384<P>> for Uint<384, 6>

Available on crate feature ark-ff only.

fn from(value: &Fp384<P>) -> Self

Converts to this type from the input type.

impl<P: Fp448Parameters> From<&Fp448<P>> for Uint<448, 7>

Available on crate feature ark-ff only.

fn from(value: &Fp448<P>) -> Self

Converts to this type from the input type.

impl<P: Fp64Parameters> From<&Fp64<P>> for Uint<64, 1>

Available on crate feature ark-ff only.

fn from(value: &Fp64<P>) -> Self

Converts to this type from the input type.

impl<P: Fp768Parameters> From<&Fp768<P>> for Uint<768, 12>

Available on crate feature ark-ff only.

fn from(value: &Fp768<P>) -> Self

Converts to this type from the input type.

impl<P: Fp832Parameters> From<&Fp832<P>> for Uint<832, 13>

Available on crate feature ark-ff only.

fn from(value: &Fp832<P>) -> Self

Converts to this type from the input type.

impl From<&Uint<128, 2>> for BigInteger128

Available on crate feature ark-ff only.

fn from(value: &Uint<128, 2>) -> Self

Converts to this type from the input type.

impl From<&Uint<256, 4>> for BigInteger256

Available on crate feature ark-ff only.

fn from(value: &Uint<256, 4>) -> Self

Converts to this type from the input type.

impl From<&Uint<320, 5>> for BigInteger320

Available on crate feature ark-ff only.

fn from(value: &Uint<320, 5>) -> Self

Converts to this type from the input type.

impl From<&Uint<384, 6>> for BigInteger384

Available on crate feature ark-ff only.

fn from(value: &Uint<384, 6>) -> Self

Converts to this type from the input type.

impl From<&Uint<448, 7>> for BigInteger448

Available on crate feature ark-ff only.

fn from(value: &Uint<448, 7>) -> Self

Converts to this type from the input type.

impl From<&Uint<64, 1>> for BigInteger64

Available on crate feature ark-ff only.

fn from(value: &Uint<64, 1>) -> Self

Converts to this type from the input type.

impl From<&Uint<768, 12>> for BigInteger768

Available on crate feature ark-ff only.

fn from(value: &Uint<768, 12>) -> Self

Converts to this type from the input type.

impl From<&Uint<832, 13>> for BigInteger832

Available on crate feature ark-ff only.

fn from(value: &Uint<832, 13>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for Any

Available on crate feature der only.

fn from(uint: &Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BN

Available on crate feature bn-rs only.

fn from(value: &Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigInt

Available on crate feature num-bigint only.

fn from(value: &Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigInt<LIMBS>

Available on crate feature ark-ff-04 only.

fn from(value: &Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigInt<LIMBS>

Available on crate feature ark-ff-05 only.

fn from(value: &Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigNumber

Available on crate feature bn-rs only.

fn from(value: &Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigUint

Available on crate feature num-bigint only.

fn from(value: &Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<'a, const BITS: usize, const LIMBS: usize> From<&'a Uint<BITS, LIMBS>> for CompactRefUint<'a, BITS, LIMBS>

Available on crate feature parity-scale-codec only.

fn from(v: &'a Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for Int

Available on crate feature der only.

fn from(uint: &Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for Uint

Available on crate feature der only.

fn from(uint: &Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for f32

fn from(value: &Uint<BITS, LIMBS>) -> Self

Approximate single precision float.

Returns f32::INFINITY if the value is too large to represent.

impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for f64

fn from(value: &Uint<BITS, LIMBS>) -> Self

Approximate double precision float.

Returns f64::INFINITY if the value is too large to represent.

impl<const BITS: usize, const LIMBS: usize> From<ArchivedUint<BITS, LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature rkyv only.

fn from(archived: ArchivedUint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<BigInt<LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature ark-ff-04 only.

fn from(value: BigInt<LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<BigInt<LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature ark-ff-05 only.

fn from(value: BigInt<LIMBS>) -> Self

Converts to this type from the input type.

impl From<BigInteger128> for Uint<128, 2>

Available on crate feature ark-ff only.

fn from(value: BigInteger128) -> Self

Converts to this type from the input type.

impl From<BigInteger256> for Uint<256, 4>

Available on crate feature ark-ff only.

fn from(value: BigInteger256) -> Self

Converts to this type from the input type.

impl From<BigInteger320> for Uint<320, 5>

Available on crate feature ark-ff only.

fn from(value: BigInteger320) -> Self

Converts to this type from the input type.

impl From<BigInteger384> for Uint<384, 6>

Available on crate feature ark-ff only.

fn from(value: BigInteger384) -> Self

Converts to this type from the input type.

impl From<BigInteger448> for Uint<448, 7>

Available on crate feature ark-ff only.

fn from(value: BigInteger448) -> Self

Converts to this type from the input type.

impl From<BigInteger64> for Uint<64, 1>

Available on crate feature ark-ff only.

fn from(value: BigInteger64) -> Self

Converts to this type from the input type.

impl From<BigInteger768> for Uint<768, 12>

Available on crate feature ark-ff only.

fn from(value: BigInteger768) -> Self

Converts to this type from the input type.

impl From<BigInteger832> for Uint<832, 13>

Available on crate feature ark-ff only.

fn from(value: BigInteger832) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Bits<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn from(value: Bits<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<CompactUint<BITS, LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature parity-scale-codec only.

fn from(v: CompactUint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> From<Fp<P, LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature ark-ff-04 only.

fn from(value: Fp<P, LIMBS>) -> Self

Converts to this type from the input type.

impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> From<Fp<P, LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature ark-ff-05 only.

fn from(value: Fp<P, LIMBS>) -> Self

Converts to this type from the input type.

impl<P: Fp256Parameters> From<Fp256<P>> for Uint<256, 4>

Available on crate feature ark-ff only.

fn from(value: Fp256<P>) -> Self

Converts to this type from the input type.

impl<P: Fp320Parameters> From<Fp320<P>> for Uint<320, 5>

Available on crate feature ark-ff only.

fn from(value: Fp320<P>) -> Self

Converts to this type from the input type.

impl<P: Fp384Parameters> From<Fp384<P>> for Uint<384, 6>

Available on crate feature ark-ff only.

fn from(value: Fp384<P>) -> Self

Converts to this type from the input type.

impl<P: Fp448Parameters> From<Fp448<P>> for Uint<448, 7>

Available on crate feature ark-ff only.

fn from(value: Fp448<P>) -> Self

Converts to this type from the input type.

impl<P: Fp64Parameters> From<Fp64<P>> for Uint<64, 1>

Available on crate feature ark-ff only.

fn from(value: Fp64<P>) -> Self

Converts to this type from the input type.

impl<P: Fp768Parameters> From<Fp768<P>> for Uint<768, 12>

Available on crate feature ark-ff only.

fn from(value: Fp768<P>) -> Self

Converts to this type from the input type.

impl<P: Fp832Parameters> From<Fp832<P>> for Uint<832, 13>

Available on crate feature ark-ff only.

fn from(value: Fp832<P>) -> Self

Converts to this type from the input type.

impl From<Uint<128, 2>> for BigInteger128

Available on crate feature ark-ff only.

fn from(value: Uint<128, 2>) -> Self

Converts to this type from the input type.

impl From<Uint<128, 2>> for U128

Available on crate feature primitive-types only.

fn from(value: U128) -> Self

Converts to this type from the input type.

impl From<Uint<256, 4>> for BigInteger256

Available on crate feature ark-ff only.

fn from(value: Uint<256, 4>) -> Self

Converts to this type from the input type.

impl From<Uint<256, 4>> for U256

Available on crate feature primitive-types only.

fn from(value: U256) -> Self

Converts to this type from the input type.

impl From<Uint<320, 5>> for BigInteger320

Available on crate feature ark-ff only.

fn from(value: Uint<320, 5>) -> Self

Converts to this type from the input type.

impl From<Uint<384, 6>> for BigInteger384

Available on crate feature ark-ff only.

fn from(value: Uint<384, 6>) -> Self

Converts to this type from the input type.

impl From<Uint<448, 7>> for BigInteger448

Available on crate feature ark-ff only.

fn from(value: Uint<448, 7>) -> Self

Converts to this type from the input type.

impl From<Uint<512, 8>> for U512

Available on crate feature primitive-types only.

fn from(value: U512) -> Self

Converts to this type from the input type.

impl From<Uint<64, 1>> for BigInteger64

Available on crate feature ark-ff only.

fn from(value: Uint<64, 1>) -> Self

Converts to this type from the input type.

impl From<Uint<768, 12>> for BigInteger768

Available on crate feature ark-ff only.

fn from(value: Uint<768, 12>) -> Self

Converts to this type from the input type.

impl From<Uint<832, 13>> for BigInteger832

Available on crate feature ark-ff only.

fn from(value: Uint<832, 13>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for Any

Available on crate feature der only.

fn from(uint: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BN

Available on crate feature bn-rs only.

fn from(value: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigDecimal

Available on crate feature bigdecimal only.

fn from(value: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigInt

Available on crate feature num-bigint only.

fn from(value: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigInt<LIMBS>

Available on crate feature ark-ff-04 only.

fn from(value: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigInt<LIMBS>

Available on crate feature ark-ff-05 only.

fn from(value: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigNumber

Available on crate feature bn-rs only.

fn from(value: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigUint

Available on crate feature num-bigint only.

fn from(value: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for Bits<BITS, LIMBS>

fn from(value: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for CompactUint<BITS, LIMBS>

Available on crate feature parity-scale-codec only.

fn from(v: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for Int

Available on crate feature der only.

fn from(uint: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for Uint

Available on crate feature der only.

fn from(uint: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for f32

fn from(value: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for f64

fn from(value: Uint<BITS, LIMBS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const LIMBS: usize> FromBytes for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

type Bytes = [u8]

fn from_le_bytes(bytes: &[u8]) -> Self

Create a number from its representation as a byte array in little endian.

fn from_be_bytes(bytes: &[u8]) -> Self

Create a number from its representation as a byte array in big endian.

fn from_ne_bytes(bytes: &Self::Bytes) -> Self

Create a number from its memory representation as a byte array in native endianness.

impl<const BITS: usize, const LIMBS: usize> FromPrimitive for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl<'a, const BITS: usize, const LIMBS: usize> FromPyObject<'a> for Uint<BITS, LIMBS>

Available on crate feature pyo3 only.

fn extract_bound(ob: &Bound<'a, PyAny>) -> PyResult<Self>

Extracts Self from the bound smart pointer obj.

impl<'a, const BITS: usize, const LIMBS: usize> FromSql<'a> for Uint<BITS, LIMBS>

Available on crate feature postgres only.

Convert from Postgres types.

See ToSql for details.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be created from the specified Postgres Type.

fn from_sql( ty: &Type, raw: &'a [u8], ) -> Result<Self, Box<dyn Error + Sync + Send>>

Creates a new value of this type from a buffer of data of the specified Postgres Type in its binary format.

fn from_sql_null(ty: &Type) -> Result<Self, Box<dyn Error + Send + Sync>>

Creates a new value of this type from a NULL SQL value.

fn from_sql_nullable( ty: &Type, raw: Option<&'a [u8]>, ) -> Result<Self, Box<dyn Error + Send + Sync>>

A convenience function that delegates to from_sql and from_sql_null depending on the value of raw.

impl<const BITS: usize, const LIMBS: usize, Db: Backend> FromSql<Binary, Db> for Uint<BITS, LIMBS>

where *const [u8]: FromSql<Binary, Db>,

Available on crate feature diesel only.

fn from_sql(bytes: Db::RawValue<'_>) -> DeserResult<Self>

See the trait documentation.

fn from_nullable_sql( bytes: Option<<DB as Backend>::RawValue<'_>>, ) -> Result<Self, Box<dyn Error + Send + Sync>>

A specialized variant of from_sql for handling null values.

impl<const BITS: usize, const LIMBS: usize> FromStr for Uint<BITS, LIMBS>

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(src: &str) -> Result<Self, Self::Err>

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

impl<const BITS: usize, const LIMBS: usize> HasCompact for Uint<BITS, LIMBS>

Available on crate feature parity-scale-codec only.

type Type = CompactUint<BITS, LIMBS>

The compact type; this can be

impl<const BITS: usize, const LIMBS: usize> Hash for Uint<BITS, LIMBS>

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const BITS: usize, const LIMBS: usize> Integer for Uint<BITS, LIMBS>

Available on crate feature num-integer only.

fn div_floor(&self, other: &Self) -> Self

Floored integer division.

fn mod_floor(&self, other: &Self) -> Self

Floored integer modulo, satisfying:

fn gcd(&self, other: &Self) -> Self

Greatest Common Divisor (GCD).

fn lcm(&self, other: &Self) -> Self

Lowest Common Multiple (LCM).

fn is_multiple_of(&self, other: &Self) -> bool

Returns true if self is a multiple of other.

fn is_even(&self) -> bool

Returns true if the number is even.

fn is_odd(&self) -> bool

Returns true if the number is odd.

fn div_rem(&self, other: &Self) -> (Self, Self)

Simultaneous truncated integer division and modulus. Returns (quotient, remainder).

fn div_ceil(&self, other: &Self) -> Self

Ceiled integer division.

fn div_mod_floor(&self, other: &Self) -> (Self, Self)

Simultaneous floored integer division and modulus. Returns (quotient, remainder).

fn extended_gcd(&self, other: &Self) -> ExtendedGcd<Self>

Greatest common divisor and Bézout coefficients.

fn dec(&mut self)

Decrements self by one.

fn inc(&mut self)

Increments self by one.

fn gcd_lcm(&self, other: &Self) -> (Self, Self)

Greatest Common Divisor (GCD) and Lowest Common Multiple (LCM) together.

fn divides(&self, other: &Self) -> bool

👎Deprecated:

Please use is_multiple_of instead

Deprecated, use is_multiple_of instead.

fn next_multiple_of(&self, other: &Self) -> Self

where Self: Clone,

Rounds up to nearest multiple of argument.

fn prev_multiple_of(&self, other: &Self) -> Self

where Self: Clone,

Rounds down to nearest multiple of argument.

impl<'a, const BITS: usize, const LIMBS: usize> IntoPyObject<'a> for &Uint<BITS, LIMBS>

Available on crate feature pyo3 only.

type Target = PyInt

The Python output type

type Output = Bound<'a, <&Uint<BITS, LIMBS> as IntoPyObject<'a>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject(self, py: Python<'a>) -> Result<Self::Output, Self::Error>

Performs the conversion.

impl<'a, const BITS: usize, const LIMBS: usize> IntoPyObject<'a> for Uint<BITS, LIMBS>

Available on crate feature pyo3 only.

type Target = PyInt

The Python output type

type Output = Bound<'a, <Uint<BITS, LIMBS> as IntoPyObject<'a>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject(self, py: Python<'a>) -> Result<Self::Output, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> Inv for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

type Output = Option<Uint<BITS, LIMBS>>

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

impl<const BITS: usize, const LIMBS: usize> LowerHex for Uint<BITS, LIMBS>

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

Formats the value using the given formatter.

impl<const BITS: usize, const LIMBS: usize> MaxEncodedLen for Uint<BITS, LIMBS>

Available on crate feature parity-scale-codec only.

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl<const BITS: usize, const LIMBS: usize> MaxEncodedLenAssoc for Uint<BITS, LIMBS>

Available on crate feature alloy-rlp only.

const LEN: usize

The maximum length.

impl<const BITS: usize, const LIMBS: usize> Mul<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the * operation.

impl<const BITS: usize, const LIMBS: usize> Mul<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the * operation.

impl<const BITS: usize, const LIMBS: usize> Mul<Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the * operation.

impl<const BITS: usize, const LIMBS: usize> Mul for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the * operation.

impl<const BITS: usize, const LIMBS: usize> MulAdd for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

type Output = Uint<BITS, LIMBS>

The resulting type after applying the fused multiply-add.

fn mul_add(self, a: Self, b: Self) -> Self::Output

Performs the fused multiply-add operation (self * a) + b

impl<const BITS: usize, const LIMBS: usize> MulAddAssign for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn mul_add_assign(&mut self, a: Self, b: Self)

Performs the fused multiply-add assignment operation *self = (*self * a) + b

impl<const BITS: usize, const LIMBS: usize> MulAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn mul_assign(&mut self, rhs: &Uint<BITS, LIMBS>)

Performs the *= operation.

impl<const BITS: usize, const LIMBS: usize> MulAssign for Uint<BITS, LIMBS>

fn mul_assign(&mut self, rhs: Uint<BITS, LIMBS>)

Performs the *= operation.

impl<const BITS: usize, const LIMBS: usize> Neg for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const BITS: usize, const LIMBS: usize> Neg for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const BITS: usize, const LIMBS: usize> Not for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

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

type Output = Uint<BITS, LIMBS>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const BITS: usize, const LIMBS: usize> Num for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

type FromStrRadixErr = ParseError

fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl<const BITS: usize, const LIMBS: usize> NumCast for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn from<T: ToPrimitive>(n: T) -> Option<Self>

Creates a number from another value that can be converted into a primitive via the ToPrimitive trait. If the source value cannot be represented by the target type, then None is returned.

impl<const BITS: usize, const LIMBS: usize> Octal for Uint<BITS, LIMBS>

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

Formats the value using the given formatter.

impl<const BITS: usize, const LIMBS: usize> One for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

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

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

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

fn cmp(&self, rhs: &Self) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const BITS: usize, const LIMBS: usize> OverflowingAdd for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn overflowing_add(&self, v: &Self) -> (Self, bool)

Returns a tuple of the sum along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

impl<const BITS: usize, const LIMBS: usize> OverflowingMul for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn overflowing_mul(&self, v: &Self) -> (Self, bool)

Returns a tuple of the product along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

impl<const BITS: usize, const LIMBS: usize> OverflowingSub for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn overflowing_sub(&self, v: &Self) -> (Self, bool)

Returns a tuple of the difference along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

impl<const BITS: usize, const LIMBS: usize> PartialEq<i128> for Uint<BITS, LIMBS>

fn eq(&self, other: &i128) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const BITS: usize, const LIMBS: usize> PartialEq<i16> for Uint<BITS, LIMBS>

fn eq(&self, other: &i16) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const BITS: usize, const LIMBS: usize> PartialEq<i32> for Uint<BITS, LIMBS>

fn eq(&self, other: &i32) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const BITS: usize, const LIMBS: usize> PartialEq<i64> for Uint<BITS, LIMBS>

fn eq(&self, other: &i64) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const BITS: usize, const LIMBS: usize> PartialEq<i8> for Uint<BITS, LIMBS>

fn eq(&self, other: &i8) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const BITS: usize, const LIMBS: usize> PartialEq<isize> for Uint<BITS, LIMBS>

fn eq(&self, other: &isize) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const BITS: usize, const LIMBS: usize> PartialEq<u128> for Uint<BITS, LIMBS>

fn eq(&self, other: &u128) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const BITS: usize, const LIMBS: usize> PartialEq<u16> for Uint<BITS, LIMBS>

fn eq(&self, other: &u16) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const BITS: usize, const LIMBS: usize> PartialEq<u32> for Uint<BITS, LIMBS>

fn eq(&self, other: &u32) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const BITS: usize, const LIMBS: usize> PartialEq<u64> for Uint<BITS, LIMBS>

fn eq(&self, other: &u64) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const BITS: usize, const LIMBS: usize> PartialEq<u8> for Uint<BITS, LIMBS>

fn eq(&self, other: &u8) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

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

fn eq(&self, other: &usize) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<const BITS: usize, const LIMBS: usize> PartialOrd<i128> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &i128) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd<i16> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &i16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd<i32> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &i32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd<i64> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &i64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd<i8> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &i8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd<isize> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &isize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd<u128> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &u128) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd<u16> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &u16) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd<u32> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &u32) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd<u64> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &u64) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd<u8> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &u8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd<usize> for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &usize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> PartialOrd for Uint<BITS, LIMBS>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BITS: usize, const LIMBS: usize> Pow<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

type Output = Uint<BITS, LIMBS>

The result after applying the operator.

fn pow(self, rhs: Self) -> Self::Output

Returns self to the power rhs.

impl<const BITS: usize, const LIMBS: usize> PrimInt for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn swap_bytes(self) -> Self

Note: This is not well-defined when BITS % 8 != 0.

fn count_ones(self) -> u32

Returns the number of ones in the binary representation of self.

fn count_zeros(self) -> u32

Returns the number of zeros in the binary representation of self.

fn leading_zeros(self) -> u32

Returns the number of leading zeros in the binary representation of self.

fn leading_ones(self) -> u32

Returns the number of leading ones in the binary representation of self.

fn trailing_zeros(self) -> u32

Returns the number of trailing zeros in the binary representation of self.

fn trailing_ones(self) -> u32

Returns the number of trailing ones in the binary representation of self.

fn rotate_left(self, n: u32) -> Self

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer.

fn rotate_right(self, n: u32) -> Self

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer.

fn signed_shl(self, n: u32) -> Self

Shifts the bits to the left by a specified amount, n, filling zeros in the least significant bits.

fn signed_shr(self, n: u32) -> Self

Shifts the bits to the right by a specified amount, n, copying the “sign bit” in the most significant bits even for unsigned types.

fn unsigned_shl(self, n: u32) -> Self

Shifts the bits to the left by a specified amount, n, filling zeros in the least significant bits.

fn unsigned_shr(self, n: u32) -> Self

Shifts the bits to the right by a specified amount, n, filling zeros in the most significant bits.

fn reverse_bits(self) -> Self

Reverses the order of bits in the integer.

fn from_be(x: Self) -> Self

Convert an integer from big endian to the target’s endianness.

fn from_le(x: Self) -> Self

Convert an integer from little endian to the target’s endianness.

fn to_be(self) -> Self

Convert self to big endian from the target’s endianness.

fn to_le(self) -> Self

Convert self to little endian from the target’s endianness.

fn pow(self, exp: u32) -> Self

Raises self to the power of exp, using exponentiation by squaring.

impl<'a, const BITS: usize, const LIMBS: usize> Product<&'a Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn product<I>(iter: I) -> Self

where I: Iterator<Item = &'a Self>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<const BITS: usize, const LIMBS: usize> Product for Uint<BITS, LIMBS>

fn product<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<const BITS: usize, const LIMBS: usize, Db, St> Queryable<St, Db> for Uint<BITS, LIMBS>

where Db: Backend, St: SingleValue, Self: FromSql<St, Db>,

Available on crate feature diesel only.

type Row = Uint<BITS, LIMBS>

The Rust type you’d like to map from.

fn build(row: Self::Row) -> DeserResult<Self>

Construct an instance of this type

impl<const BITS: usize, const LIMBS: usize> Rem<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the % operation.

impl<const BITS: usize, const LIMBS: usize> Rem<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the % operation.

impl<const BITS: usize, const LIMBS: usize> Rem<Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the % operation.

impl<const BITS: usize, const LIMBS: usize> Rem for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the % operation.

impl<const BITS: usize, const LIMBS: usize> RemAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn rem_assign(&mut self, rhs: &Uint<BITS, LIMBS>)

Performs the %= operation.

impl<const BITS: usize, const LIMBS: usize> RemAssign for Uint<BITS, LIMBS>

fn rem_assign(&mut self, rhs: Uint<BITS, LIMBS>)

Performs the %= operation.

impl<const BITS: usize, const LIMBS: usize> Saturating for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn saturating_add(self, v: Self) -> Self

Saturating addition operator. Returns a+b, saturating at the numeric bounds instead of overflowing.

fn saturating_sub(self, v: Self) -> Self

Saturating subtraction operator. Returns a-b, saturating at the numeric bounds instead of overflowing.

impl<const BITS: usize, const LIMBS: usize> SaturatingAdd for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn saturating_add(&self, v: &Self) -> Self

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl<const BITS: usize, const LIMBS: usize> SaturatingMul for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn saturating_mul(&self, v: &Self) -> Self

Saturating multiplication. Computes self * other, saturating at the relevant high or low boundary of the type.

impl<const BITS: usize, const LIMBS: usize> SaturatingSub for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn saturating_sub(&self, v: &Self) -> Self

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

impl<S: Fallible + ?Sized, const BITS: usize, const LIMBS: usize> Serialize<S> for Uint<BITS, LIMBS>

Available on crate feature rkyv only.

fn serialize( &self, serializer: &mut S, ) -> Result<[(); LIMBS], <S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<const BITS: usize, const LIMBS: usize> Serialize for Uint<BITS, LIMBS>

Available on crate feature serde only.

Serialize a Uint value.

For human readable formats a 0x prefixed lower case hex string is used. For binary formats a byte array is used. Leading zeros are included.

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl<const BITS: usize, const LIMBS: usize> Shl<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: &Self) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<&i16> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: &i16) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<&i32> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<&i64> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: &i64) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<&i8> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: &i8) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<&isize> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<&u16> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: &u16) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<&u32> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<&u64> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: &u64) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<&u8> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: &u8) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<&usize> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<i16> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<i32> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<i64> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<i8> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<isize> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<u16> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<u32> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<u64> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> Shl<u8> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> Self::Output

Performs the << operation.

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

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Self::Output

Performs the << operation.

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

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&i16> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: &i16)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&i32> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: &i32)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&i64> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: &i64)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&i8> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: &i8)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&isize> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: &isize)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&u16> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: &u16)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&u32> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&u64> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: &u64)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&u8> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: &u8)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&usize> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: &usize)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<i16> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: i16)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<i32> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<i64> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: i64)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<i8> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: i8)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<isize> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<u16> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: u16)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<u32> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<u64> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: u64)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<u8> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: u8)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign<usize> for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> ShlAssign for Uint<BITS, LIMBS>

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const BITS: usize, const LIMBS: usize> Shr<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: &Self) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<&i16> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i16) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<&i32> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<&i64> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i64) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<&i8> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: &i8) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<&isize> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<&u16> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u16) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<&u32> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<&u64> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u64) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<&u8> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: &u8) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<&usize> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<i16> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<i32> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<i64> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<i8> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<isize> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<u16> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<u32> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<u64> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> Shr<u8> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> Self::Output

Performs the >> operation.

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

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation.

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

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<&i16> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: &i16)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<&i32> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: &i32)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<&i64> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: &i64)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<&i8> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: &i8)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<&isize> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: &isize)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<&u16> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: &u16)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<&u32> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<&u64> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: &u64)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<&u8> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: &u8)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<&usize> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: &usize)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<i16> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: i16)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<i32> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<i64> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: i64)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<i8> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: i8)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<isize> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<u16> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: u16)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<u32> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<u64> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: u64)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<u8> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: u8)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign<usize> for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> ShrAssign for Uint<BITS, LIMBS>

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const BITS: usize, const LIMBS: usize> Structable for Uint<BITS, LIMBS>

Available on crate feature valuable only.

fn definition(&self) -> StructDef<'_>

Returns the struct’s definition.

impl<const BITS: usize, const LIMBS: usize> Sub<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the - operator.

fn sub(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the - operation.

impl<const BITS: usize, const LIMBS: usize> Sub<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the - operator.

fn sub(self, rhs: &Uint<BITS, LIMBS>) -> Self::Output

Performs the - operation.

impl<const BITS: usize, const LIMBS: usize> Sub<Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the - operator.

fn sub(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the - operation.

impl<const BITS: usize, const LIMBS: usize> Sub for Uint<BITS, LIMBS>

type Output = Uint<BITS, LIMBS>

The resulting type after applying the - operator.

fn sub(self, rhs: Uint<BITS, LIMBS>) -> Self::Output

Performs the - operation.

impl<const BITS: usize, const LIMBS: usize> SubAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn sub_assign(&mut self, rhs: &Uint<BITS, LIMBS>)

Performs the -= operation.

impl<const BITS: usize, const LIMBS: usize> SubAssign for Uint<BITS, LIMBS>

fn sub_assign(&mut self, rhs: Uint<BITS, LIMBS>)

Performs the -= operation.

impl<'a, const BITS: usize, const LIMBS: usize> Sum<&'a Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = &'a Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<const BITS: usize, const LIMBS: usize> Sum for Uint<BITS, LIMBS>

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<const BITS: usize, const LIMBS: usize> ToBytes for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

type Bytes = Vec<u8>

fn to_le_bytes(&self) -> Self::Bytes

Return the memory representation of this number as a byte array in little-endian byte order.

fn to_be_bytes(&self) -> Self::Bytes

Return the memory representation of this number as a byte array in big-endian byte order.

fn to_ne_bytes(&self) -> Self::Bytes

Return the memory representation of this number as a byte array in native byte order.

impl<const BITS: usize, const LIMBS: usize> ToPrimitive for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl<const BITS: usize, const LIMBS: usize, Db> ToSql<Binary, Db> for Uint<BITS, LIMBS>

where for<'c> Db: Backend<BindCollector<'c> = RawBytesBindCollector<Db>>,

Available on crate feature diesel only.

fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Db>) -> SerResult

See the trait documentation.

impl<const BITS: usize, const LIMBS: usize, Db> ToSql<Nullable<Binary>, Db> for Uint<BITS, LIMBS>

where Db: Backend, Self: ToSql<Binary, Db>,

Available on crate feature diesel only.

fn to_sql<'a>(&'a self, out: &mut Output<'a, '_, Db>) -> SerResult

See the trait documentation.

impl<const BITS: usize, const LIMBS: usize> ToSql for Uint<BITS, LIMBS>

Available on crate feature postgres only.

Convert to Postgres types.

Compatible Postgres data types are:

• BOOL, SMALLINT, INTEGER, BIGINT which are 1, 16, 32 and 64 bit signed integers respectively.
• OID which is a 32 bit unsigned integer.
• FLOAT, DOUBLE PRECISION which are 32 and 64 bit floating point.
• DECIMAL and NUMERIC, which are variable length.
• MONEY which is a 64 bit integer with two decimals.
• BYTEA, BIT, VARBIT interpreted as a big-endian binary number.
• CHAR, VARCHAR, TEXT as 0x-prefixed big-endian hex strings.
• JSON, JSONB as a hex string compatible with the Serde serialization.

Note: Uints are never null, use Option<Uint> instead.

Errors

Returns an error when trying to convert to a value that is too small to fit the number. Note that this depends on the value, not the type, so a Uint<256> can be stored in a SMALLINT column, as long as the values are less than $2^{16}$.

Implementation details

The Postgres binary formats are used in the wire-protocol and the the COPY BINARY command, but they have very little documentation. You are pointed to the source code, for example this is the implementation of the the NUMERIC type serializer: numeric.c.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be converted to the specified Postgres Type.

fn to_sql( &self, ty: &Type, out: &mut BytesMut, ) -> Result<IsNull, Box<dyn Error + Sync + Send + 'static>>

Converts the value of self into the binary format of the specified Postgres Type, appending it to out.

fn to_sql_checked( &self, ty: &Type, out: &mut BytesMut, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

An adaptor method used internally by Rust-Postgres.

fn encode_format(&self, _ty: &Type) -> Format

Specify the encode format

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Any> for Uint<BITS, LIMBS>

Available on crate feature der only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(any: &Any) -> Result<Self>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&BN> for Uint<BITS, LIMBS>

Available on crate feature bn-rs only.

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: &BN) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&BigInt> for Uint<BITS, LIMBS>

Available on crate feature num-bigint only.

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: &BigInt) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&BigNumber> for Uint<BITS, LIMBS>

Available on crate feature bn-rs only.

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: &BigNumber) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&BigUint> for Uint<BITS, LIMBS>

Available on crate feature num-bigint only.

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: &BigUint) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Int> for Uint<BITS, LIMBS>

Available on crate feature der only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(int: &Int) -> Result<Self>

Performs the conversion.

impl<P: Fp256Parameters> TryFrom<&Uint<256, 4>> for Fp256<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: &Uint<256, 4>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp320Parameters> TryFrom<&Uint<320, 5>> for Fp320<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: &Uint<320, 5>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp384Parameters> TryFrom<&Uint<384, 6>> for Fp384<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: &Uint<384, 6>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp448Parameters> TryFrom<&Uint<448, 7>> for Fp448<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: &Uint<448, 7>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp64Parameters> TryFrom<&Uint<64, 1>> for Fp64<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: &Uint<64, 1>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp768Parameters> TryFrom<&Uint<768, 12>> for Fp768<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: &Uint<768, 12>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp832Parameters> TryFrom<&Uint<832, 13>> for Fp832<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: &Uint<832, 13>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for Fp<P, LIMBS>

Available on crate feature ark-ff-04 only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for Fp<P, LIMBS>

Available on crate feature ark-ff-05 only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for bool

type Error = FromUintError<bool>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for i128

type Error = FromUintError<i128>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for i16

type Error = FromUintError<i16>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for i32

type Error = FromUintError<i32>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for i64

type Error = FromUintError<i64>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for i8

type Error = FromUintError<i8>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for isize

type Error = FromUintError<isize>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for u128

type Error = FromUintError<u128>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for u16

type Error = FromUintError<u16>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for u32

type Error = FromUintError<u32>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for u64

type Error = FromUintError<u64>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for u8

type Error = FromUintError<u8>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for usize

type Error = FromUintError<usize>

The type returned in the event of a conversion error.

fn try_from(value: &Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<&Uint> for Uint<BITS, LIMBS>

Available on crate feature der only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(uint: &DerUint) -> Result<Self>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Any> for Uint<BITS, LIMBS>

Available on crate feature der only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(obj: Any) -> Result<Self>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<AnyRef<'_>> for Uint<BITS, LIMBS>

Available on crate feature der only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(any: AnyRef<'_>) -> Result<Self>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<BN> for Uint<BITS, LIMBS>

Available on crate feature bn-rs only.

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: BN) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<BigDecimal> for Uint<BITS, LIMBS>

Available on crate feature bigdecimal only.

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: BigDecimal) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<BigInt> for Uint<BITS, LIMBS>

Available on crate feature num-bigint only.

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: BigInt) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<BigNumber> for Uint<BITS, LIMBS>

Available on crate feature bn-rs only.

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: BigNumber) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<BigUint> for Uint<BITS, LIMBS>

Available on crate feature num-bigint only.

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: BigUint) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Int> for Uint<BITS, LIMBS>

Available on crate feature der only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(obj: Int) -> Result<Self>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<IntRef<'_>> for Uint<BITS, LIMBS>

Available on crate feature der only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(int: IntRef<'_>) -> Result<Self>

Performs the conversion.

impl<P: Fp256Parameters> TryFrom<Uint<256, 4>> for Fp256<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: Uint<256, 4>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp320Parameters> TryFrom<Uint<320, 5>> for Fp320<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: Uint<320, 5>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp384Parameters> TryFrom<Uint<384, 6>> for Fp384<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: Uint<384, 6>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp448Parameters> TryFrom<Uint<448, 7>> for Fp448<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: Uint<448, 7>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp64Parameters> TryFrom<Uint<64, 1>> for Fp64<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: Uint<64, 1>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp768Parameters> TryFrom<Uint<768, 12>> for Fp768<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: Uint<768, 12>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: Fp832Parameters> TryFrom<Uint<832, 13>> for Fp832<P>

Available on crate feature ark-ff only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: Uint<832, 13>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for Fp<P, LIMBS>

Available on crate feature ark-ff-04 only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for Fp<P, LIMBS>

Available on crate feature ark-ff-05 only.

type Error = ToFieldError

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, ToFieldError>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for bool

type Error = FromUintError<bool>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for i128

type Error = FromUintError<i128>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for i16

type Error = FromUintError<i16>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for i32

type Error = FromUintError<i32>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for i64

type Error = FromUintError<i64>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for i8

type Error = FromUintError<i8>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for isize

type Error = FromUintError<isize>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for u128

type Error = FromUintError<u128>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for u16

type Error = FromUintError<u16>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for u32

type Error = FromUintError<u32>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for u64

type Error = FromUintError<u64>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for u8

type Error = FromUintError<u8>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for usize

type Error = FromUintError<usize>

The type returned in the event of a conversion error.

fn try_from(value: Uint<BITS, LIMBS>) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<Uint> for Uint<BITS, LIMBS>

Available on crate feature der only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(obj: DerUint) -> Result<Self>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<UintRef<'_>> for Uint<BITS, LIMBS>

Available on crate feature der only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(uint: UintRef<'_>) -> Result<Self>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<bool> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: bool) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<f32> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: f32) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<f64> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: f64) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<i128> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: i128) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<i16> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: i16) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<i32> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<i64> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: i64) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<i8> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: i8) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<isize> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: isize) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<u128> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: u128) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<u16> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: u16) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<u32> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<u64> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: u64) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<u8> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize> TryFrom<usize> for Uint<BITS, LIMBS>

type Error = ToUintError<Uint<BITS, LIMBS>>

The type returned in the event of a conversion error.

fn try_from(value: usize) -> Result<Self, Self::Error>

Performs the conversion.

impl<const BITS: usize, const LIMBS: usize, DB: Database> Type<DB> for Uint<BITS, LIMBS>

where Vec<u8>: Type<DB>,

Available on crate feature sqlx only.

fn type_info() -> DB::TypeInfo

Returns the canonical SQL type for this Rust type.

fn compatible(ty: &DB::TypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type.

impl<const BITS: usize, const LIMBS: usize> UpperHex for Uint<BITS, LIMBS>

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

Formats the value using the given formatter.

impl<const BITS: usize, const LIMBS: usize> Valuable for Uint<BITS, LIMBS>

Available on crate feature valuable only.

fn as_value(&self) -> Value<'_>

Converts self into a Value instance.

fn visit(&self, visitor: &mut dyn Visit)

Calls the relevant method on Visit to extract data from self.

fn visit_slice(slice: &[Self], visit: &mut dyn Visit)

where Self: Sized,

Calls Visit::visit_primitive_slice() with self.

impl<const BITS: usize, const LIMBS: usize> ValueOrd for Uint<BITS, LIMBS>

Available on crate feature der only.

fn value_cmp(&self, other: &Self) -> Result<Ordering>

Return an Ordering between value portion of TLV-encoded self and other when serialized as ASN.1 DER.

impl<const BITS: usize, const LIMBS: usize> WrappingAdd for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

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

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

impl<const BITS: usize, const LIMBS: usize> WrappingMul for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

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

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

impl<const BITS: usize, const LIMBS: usize> WrappingNeg for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn wrapping_neg(&self) -> Self

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

impl<const BITS: usize, const LIMBS: usize> WrappingShl for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn wrapping_shl(&self, rhs: u32) -> Self

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<const BITS: usize, const LIMBS: usize> WrappingShr for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn wrapping_shr(&self, rhs: u32) -> Self

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<const BITS: usize, const LIMBS: usize> WrappingSub for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

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

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

impl<const BITS: usize, const LIMBS: usize> Zero for Uint<BITS, LIMBS>

Available on crate feature num-traits only.

fn zero() -> Self

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<const BITS: usize, const LIMBS: usize> Zeroable for Uint<BITS, LIMBS>

Available on crate feature bytemuck only.

fn zeroed() -> Self

Calls zeroed.

impl<const BITS: usize, const LIMBS: usize> Zeroize for Uint<BITS, LIMBS>

Available on crate feature zeroize only.

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

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

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

impl<const BITS: usize, const LIMBS: usize> MaxEncodedLen<{ Self::BYTES + length_of_length(Self::BYTES) }> for Uint<BITS, LIMBS>

Available on crate feature alloy-rlp only.

impl Pod for Uint<{ 1024 }, 16>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 128 }, 2>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 192 }, 3>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 256 }, 4>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 320 }, 5>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 384 }, 6>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 448 }, 7>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 512 }, 8>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 576 }, 9>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 64 }, 1>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 640 }, 10>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 704 }, 11>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 768 }, 12>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 832 }, 13>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 896 }, 14>

Available on crate feature bytemuck only.

impl Pod for Uint<{ 960 }, 15>

Available on crate feature bytemuck only.

impl<const BITS: usize, const LIMBS: usize> StructuralPartialEq for Uint<BITS, LIMBS>

impl<const BITS: usize, const LIMBS: usize, T> UintTryFrom<T> for Uint<BITS, LIMBS>

where Self: TryFrom<T, Error = ToUintError<Self>>,

Blanket implementation for any type that implements TryFrom<Uint>.

impl<const BITS: usize, const LIMBS: usize, const BITS_SRC: usize, const LIMBS_SRC: usize> UintTryFrom<Uint<BITS_SRC, LIMBS_SRC>> for Uint<BITS, LIMBS>

impl<const BITS: usize, const LIMBS: usize, T> UintTryTo<T> for Uint<BITS, LIMBS>

where T: for<'a> TryFrom<&'a Self, Error = FromUintError<T>>,

impl<const BITS: usize, const LIMBS: usize, const BITS_DST: usize, const LIMBS_DST: usize> UintTryTo<Uint<BITS_DST, LIMBS_DST>> for Uint<BITS, LIMBS>

impl<const BITS: usize, const LIMBS: usize> Unsigned for Uint<BITS, LIMBS>

Available on crate feature num-traits only.