pub struct Uint<const BITS: usize, const LIMBS: usize> { /* private fields */ }
Expand description
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
andu64::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 inUint
. Uint::to_le_bytes
andUint::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 anUint
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§
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub fn abs_diff(self, other: Self) -> Self
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$.
sourcepub fn checked_add(self, rhs: Self) -> Option<Self>
pub fn checked_add(self, rhs: Self) -> Option<Self>
Computes self + rhs
, returning None
if overflow occurred.
sourcepub fn checked_neg(self) -> Option<Self>
pub fn checked_neg(self) -> Option<Self>
Computes -self
, returning None
unless self == 0
.
sourcepub fn checked_sub(self, rhs: Self) -> Option<Self>
pub fn checked_sub(self, rhs: Self) -> Option<Self>
Computes self - rhs
, returning None
if overflow occurred.
sourcepub fn overflowing_add(self, rhs: Self) -> (Self, bool)
pub 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.
sourcepub fn overflowing_neg(self) -> (Self, bool)
pub 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.
sourcepub fn overflowing_sub(self, rhs: Self) -> (Self, bool)
pub 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.
sourcepub fn saturating_add(self, rhs: Self) -> Self
pub fn saturating_add(self, rhs: Self) -> Self
Computes self + rhs
, saturating at the numeric bounds instead of
overflowing.
sourcepub fn saturating_sub(self, rhs: Self) -> Self
pub fn saturating_sub(self, rhs: Self) -> Self
Computes self - rhs
, saturating at the numeric bounds instead of
overflowing
sourcepub fn wrapping_add(self, rhs: Self) -> Self
pub fn wrapping_add(self, rhs: Self) -> Self
Computes self + rhs
, wrapping around at the boundary of the type.
sourcepub fn wrapping_neg(self) -> Self
pub fn wrapping_neg(self) -> Self
Computes -self
, wrapping around at the boundary of the type.
sourcepub fn wrapping_sub(self, rhs: Self) -> Self
pub fn wrapping_sub(self, rhs: Self) -> Self
Computes self - rhs
, wrapping around at the boundary of the type.
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub fn to_base_le(&self, base: u64) -> impl Iterator<Item = u64>
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.
sourcepub fn to_base_be(&self, base: u64) -> impl Iterator<Item = u64>
Available on crate feature alloc
only.
pub fn to_base_be(&self, base: u64) -> impl Iterator<Item = u64>
alloc
only.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.
Panics
Panics if the base is less than 2.
sourcepub fn from_base_le<I>(base: u64, digits: I) -> Result<Self, BaseConvertError>where
I: IntoIterator<Item = u64>,
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.
sourcepub fn from_base_be<I: IntoIterator<Item = u64>>(
base: u64,
digits: I
) -> Result<Self, BaseConvertError>
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.
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub const fn bit(&self, index: usize) -> bool
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.
sourcepub const fn byte(&self, index: usize) -> u8
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
exceeds 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);
sourcepub fn reverse_bits(self) -> Self
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.
sourcepub fn leading_zeros(&self) -> usize
pub fn leading_zeros(&self) -> usize
Returns the number of leading zeros in the binary representation of
self
.
sourcepub fn leading_ones(&self) -> usize
pub fn leading_ones(&self) -> usize
Returns the number of leading zeros in the binary representation of
self
.
sourcepub fn trailing_zeros(&self) -> usize
pub fn trailing_zeros(&self) -> usize
Returns the number of trailing zeros in the binary representation of
self
.
sourcepub fn trailing_ones(&self) -> usize
pub fn trailing_ones(&self) -> usize
Returns the number of trailing ones in the binary representation of
self
.
sourcepub fn count_ones(&self) -> usize
pub fn count_ones(&self) -> usize
Returns the number of ones in the binary representation of self
.
sourcepub fn count_zeros(&self) -> usize
pub fn count_zeros(&self) -> usize
Returns the number of zeros in the binary representation of self
.
sourcepub fn most_significant_bits(&self) -> (u64, usize)
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.
sourcepub fn checked_shl(self, rhs: usize) -> Option<Self>
pub 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).
sourcepub fn saturating_shl(self, rhs: usize) -> Self
pub fn saturating_shl(self, rhs: usize) -> Self
sourcepub fn overflowing_shl(self, rhs: usize) -> (Self, bool)
pub 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).
sourcepub fn wrapping_shl(self, rhs: usize) -> Self
pub 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).
sourcepub fn checked_shr(self, rhs: usize) -> Option<Self>
pub 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).
sourcepub fn overflowing_shr(self, rhs: usize) -> (Self, bool)
pub 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_shl
which returns true
if
the shift is larger than BITS
(which is IMHO not very useful).
sourcepub fn wrapping_shr(self, rhs: usize) -> Self
pub 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).
sourcepub fn rotate_left(self, rhs: usize) -> Self
pub 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 fn rotate_right(self, rhs: usize) -> Self
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub const BYTES: usize = _
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.
sourcepub const fn as_le_slice(&self) -> &[u8] ⓘ
Available on little-endian only.
pub const fn as_le_slice(&self) -> &[u8] ⓘ
Access the underlying store as a little-endian slice of bytes.
Only available on litte-endian targets.
If BITS
does not evenly divide 8, it is padded with zero bits in the
most significant position.
sourcepub unsafe fn as_le_slice_mut(&mut self) -> &mut [u8] ⓘ
Available on little-endian only.
pub unsafe fn as_le_slice_mut(&mut self) -> &mut [u8] ⓘ
sourcepub const fn as_le_bytes(&self) -> Cow<'_, [u8]>
Available on crate feature alloc
only.
pub const fn as_le_bytes(&self) -> Cow<'_, [u8]>
alloc
only.Access the underlying store as a little-endian bytes.
Uses an optimized implementation on little-endian targets.
sourcepub fn as_le_bytes_trimmed(&self) -> Cow<'_, [u8]>
Available on crate feature alloc
only.
pub fn as_le_bytes_trimmed(&self) -> Cow<'_, [u8]>
alloc
only.Access the underlying store as a little-endian bytes with trailing zeros removed.
Uses an optimized implementation on little-endian targets.
sourcepub fn to_le_bytes<const BYTES: usize>(&self) -> [u8; BYTES]
pub 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.
sourcepub fn to_le_bytes_vec(&self) -> Vec<u8> ⓘ
Available on crate feature alloc
only.
pub fn to_le_bytes_vec(&self) -> Vec<u8> ⓘ
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.
sourcepub fn to_le_bytes_trimmed_vec(&self) -> Vec<u8> ⓘ
Available on crate feature alloc
only.
pub fn to_le_bytes_trimmed_vec(&self) -> Vec<u8> ⓘ
alloc
only.Converts the Uint
to a little-endian byte vector with trailing zeros
bytes removed.
sourcepub fn to_be_bytes<const BYTES: usize>(&self) -> [u8; BYTES]
pub 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.
sourcepub fn to_be_bytes_vec(&self) -> Vec<u8> ⓘ
Available on crate feature alloc
only.
pub fn to_be_bytes_vec(&self) -> Vec<u8> ⓘ
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.
sourcepub fn to_be_bytes_trimmed_vec(&self) -> Vec<u8> ⓘ
Available on crate feature alloc
only.
pub fn to_be_bytes_trimmed_vec(&self) -> Vec<u8> ⓘ
alloc
only.Converts the Uint
to a big-endian byte vector with leading zeros
bytes removed.
sourcepub fn try_from_be_slice(bytes: &[u8]) -> Option<Self>
pub fn try_from_be_slice(bytes: &[u8]) -> Option<Self>
sourcepub fn try_from_le_slice(bytes: &[u8]) -> Option<Self>
pub fn try_from_le_slice(bytes: &[u8]) -> Option<Self>
sourcepub fn from_be_bytes<const BYTES: usize>(bytes: [u8; BYTES]) -> Self
pub 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.
sourcepub fn from_le_bytes<const BYTES: usize>(bytes: [u8; BYTES]) -> Self
pub 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.
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub fn checked_div(self, rhs: Self) -> Option<Self>
pub fn checked_div(self, rhs: Self) -> Option<Self>
Computes self / rhs
, returning None
if rhs == 0
.
sourcepub fn checked_rem(self, rhs: Self) -> Option<Self>
pub fn checked_rem(self, rhs: Self) -> Option<Self>
Computes self % rhs
, returning None
if rhs == 0
.
sourcepub fn div_rem(self, rhs: Self) -> (Self, Self)
pub fn div_rem(self, rhs: Self) -> (Self, Self)
sourcepub fn wrapping_div(self, rhs: Self) -> Self
pub fn wrapping_div(self, rhs: Self) -> Self
sourcepub fn wrapping_rem(self, rhs: Self) -> Self
pub fn wrapping_rem(self, rhs: Self) -> Self
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub fn from<T>(value: T) -> Selfwhere
Self: UintTryFrom<T>,
pub fn from<T>(value: T) -> Selfwhere 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);
sourcepub fn saturating_from<T>(value: T) -> Selfwhere
Self: UintTryFrom<T>,
pub fn saturating_from<T>(value: T) -> Selfwhere 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);
sourcepub fn wrapping_from<T>(value: T) -> Selfwhere
Self: UintTryFrom<T>,
pub fn wrapping_from<T>(value: T) -> Selfwhere 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);
sourcepub fn wrapping_to<T>(&self) -> Twhere
Self: UintTryTo<T>,
pub fn wrapping_to<T>(&self) -> Twhere 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);
sourcepub fn saturating_to<T>(&self) -> Twhere
Self: UintTryTo<T>,
pub fn saturating_to<T>(&self) -> Twhere 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);
sourcepub fn from_uint<const BITS_SRC: usize, const LIMBS_SRC: usize>(
value: Uint<BITS_SRC, LIMBS_SRC>
) -> Self
👎Deprecated since 1.4.0: Use ::from()
instead.
pub fn from_uint<const BITS_SRC: usize, const LIMBS_SRC: usize>( value: Uint<BITS_SRC, LIMBS_SRC> ) -> Self
::from()
instead.pub fn checked_from_uint<const BITS_SRC: usize, const LIMBS_SRC: usize>( value: Uint<BITS_SRC, LIMBS_SRC> ) -> Option<Self>
::checked_from()
instead.source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub fn gcd_extended(self, other: Self) -> (Self, Self, Self, bool)
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
.
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
pub fn checked_log(self, base: Self) -> Option<usize>
std
only.pub fn checked_log10(self) -> Option<usize>
std
only.sourcepub fn checked_log2(self) -> Option<usize>
Available on crate feature std
only.
pub fn checked_log2(self) -> Option<usize>
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.
sourcepub fn log(self, base: Self) -> usize
Available on crate feature std
only.
pub fn log(self, base: Self) -> usize
std
only.Panics
Panics if the base
is less than 2 or if the number is zero.
pub fn log10(self) -> usize
std
only.pub fn log2(self) -> usize
std
only.sourcepub fn approx_log(self, base: f64) -> f64
Available on crate feature std
only.
pub fn approx_log(self, base: f64) -> f64
std
only.Double precision logarithm.
sourcepub fn approx_log2(self) -> f64
Available on crate feature std
only.
pub fn approx_log2(self) -> f64
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);
sourcepub fn approx_log10(self) -> f64
Available on crate feature std
only.
pub fn approx_log10(self) -> f64
std
only.Double precision decimal logarithm.
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub fn reduce_mod(self, modulus: Self) -> Self
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.
sourcepub fn add_mod(self, rhs: Self, modulus: Self) -> Self
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.
sourcepub fn mul_mod(self, rhs: Self, modulus: Self) -> Self
Available on crate feature alloc
only.
pub fn mul_mod(self, rhs: Self, modulus: Self) -> Self
alloc
only.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.
sourcepub fn pow_mod(self, exp: Self, modulus: Self) -> Self
Available on crate feature alloc
only.
pub fn pow_mod(self, exp: Self, modulus: Self) -> Self
alloc
only.Compute $\mod{\mathtt{self}^{\mathtt{rhs}}}_{\mathtt{modulus}}$.
Returns zero if the modulus is zero.
sourcepub fn inv_mod(self, modulus: Self) -> Option<Self>
pub fn inv_mod(self, modulus: Self) -> Option<Self>
Compute $\mod{\mathtt{self}^{-1}}_{\mathtt{modulus}}$.
Returns None
if the inverse does not exist.
sourcepub fn mul_redc(self, other: Self, modulus: Self, inv: u64) -> Self
Available on crate feature alloc
only.
pub fn mul_redc(self, other: Self, modulus: Self, inv: u64) -> Self
alloc
only.Montgomery multiplication.
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.
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub fn checked_mul(self, rhs: Self) -> Option<Self>
pub fn checked_mul(self, rhs: Self) -> Option<Self>
Computes self * rhs
, returning None
if overflow occurred.
sourcepub fn overflowing_mul(self, rhs: Self) -> (Self, bool)
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)
);
sourcepub fn saturating_mul(self, rhs: Self) -> Self
pub fn saturating_mul(self, rhs: Self) -> Self
Computes self * rhs
, saturating at the numeric bounds instead of
overflowing.
sourcepub fn wrapping_mul(self, rhs: Self) -> Self
pub fn wrapping_mul(self, rhs: Self) -> Self
Computes self * rhs
, wrapping around at the boundary of the type.
sourcepub fn inv_ring(self) -> Option<Self>
pub fn inv_ring(self) -> Option<Self>
Computes the inverse modulo $2^{\mathtt{BITS}}$ of self
, returning
None
if the inverse does not exist.
sourcepub 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>
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);
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
pub fn checked_pow(self, exp: Self) -> Option<Self>
sourcepub fn overflowing_pow(self, exp: Self) -> (Self, bool)
pub fn overflowing_pow(self, exp: Self) -> (Self, bool)
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
pub fn saturating_pow(self, exp: Self) -> Self
pub fn wrapping_pow(self, exp: Self) -> Self
sourcepub fn approx_pow2(exp: f64) -> Option<Self>
Available on crate feature std
only.
pub fn approx_pow2(exp: f64) -> Option<Self>
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));
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub fn root(self, degree: usize) -> Self
Available on crate feature std
only.
pub fn root(self, degree: usize) -> Self
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);
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub fn is_power_of_two(self) -> bool
pub fn is_power_of_two(self) -> bool
Returns true
if and only if self == 2^k
for some k
.
sourcepub fn next_power_of_two(self) -> Self
pub 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.
sourcepub fn checked_next_power_of_two(self) -> Option<Self>
pub 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);
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub fn next_multiple_of(self, rhs: Self) -> Self
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.
sourcepub fn checked_next_multiple_of(self, rhs: Self) -> Option<Self>
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));
}
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub fn from_str_radix(src: &str, radix: u64) -> Result<Self, ParseError>
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
ifUint::from_base_be
fails.
source§impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Uint<BITS, LIMBS>
sourcepub const MIN: Self = Self::ZERO
pub const MIN: Self = Self::ZERO
The smallest value that can be represented by this integer type.
Synonym for Self::ZERO
.
sourcepub const MAX: Self = _
pub const MAX: Self = _
The largest value that can be represented by this integer type, $2^{\mathtt{BITS}} − 1$.
sourcepub unsafe fn as_limbs_mut(&mut self) -> &mut [u64; LIMBS]
pub 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.
sourcepub const fn into_limbs(self) -> [u64; LIMBS]
pub const fn into_limbs(self) -> [u64; LIMBS]
Convert to a array of limbs.
Limbs are least significant first.
sourcepub const fn from_limbs(limbs: [u64; LIMBS]) -> Self
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 to large for the bit-size of the Uint.
sourcepub fn from_limbs_slice(slice: &[u64]) -> Self
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 to large for the bit-size of the Uint.
sourcepub fn checked_from_limbs_slice(slice: &[u64]) -> Option<Self>
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
sourcepub fn overflowing_from_limbs_slice(slice: &[u64]) -> (Self, bool)
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
Trait Implementations§
source§impl<const BITS: usize, const LIMBS: usize> AddAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> AddAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn add_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
fn add_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
+=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> AddAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> AddAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn add_assign(&mut self, rhs: Uint<BITS, LIMBS>)
fn add_assign(&mut self, rhs: Uint<BITS, LIMBS>)
+=
operation. Read moresource§impl<'a, const BITS: usize, const LIMBS: usize> Arbitrary<'a> for Uint<BITS, LIMBS>
Available on crate feature arbitrary
only.
impl<'a, const BITS: usize, const LIMBS: usize> Arbitrary<'a> for Uint<BITS, LIMBS>
arbitrary
only.source§fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>
fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>
Self
from the given unstructured data. Read moresource§fn size_hint(_depth: usize) -> (usize, Option<usize>)
fn size_hint(_depth: usize) -> (usize, Option<usize>)
Unstructured
this type
needs to construct itself. Read moresource§fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>
fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>
Self
from the entirety of the given
unstructured data. Read moresource§impl<const BITS: usize, const LIMBS: usize> Arbitrary for Uint<BITS, LIMBS>
Available on crate feature quickcheck
only.
impl<const BITS: usize, const LIMBS: usize> Arbitrary for Uint<BITS, LIMBS>
quickcheck
only.source§impl<const BITS: usize, const LIMBS: usize> Arbitrary for Uint<BITS, LIMBS>
Available on crate feature proptest
only.
impl<const BITS: usize, const LIMBS: usize> Arbitrary for Uint<BITS, LIMBS>
proptest
only.§type Parameters = ()
type Parameters = ()
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>>
type Strategy = Map<<[u64; LIMBS] as Arbitrary>::Strategy, fn(_: [u64; LIMBS]) -> Uint<BITS, LIMBS>>
Strategy
used to generate values of type Self
.source§fn arbitrary_with((): Self::Parameters) -> Self::Strategy
fn arbitrary_with((): Self::Parameters) -> Self::Strategy
source§impl<const BITS: usize, const LIMBS: usize> BitAnd<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> BitAnd<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>
source§impl<const BITS: usize, const LIMBS: usize> BitAndAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> BitAndAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn bitand_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
fn bitand_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
&=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> BitAndAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> BitAndAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn bitand_assign(&mut self, rhs: Uint<BITS, LIMBS>)
fn bitand_assign(&mut self, rhs: Uint<BITS, LIMBS>)
&=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> BitOrAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> BitOrAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn bitor_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
fn bitor_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
|=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> BitOrAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> BitOrAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn bitor_assign(&mut self, rhs: Uint<BITS, LIMBS>)
fn bitor_assign(&mut self, rhs: Uint<BITS, LIMBS>)
|=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> BitXor<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> BitXor<&Uint<BITS, LIMBS>> for &Uint<BITS, LIMBS>
source§impl<const BITS: usize, const LIMBS: usize> BitXorAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> BitXorAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn bitxor_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
fn bitxor_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
^=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> BitXorAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> BitXorAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn bitxor_assign(&mut self, rhs: Uint<BITS, LIMBS>)
fn bitxor_assign(&mut self, rhs: Uint<BITS, LIMBS>)
^=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> Decodable for Uint<BITS, LIMBS>
Available on crate feature alloy-rlp
only.
impl<const BITS: usize, const LIMBS: usize> Decodable for Uint<BITS, LIMBS>
alloy-rlp
only.Allows a Uint
to be deserialized from RLP.
source§impl<const BITS: usize, const LIMBS: usize> Decodable for Uint<BITS, LIMBS>
Available on crate feature fastrlp
only.
impl<const BITS: usize, const LIMBS: usize> Decodable for Uint<BITS, LIMBS>
fastrlp
only.Allows a Uint
to be deserialized from RLP.
source§impl<const BITS: usize, const LIMBS: usize> Decodable for Uint<BITS, LIMBS>
Available on crate feature rlp
only.
impl<const BITS: usize, const LIMBS: usize> Decodable for Uint<BITS, LIMBS>
rlp
only.Allows a Uint
to be deserialized from RLP.
source§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.
impl<'a, const BITS: usize, const LIMBS: usize, DB: Database> Decode<'a, DB> for Uint<BITS, LIMBS>where Vec<u8>: Decode<'a, DB>,
sqlx
only.source§fn decode(value: <DB as HasValueRef<'a>>::ValueRef) -> Result<Self, BoxDynError>
fn decode(value: <DB as HasValueRef<'a>>::ValueRef) -> Result<Self, BoxDynError>
source§impl<const BITS: usize, const LIMBS: usize> Decode for Uint<BITS, LIMBS>
Available on crate feature parity-scale-codec
only.
impl<const BITS: usize, const LIMBS: usize> Decode for Uint<BITS, LIMBS>
parity-scale-codec
only.source§fn decode<I: Input>(input: &mut I) -> Result<Self, Error>
fn decode<I: Input>(input: &mut I) -> Result<Self, Error>
source§fn decode_into<I>(
input: &mut I,
dst: &mut MaybeUninit<Self>
) -> Result<DecodeFinished, Error>where
I: Input,
fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,
source§impl<'de, const BITS: usize, const LIMBS: usize> Deserialize<'de> for Uint<BITS, LIMBS>
Available on crate feature serde
only.
impl<'de, const BITS: usize, const LIMBS: usize> Deserialize<'de> for Uint<BITS, LIMBS>
serde
only.Deserialize human readable hex strings or byte arrays into hashes.
Hex strings can be upper/lower/mixed case, have an optional 0x
prefix, and
can be any length. They are interpreted big-endian.
source§fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
source§impl<const BITS: usize, const LIMBS: usize> Display for Uint<BITS, LIMBS>
Available on crate feature alloc
only.
impl<const BITS: usize, const LIMBS: usize> Display for Uint<BITS, LIMBS>
alloc
only.source§impl<const BITS: usize, const LIMBS: usize> Distribution<Uint<BITS, LIMBS>> for Standard
Available on crate feature rand
only.
impl<const BITS: usize, const LIMBS: usize> Distribution<Uint<BITS, LIMBS>> for Standard
rand
only.source§fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Uint<BITS, LIMBS>
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Uint<BITS, LIMBS>
T
, using rng
as the source of randomness.source§impl<const BITS: usize, const LIMBS: usize> DivAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> DivAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn div_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
fn div_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
/=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> DivAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> DivAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn div_assign(&mut self, rhs: Uint<BITS, LIMBS>)
fn div_assign(&mut self, rhs: Uint<BITS, LIMBS>)
/=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> Encodable for Uint<BITS, LIMBS>
Available on crate feature fastrlp
only.
impl<const BITS: usize, const LIMBS: usize> Encodable for Uint<BITS, LIMBS>
fastrlp
only.Allows a Uint
to be serialized as RLP.
source§impl<const BITS: usize, const LIMBS: usize> Encodable for Uint<BITS, LIMBS>
Available on crate feature alloy-rlp
only.
impl<const BITS: usize, const LIMBS: usize> Encodable for Uint<BITS, LIMBS>
alloy-rlp
only.Allows a Uint
to be serialized as RLP.
source§impl<const BITS: usize, const LIMBS: usize> Encodable for Uint<BITS, LIMBS>
Available on crate feature rlp
only.
impl<const BITS: usize, const LIMBS: usize> Encodable for Uint<BITS, LIMBS>
rlp
only.Allows a Uint
to be serialized as RLP.
source§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.
impl<'a, const BITS: usize, const LIMBS: usize, DB: Database> Encode<'a, DB> for Uint<BITS, LIMBS>where Vec<u8>: Encode<'a, DB>,
sqlx
only.source§fn encode_by_ref(
&self,
buf: &mut <DB as HasArguments<'a>>::ArgumentBuffer
) -> IsNull
fn encode_by_ref( &self, buf: &mut <DB as HasArguments<'a>>::ArgumentBuffer ) -> IsNull
source§fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNullwhere
Self: Sized,
fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNullwhere Self: Sized,
self
into buf
in the expected format for the database.fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
source§impl<const BITS: usize, const LIMBS: usize> Encode for Uint<BITS, LIMBS>
Available on crate feature parity-scale-codec
only.
impl<const BITS: usize, const LIMBS: usize> Encode for Uint<BITS, LIMBS>
parity-scale-codec
only.source§fn size_hint(&self) -> usize
fn size_hint(&self) -> usize
u32 prefix for compact encoding + bytes needed for LE bytes representation
source§fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R
fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R
source§fn encode_to<T>(&self, dest: &mut T)where
T: Output + ?Sized,
fn encode_to<T>(&self, dest: &mut T)where T: Output + ?Sized,
source§fn encoded_size(&self) -> usize
fn encoded_size(&self) -> usize
source§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.
impl<'a, const BITS: usize, const LIMBS: usize> EncodeAsRef<'a, Uint<BITS, LIMBS>> for CompactUint<BITS, LIMBS>
parity-scale-codec
only.§type RefType = CompactRefUint<'a, BITS, LIMBS>
type RefType = CompactRefUint<'a, BITS, LIMBS>
source§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.
impl<'a, const BITS: usize, const LIMBS: usize> From<&'a Uint<BITS, LIMBS>> for CompactRefUint<'a, BITS, LIMBS>
parity-scale-codec
only.source§impl<const BITS: usize, const LIMBS: usize> From<&BigInt<LIMBS>> for Uint<BITS, LIMBS>
Available on crate feature ark-ff-04
only.
impl<const BITS: usize, const LIMBS: usize> From<&BigInt<LIMBS>> for Uint<BITS, LIMBS>
ark-ff-04
only.source§impl From<&BigInteger128> for Uint<128, 2>
Available on crate feature ark-ff
only.
impl From<&BigInteger128> for Uint<128, 2>
ark-ff
only.source§fn from(value: &BigInteger128) -> Self
fn from(value: &BigInteger128) -> Self
source§impl From<&BigInteger256> for Uint<256, 4>
Available on crate feature ark-ff
only.
impl From<&BigInteger256> for Uint<256, 4>
ark-ff
only.source§fn from(value: &BigInteger256) -> Self
fn from(value: &BigInteger256) -> Self
source§impl From<&BigInteger320> for Uint<320, 5>
Available on crate feature ark-ff
only.
impl From<&BigInteger320> for Uint<320, 5>
ark-ff
only.source§fn from(value: &BigInteger320) -> Self
fn from(value: &BigInteger320) -> Self
source§impl From<&BigInteger384> for Uint<384, 6>
Available on crate feature ark-ff
only.
impl From<&BigInteger384> for Uint<384, 6>
ark-ff
only.source§fn from(value: &BigInteger384) -> Self
fn from(value: &BigInteger384) -> Self
source§impl From<&BigInteger448> for Uint<448, 7>
Available on crate feature ark-ff
only.
impl From<&BigInteger448> for Uint<448, 7>
ark-ff
only.source§fn from(value: &BigInteger448) -> Self
fn from(value: &BigInteger448) -> Self
source§impl From<&BigInteger64> for Uint<64, 1>
Available on crate feature ark-ff
only.
impl From<&BigInteger64> for Uint<64, 1>
ark-ff
only.source§fn from(value: &BigInteger64) -> Self
fn from(value: &BigInteger64) -> Self
source§impl From<&BigInteger768> for Uint<768, 12>
Available on crate feature ark-ff
only.
impl From<&BigInteger768> for Uint<768, 12>
ark-ff
only.source§fn from(value: &BigInteger768) -> Self
fn from(value: &BigInteger768) -> Self
source§impl From<&BigInteger832> for Uint<832, 13>
Available on crate feature ark-ff
only.
impl From<&BigInteger832> for Uint<832, 13>
ark-ff
only.source§fn from(value: &BigInteger832) -> Self
fn from(value: &BigInteger832) -> Self
source§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.
impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> From<&Fp<P, LIMBS>> for Uint<BITS, LIMBS>
ark-ff-04
only.source§impl<P: Fp256Parameters> From<&Fp256<P>> for Uint<256, 4>
Available on crate feature ark-ff
only.
impl<P: Fp256Parameters> From<&Fp256<P>> for Uint<256, 4>
ark-ff
only.source§impl<P: Fp320Parameters> From<&Fp320<P>> for Uint<320, 5>
Available on crate feature ark-ff
only.
impl<P: Fp320Parameters> From<&Fp320<P>> for Uint<320, 5>
ark-ff
only.source§impl<P: Fp384Parameters> From<&Fp384<P>> for Uint<384, 6>
Available on crate feature ark-ff
only.
impl<P: Fp384Parameters> From<&Fp384<P>> for Uint<384, 6>
ark-ff
only.source§impl<P: Fp448Parameters> From<&Fp448<P>> for Uint<448, 7>
Available on crate feature ark-ff
only.
impl<P: Fp448Parameters> From<&Fp448<P>> for Uint<448, 7>
ark-ff
only.source§impl<P: Fp64Parameters> From<&Fp64<P>> for Uint<64, 1>
Available on crate feature ark-ff
only.
impl<P: Fp64Parameters> From<&Fp64<P>> for Uint<64, 1>
ark-ff
only.source§impl<P: Fp768Parameters> From<&Fp768<P>> for Uint<768, 12>
Available on crate feature ark-ff
only.
impl<P: Fp768Parameters> From<&Fp768<P>> for Uint<768, 12>
ark-ff
only.source§impl<P: Fp832Parameters> From<&Fp832<P>> for Uint<832, 13>
Available on crate feature ark-ff
only.
impl<P: Fp832Parameters> From<&Fp832<P>> for Uint<832, 13>
ark-ff
only.source§impl From<&Uint<128, 2>> for BigInteger128
Available on crate feature ark-ff
only.
impl From<&Uint<128, 2>> for BigInteger128
ark-ff
only.source§impl From<&Uint<256, 4>> for BigInteger256
Available on crate feature ark-ff
only.
impl From<&Uint<256, 4>> for BigInteger256
ark-ff
only.source§impl From<&Uint<320, 5>> for BigInteger320
Available on crate feature ark-ff
only.
impl From<&Uint<320, 5>> for BigInteger320
ark-ff
only.source§impl From<&Uint<384, 6>> for BigInteger384
Available on crate feature ark-ff
only.
impl From<&Uint<384, 6>> for BigInteger384
ark-ff
only.source§impl From<&Uint<448, 7>> for BigInteger448
Available on crate feature ark-ff
only.
impl From<&Uint<448, 7>> for BigInteger448
ark-ff
only.source§impl From<&Uint<64, 1>> for BigInteger64
Available on crate feature ark-ff
only.
impl From<&Uint<64, 1>> for BigInteger64
ark-ff
only.source§impl From<&Uint<768, 12>> for BigInteger768
Available on crate feature ark-ff
only.
impl From<&Uint<768, 12>> for BigInteger768
ark-ff
only.source§impl From<&Uint<832, 13>> for BigInteger832
Available on crate feature ark-ff
only.
impl From<&Uint<832, 13>> for BigInteger832
ark-ff
only.source§impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BN
Available on crate feature bn-rs
only.
impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BN
bn-rs
only.source§impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigInt
Available on crate feature num-bigint
only.
impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigInt
num-bigint
only.source§impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigInt<LIMBS>
Available on crate feature ark-ff-04
only.
impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigInt<LIMBS>
ark-ff-04
only.source§impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigNumber
Available on crate feature bn-rs
only.
impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigNumber
bn-rs
only.source§impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigUint
Available on crate feature num-bigint
only.
impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for BigUint
num-bigint
only.source§impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for f32
Available on crate feature std
only.
impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for f32
std
only.source§impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for f64
Available on crate feature std
only.
impl<const BITS: usize, const LIMBS: usize> From<&Uint<BITS, LIMBS>> for f64
std
only.source§impl<const BITS: usize, const LIMBS: usize> From<BigInt<LIMBS>> for Uint<BITS, LIMBS>
Available on crate feature ark-ff-04
only.
impl<const BITS: usize, const LIMBS: usize> From<BigInt<LIMBS>> for Uint<BITS, LIMBS>
ark-ff-04
only.source§impl From<BigInteger128> for Uint<128, 2>
Available on crate feature ark-ff
only.
impl From<BigInteger128> for Uint<128, 2>
ark-ff
only.source§fn from(value: BigInteger128) -> Self
fn from(value: BigInteger128) -> Self
source§impl From<BigInteger256> for Uint<256, 4>
Available on crate feature ark-ff
only.
impl From<BigInteger256> for Uint<256, 4>
ark-ff
only.source§fn from(value: BigInteger256) -> Self
fn from(value: BigInteger256) -> Self
source§impl From<BigInteger320> for Uint<320, 5>
Available on crate feature ark-ff
only.
impl From<BigInteger320> for Uint<320, 5>
ark-ff
only.source§fn from(value: BigInteger320) -> Self
fn from(value: BigInteger320) -> Self
source§impl From<BigInteger384> for Uint<384, 6>
Available on crate feature ark-ff
only.
impl From<BigInteger384> for Uint<384, 6>
ark-ff
only.source§fn from(value: BigInteger384) -> Self
fn from(value: BigInteger384) -> Self
source§impl From<BigInteger448> for Uint<448, 7>
Available on crate feature ark-ff
only.
impl From<BigInteger448> for Uint<448, 7>
ark-ff
only.source§fn from(value: BigInteger448) -> Self
fn from(value: BigInteger448) -> Self
source§impl From<BigInteger64> for Uint<64, 1>
Available on crate feature ark-ff
only.
impl From<BigInteger64> for Uint<64, 1>
ark-ff
only.source§fn from(value: BigInteger64) -> Self
fn from(value: BigInteger64) -> Self
source§impl From<BigInteger768> for Uint<768, 12>
Available on crate feature ark-ff
only.
impl From<BigInteger768> for Uint<768, 12>
ark-ff
only.source§fn from(value: BigInteger768) -> Self
fn from(value: BigInteger768) -> Self
source§impl From<BigInteger832> for Uint<832, 13>
Available on crate feature ark-ff
only.
impl From<BigInteger832> for Uint<832, 13>
ark-ff
only.source§fn from(value: BigInteger832) -> Self
fn from(value: BigInteger832) -> Self
source§impl<const BITS: usize, const LIMBS: usize> From<CompactUint<BITS, LIMBS>> for Uint<BITS, LIMBS>
Available on crate feature parity-scale-codec
only.
impl<const BITS: usize, const LIMBS: usize> From<CompactUint<BITS, LIMBS>> for Uint<BITS, LIMBS>
parity-scale-codec
only.source§fn from(v: CompactUint<BITS, LIMBS>) -> Self
fn from(v: CompactUint<BITS, LIMBS>) -> Self
source§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.
impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> From<Fp<P, LIMBS>> for Uint<BITS, LIMBS>
ark-ff-04
only.source§impl<P: Fp256Parameters> From<Fp256<P>> for Uint<256, 4>
Available on crate feature ark-ff
only.
impl<P: Fp256Parameters> From<Fp256<P>> for Uint<256, 4>
ark-ff
only.source§impl<P: Fp320Parameters> From<Fp320<P>> for Uint<320, 5>
Available on crate feature ark-ff
only.
impl<P: Fp320Parameters> From<Fp320<P>> for Uint<320, 5>
ark-ff
only.source§impl<P: Fp384Parameters> From<Fp384<P>> for Uint<384, 6>
Available on crate feature ark-ff
only.
impl<P: Fp384Parameters> From<Fp384<P>> for Uint<384, 6>
ark-ff
only.source§impl<P: Fp448Parameters> From<Fp448<P>> for Uint<448, 7>
Available on crate feature ark-ff
only.
impl<P: Fp448Parameters> From<Fp448<P>> for Uint<448, 7>
ark-ff
only.source§impl<P: Fp768Parameters> From<Fp768<P>> for Uint<768, 12>
Available on crate feature ark-ff
only.
impl<P: Fp768Parameters> From<Fp768<P>> for Uint<768, 12>
ark-ff
only.source§impl<P: Fp832Parameters> From<Fp832<P>> for Uint<832, 13>
Available on crate feature ark-ff
only.
impl<P: Fp832Parameters> From<Fp832<P>> for Uint<832, 13>
ark-ff
only.source§impl From<Uint<128, 2>> for BigInteger128
Available on crate feature ark-ff
only.
impl From<Uint<128, 2>> for BigInteger128
ark-ff
only.source§impl From<Uint<256, 4>> for BigInteger256
Available on crate feature ark-ff
only.
impl From<Uint<256, 4>> for BigInteger256
ark-ff
only.source§impl From<Uint<320, 5>> for BigInteger320
Available on crate feature ark-ff
only.
impl From<Uint<320, 5>> for BigInteger320
ark-ff
only.source§impl From<Uint<384, 6>> for BigInteger384
Available on crate feature ark-ff
only.
impl From<Uint<384, 6>> for BigInteger384
ark-ff
only.source§impl From<Uint<448, 7>> for BigInteger448
Available on crate feature ark-ff
only.
impl From<Uint<448, 7>> for BigInteger448
ark-ff
only.source§impl From<Uint<64, 1>> for BigInteger64
Available on crate feature ark-ff
only.
impl From<Uint<64, 1>> for BigInteger64
ark-ff
only.source§impl From<Uint<768, 12>> for BigInteger768
Available on crate feature ark-ff
only.
impl From<Uint<768, 12>> for BigInteger768
ark-ff
only.source§impl From<Uint<832, 13>> for BigInteger832
Available on crate feature ark-ff
only.
impl From<Uint<832, 13>> for BigInteger832
ark-ff
only.source§impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BN
Available on crate feature bn-rs
only.
impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BN
bn-rs
only.source§impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigInt
Available on crate feature num-bigint
only.
impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigInt
num-bigint
only.source§impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigInt<LIMBS>
Available on crate feature ark-ff-04
only.
impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigInt<LIMBS>
ark-ff-04
only.source§impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigNumber
Available on crate feature bn-rs
only.
impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigNumber
bn-rs
only.source§impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigUint
Available on crate feature num-bigint
only.
impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for BigUint
num-bigint
only.source§impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for CompactUint<BITS, LIMBS>
Available on crate feature parity-scale-codec
only.
impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for CompactUint<BITS, LIMBS>
parity-scale-codec
only.source§impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for f32
Available on crate feature std
only.
impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for f32
std
only.source§impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for f64
Available on crate feature std
only.
impl<const BITS: usize, const LIMBS: usize> From<Uint<BITS, LIMBS>> for f64
std
only.source§impl<'source, const BITS: usize, const LIMBS: usize> FromPyObject<'source> for Uint<BITS, LIMBS>
Available on crate feature pyo3
only.
impl<'source, const BITS: usize, const LIMBS: usize> FromPyObject<'source> for Uint<BITS, LIMBS>
pyo3
only.source§impl<'a, const BITS: usize, const LIMBS: usize> FromSql<'a> for Uint<BITS, LIMBS>
Available on crate feature postgres
only.
impl<'a, const BITS: usize, const LIMBS: usize> FromSql<'a> for Uint<BITS, LIMBS>
postgres
only.Convert from Postgres types.
See ToSql
for details.
source§fn accepts(ty: &Type) -> bool
fn accepts(ty: &Type) -> bool
Type
.source§fn from_sql(
ty: &Type,
raw: &'a [u8]
) -> Result<Self, Box<dyn Error + Sync + Send>>
fn from_sql( ty: &Type, raw: &'a [u8] ) -> Result<Self, Box<dyn Error + Sync + Send>>
Type
in its binary format. Read moresource§impl<const BITS: usize, const LIMBS: usize> HasCompact for Uint<BITS, LIMBS>
Available on crate feature parity-scale-codec
only.
impl<const BITS: usize, const LIMBS: usize> HasCompact for Uint<BITS, LIMBS>
parity-scale-codec
only.§type Type = CompactUint<BITS, LIMBS>
type Type = CompactUint<BITS, LIMBS>
source§impl<const BITS: usize, const LIMBS: usize> IntoPy<Py<PyAny>> for Uint<BITS, LIMBS>
Available on crate feature pyo3
only.
impl<const BITS: usize, const LIMBS: usize> IntoPy<Py<PyAny>> for Uint<BITS, LIMBS>
pyo3
only.source§impl<const BITS: usize, const LIMBS: usize> MaxEncodedLen for Uint<BITS, LIMBS>
Available on crate feature parity-scale-codec
only.
impl<const BITS: usize, const LIMBS: usize> MaxEncodedLen for Uint<BITS, LIMBS>
parity-scale-codec
only.source§fn max_encoded_len() -> usize
fn max_encoded_len() -> usize
source§impl<const BITS: usize, const LIMBS: usize> MaxEncodedLenAssoc for Uint<BITS, LIMBS>
Available on crate feature alloy-rlp
only.
impl<const BITS: usize, const LIMBS: usize> MaxEncodedLenAssoc for Uint<BITS, LIMBS>
alloy-rlp
only.source§impl<const BITS: usize, const LIMBS: usize> MulAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> MulAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn mul_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
fn mul_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
*=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> MulAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> MulAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn mul_assign(&mut self, rhs: Uint<BITS, LIMBS>)
fn mul_assign(&mut self, rhs: Uint<BITS, LIMBS>)
*=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> Octal for Uint<BITS, LIMBS>
Available on crate feature alloc
only.
impl<const BITS: usize, const LIMBS: usize> Octal for Uint<BITS, LIMBS>
alloc
only.source§impl<const BITS: usize, const LIMBS: usize> Ord for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Ord for Uint<BITS, LIMBS>
source§impl<const BITS: usize, const LIMBS: usize> PartialEq<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> PartialEq<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§impl<const BITS: usize, const LIMBS: usize> PartialOrd<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> PartialOrd<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<'a, const BITS: usize, const LIMBS: usize> Product<&'a Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<'a, const BITS: usize, const LIMBS: usize> Product<&'a Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§impl<const BITS: usize, const LIMBS: usize> RemAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> RemAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn rem_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
fn rem_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
%=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> RemAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> RemAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn rem_assign(&mut self, rhs: Uint<BITS, LIMBS>)
fn rem_assign(&mut self, rhs: Uint<BITS, LIMBS>)
%=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> Serialize for Uint<BITS, LIMBS>
Available on crate feature serde
only.
impl<const BITS: usize, const LIMBS: usize> Serialize for Uint<BITS, LIMBS>
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.
source§impl<const BITS: usize, const LIMBS: usize> ShlAssign<&usize> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> ShlAssign<&usize> for Uint<BITS, LIMBS>
source§fn shl_assign(&mut self, rhs: &usize)
fn shl_assign(&mut self, rhs: &usize)
<<=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> ShlAssign<usize> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> ShlAssign<usize> for Uint<BITS, LIMBS>
source§fn shl_assign(&mut self, rhs: usize)
fn shl_assign(&mut self, rhs: usize)
<<=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> ShrAssign<&usize> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> ShrAssign<&usize> for Uint<BITS, LIMBS>
source§fn shr_assign(&mut self, rhs: &usize)
fn shr_assign(&mut self, rhs: &usize)
>>=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> ShrAssign<usize> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> ShrAssign<usize> for Uint<BITS, LIMBS>
source§fn shr_assign(&mut self, rhs: usize)
fn shr_assign(&mut self, rhs: usize)
>>=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> Structable for Uint<BITS, LIMBS>
Available on crate feature valuable
only.
impl<const BITS: usize, const LIMBS: usize> Structable for Uint<BITS, LIMBS>
valuable
only.source§fn definition(&self) -> StructDef<'_>
fn definition(&self) -> StructDef<'_>
source§impl<const BITS: usize, const LIMBS: usize> SubAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> SubAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn sub_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
fn sub_assign(&mut self, rhs: &Uint<BITS, LIMBS>)
-=
operation. Read moresource§impl<const BITS: usize, const LIMBS: usize> SubAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> SubAssign<Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§fn sub_assign(&mut self, rhs: Uint<BITS, LIMBS>)
fn sub_assign(&mut self, rhs: Uint<BITS, LIMBS>)
-=
operation. Read moresource§impl<'a, const BITS: usize, const LIMBS: usize> Sum<&'a Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
impl<'a, const BITS: usize, const LIMBS: usize> Sum<&'a Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>
source§impl<const BITS: usize, const LIMBS: usize> ToPyObject for Uint<BITS, LIMBS>
Available on crate feature pyo3
only.
impl<const BITS: usize, const LIMBS: usize> ToPyObject for Uint<BITS, LIMBS>
pyo3
only.source§impl<const BITS: usize, const LIMBS: usize> ToSql for Uint<BITS, LIMBS>
Available on crate feature postgres
only.
impl<const BITS: usize, const LIMBS: usize> ToSql for Uint<BITS, LIMBS>
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
andNUMERIC
, 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
as0x
-prefixed big-endian hex strings.JSON
,JSONB
as a hex string compatible with the Serde serialization.
Note: Uint
s 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
.
source§fn accepts(ty: &Type) -> bool
fn accepts(ty: &Type) -> bool
Type
.source§fn to_sql(
&self,
ty: &Type,
out: &mut BytesMut
) -> Result<IsNull, Box<dyn Error + Sync + Send + 'static>>
fn to_sql( &self, ty: &Type, out: &mut BytesMut ) -> Result<IsNull, Box<dyn Error + Sync + Send + 'static>>
self
into the binary format of the specified
Postgres Type
, appending it to out
. Read moresource§fn to_sql_checked(
&self,
ty: &Type,
out: &mut BytesMut
) -> Result<IsNull, Box<dyn Error + Sync + Send>>
fn to_sql_checked( &self, ty: &Type, out: &mut BytesMut ) -> Result<IsNull, Box<dyn Error + Sync + Send>>
source§fn encode_format(&self, _ty: &Type) -> Format
fn encode_format(&self, _ty: &Type) -> Format
source§impl<const BITS: usize, const LIMBS: usize> TryFrom<&BN> for Uint<BITS, LIMBS>
Available on crate feature bn-rs
only.
impl<const BITS: usize, const LIMBS: usize> TryFrom<&BN> for Uint<BITS, LIMBS>
bn-rs
only.source§impl<const BITS: usize, const LIMBS: usize> TryFrom<&BigInt> for Uint<BITS, LIMBS>
Available on crate feature num-bigint
only.
impl<const BITS: usize, const LIMBS: usize> TryFrom<&BigInt> for Uint<BITS, LIMBS>
num-bigint
only.source§impl<const BITS: usize, const LIMBS: usize> TryFrom<&BigNumber> for Uint<BITS, LIMBS>
Available on crate feature bn-rs
only.
impl<const BITS: usize, const LIMBS: usize> TryFrom<&BigNumber> for Uint<BITS, LIMBS>
bn-rs
only.source§impl<const BITS: usize, const LIMBS: usize> TryFrom<&BigUint> for Uint<BITS, LIMBS>
Available on crate feature num-bigint
only.
impl<const BITS: usize, const LIMBS: usize> TryFrom<&BigUint> for Uint<BITS, LIMBS>
num-bigint
only.source§impl<P: Fp256Parameters> TryFrom<&Uint<256, 4>> for Fp256<P>
Available on crate feature ark-ff
only.
impl<P: Fp256Parameters> TryFrom<&Uint<256, 4>> for Fp256<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp320Parameters> TryFrom<&Uint<320, 5>> for Fp320<P>
Available on crate feature ark-ff
only.
impl<P: Fp320Parameters> TryFrom<&Uint<320, 5>> for Fp320<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp384Parameters> TryFrom<&Uint<384, 6>> for Fp384<P>
Available on crate feature ark-ff
only.
impl<P: Fp384Parameters> TryFrom<&Uint<384, 6>> for Fp384<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp448Parameters> TryFrom<&Uint<448, 7>> for Fp448<P>
Available on crate feature ark-ff
only.
impl<P: Fp448Parameters> TryFrom<&Uint<448, 7>> for Fp448<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp64Parameters> TryFrom<&Uint<64, 1>> for Fp64<P>
Available on crate feature ark-ff
only.
impl<P: Fp64Parameters> TryFrom<&Uint<64, 1>> for Fp64<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp768Parameters> TryFrom<&Uint<768, 12>> for Fp768<P>
Available on crate feature ark-ff
only.
impl<P: Fp768Parameters> TryFrom<&Uint<768, 12>> for Fp768<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp832Parameters> TryFrom<&Uint<832, 13>> for Fp832<P>
Available on crate feature ark-ff
only.
impl<P: Fp832Parameters> TryFrom<&Uint<832, 13>> for Fp832<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§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.
impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> TryFrom<&Uint<BITS, LIMBS>> for Fp<P, LIMBS>
ark-ff-04
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<const BITS: usize, const LIMBS: usize> TryFrom<BN> for Uint<BITS, LIMBS>
Available on crate feature bn-rs
only.
impl<const BITS: usize, const LIMBS: usize> TryFrom<BN> for Uint<BITS, LIMBS>
bn-rs
only.source§impl<const BITS: usize, const LIMBS: usize> TryFrom<BigInt> for Uint<BITS, LIMBS>
Available on crate feature num-bigint
only.
impl<const BITS: usize, const LIMBS: usize> TryFrom<BigInt> for Uint<BITS, LIMBS>
num-bigint
only.source§impl<const BITS: usize, const LIMBS: usize> TryFrom<BigNumber> for Uint<BITS, LIMBS>
Available on crate feature bn-rs
only.
impl<const BITS: usize, const LIMBS: usize> TryFrom<BigNumber> for Uint<BITS, LIMBS>
bn-rs
only.source§impl<const BITS: usize, const LIMBS: usize> TryFrom<BigUint> for Uint<BITS, LIMBS>
Available on crate feature num-bigint
only.
impl<const BITS: usize, const LIMBS: usize> TryFrom<BigUint> for Uint<BITS, LIMBS>
num-bigint
only.source§impl<P: Fp256Parameters> TryFrom<Uint<256, 4>> for Fp256<P>
Available on crate feature ark-ff
only.
impl<P: Fp256Parameters> TryFrom<Uint<256, 4>> for Fp256<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp320Parameters> TryFrom<Uint<320, 5>> for Fp320<P>
Available on crate feature ark-ff
only.
impl<P: Fp320Parameters> TryFrom<Uint<320, 5>> for Fp320<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp384Parameters> TryFrom<Uint<384, 6>> for Fp384<P>
Available on crate feature ark-ff
only.
impl<P: Fp384Parameters> TryFrom<Uint<384, 6>> for Fp384<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp448Parameters> TryFrom<Uint<448, 7>> for Fp448<P>
Available on crate feature ark-ff
only.
impl<P: Fp448Parameters> TryFrom<Uint<448, 7>> for Fp448<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp64Parameters> TryFrom<Uint<64, 1>> for Fp64<P>
Available on crate feature ark-ff
only.
impl<P: Fp64Parameters> TryFrom<Uint<64, 1>> for Fp64<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp768Parameters> TryFrom<Uint<768, 12>> for Fp768<P>
Available on crate feature ark-ff
only.
impl<P: Fp768Parameters> TryFrom<Uint<768, 12>> for Fp768<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<P: Fp832Parameters> TryFrom<Uint<832, 13>> for Fp832<P>
Available on crate feature ark-ff
only.
impl<P: Fp832Parameters> TryFrom<Uint<832, 13>> for Fp832<P>
ark-ff
only.§type Error = ToFieldError
type Error = ToFieldError
source§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.
impl<P: FpConfig<LIMBS>, const BITS: usize, const LIMBS: usize> TryFrom<Uint<BITS, LIMBS>> for Fp<P, LIMBS>
ark-ff-04
only.§type Error = ToFieldError
type Error = ToFieldError
source§impl<const BITS: usize, const LIMBS: usize> TryFrom<f32> for Uint<BITS, LIMBS>
Available on crate feature std
only.
impl<const BITS: usize, const LIMBS: usize> TryFrom<f32> for Uint<BITS, LIMBS>
std
only.source§impl<const BITS: usize, const LIMBS: usize> TryFrom<f64> for Uint<BITS, LIMBS>
Available on crate feature std
only.
impl<const BITS: usize, const LIMBS: usize> TryFrom<f64> for Uint<BITS, LIMBS>
std
only.source§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.
impl<const BITS: usize, const LIMBS: usize, DB: Database> Type<DB> for Uint<BITS, LIMBS>where Vec<u8>: Type<DB>,
sqlx
only.source§impl<const BITS: usize, const LIMBS: usize, T> UintTryFrom<T> for Uint<BITS, LIMBS>where
Self: TryFrom<T, Error = ToUintError<Self>>,
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>
.
fn uint_try_from(value: T) -> Result<Self, ToUintError<Self>>
source§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, const BITS_SRC: usize, const LIMBS_SRC: usize> UintTryFrom<Uint<BITS_SRC, LIMBS_SRC>> for Uint<BITS, LIMBS>
fn uint_try_from( value: Uint<BITS_SRC, LIMBS_SRC> ) -> Result<Self, ToUintError<Self>>
source§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, T> UintTryTo<T> for Uint<BITS, LIMBS>where T: for<'a> TryFrom<&'a Self, Error = FromUintError<T>>,
fn uint_try_to(&self) -> Result<T, FromUintError<T>>
source§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, const BITS_DST: usize, const LIMBS_DST: usize> UintTryTo<Uint<BITS_DST, LIMBS_DST>> for Uint<BITS, LIMBS>
fn uint_try_to( &self ) -> Result<Uint<BITS_DST, LIMBS_DST>, FromUintError<Uint<BITS_DST, LIMBS_DST>>>
source§impl<const BITS: usize, const LIMBS: usize> Valuable for Uint<BITS, LIMBS>
Available on crate feature valuable
only.
impl<const BITS: usize, const LIMBS: usize> Valuable for Uint<BITS, LIMBS>
valuable
only.source§impl<const BITS: usize, const LIMBS: usize> Zeroize for Uint<BITS, LIMBS>
Available on crate feature zeroize
only.
impl<const BITS: usize, const LIMBS: usize> Zeroize for Uint<BITS, LIMBS>
zeroize
only.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>
alloy-rlp
only.impl<const BITS: usize, const LIMBS: usize> StructuralEq for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> StructuralPartialEq for Uint<BITS, LIMBS>
Auto Trait Implementations§
impl<const BITS: usize, const LIMBS: usize> RefUnwindSafe for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Send for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Sync for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> Unpin for Uint<BITS, LIMBS>
impl<const BITS: usize, const LIMBS: usize> UnwindSafe for Uint<BITS, LIMBS>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> BorrowToSql for Twhere
T: ToSql,
impl<T> BorrowToSql for Twhere T: ToSql,
source§fn borrow_to_sql(&self) -> &dyn ToSql
fn borrow_to_sql(&self) -> &dyn ToSql
self
as a ToSql
trait object.source§impl<T> DecodeLimit for Twhere
T: Decode,
impl<T> DecodeLimit for Twhere T: Decode,
§impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.