Struct libp2p::multihash::typenum::uint::UInt [−][src]
UInt
is defined recursively, where B
is the least significant bit and U
is the rest
of the number. Conceptually, U
should be bound by the trait Unsigned
and B
should
be bound by the trait Bit
, but enforcing these bounds causes linear instead of
logrithmic scaling in some places, so they are left off for now. They may be enforced in
future.
In order to keep numbers unique, leading zeros are not allowed, so UInt<UTerm, B0>
is
forbidden.
Example
use typenum::{B0, B1, UInt, UTerm}; type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
Implementations
impl<U, B> UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
Trait Implementations
impl<U, B> Add<B0> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
U + B0 = U
type Output = UInt<U, B>
The resulting type after applying the +
operator.
pub fn add(self, B0) -> <UInt<U, B> as Add<B0>>::Output
[src]
impl<U> Add<B1> for UInt<U, B1> where
U: Unsigned + Add<B1>,
<U as Add<B1>>::Output: Unsigned,
[src]
U: Unsigned + Add<B1>,
<U as Add<B1>>::Output: Unsigned,
UInt<U, B1> + B1 = UInt<U + B1, B0>
type Output = UInt<<U as Add<B1>>::Output, B0>
The resulting type after applying the +
operator.
pub fn add(self, B1) -> <UInt<U, B1> as Add<B1>>::Output
[src]
impl<U> Add<B1> for UInt<U, B0> where
U: Unsigned,
[src]
U: Unsigned,
UInt<U, B0> + B1 = UInt<U + B1>
type Output = UInt<U, B1>
The resulting type after applying the +
operator.
pub fn add(self, B1) -> <UInt<U, B0> as Add<B1>>::Output
[src]
impl<Ul, Ur> Add<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
[src]
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
UInt<Ul, B1> + UInt<Ur, B0> = UInt<Ul + Ur, B1>
type Output = UInt<<Ul as Add<Ur>>::Output, B1>
The resulting type after applying the +
operator.
pub fn add(
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B1> as Add<UInt<Ur, B0>>>::Output
[src]
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B1> as Add<UInt<Ur, B0>>>::Output
impl<Ul, Ur> Add<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
[src]
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
UInt<Ul, B0> + UInt<Ur, B0> = UInt<Ul + Ur, B0>
type Output = UInt<<Ul as Add<Ur>>::Output, B0>
The resulting type after applying the +
operator.
pub fn add(
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B0> as Add<UInt<Ur, B0>>>::Output
[src]
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B0> as Add<UInt<Ur, B0>>>::Output
impl<Ul, Ur> Add<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
[src]
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
UInt<Ul, B0> + UInt<Ur, B1> = UInt<Ul + Ur, B1>
type Output = UInt<<Ul as Add<Ur>>::Output, B1>
The resulting type after applying the +
operator.
pub fn add(
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B0> as Add<UInt<Ur, B1>>>::Output
[src]
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B0> as Add<UInt<Ur, B1>>>::Output
impl<Ul, Ur> Add<UInt<Ur, B1>> for UInt<Ul, B1> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
<Ul as Add<Ur>>::Output: Add<B1>,
[src]
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
<Ul as Add<Ur>>::Output: Add<B1>,
UInt<Ul, B1> + UInt<Ur, B1> = UInt<(Ul + Ur) + B1, B0>
type Output = UInt<<<Ul as Add<Ur>>::Output as Add<B1>>::Output, B0>
The resulting type after applying the +
operator.
pub fn add(
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B1> as Add<UInt<Ur, B1>>>::Output
[src]
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B1> as Add<UInt<Ur, B1>>>::Output
impl<U, B> Add<UTerm> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
UInt<U, B> + UTerm = UInt<U, B>
type Output = UInt<U, B>
The resulting type after applying the +
operator.
pub fn add(self, UTerm) -> <UInt<U, B> as Add<UTerm>>::Output
[src]
impl<T, N> ArrayLength<T> for UInt<N, B0> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
type ArrayType
impl<T, N> ArrayLength<T> for UInt<N, B1> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
type ArrayType
impl<T, N> ArrayLength<T> for UInt<N, B0> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
type ArrayType
impl<T, N> ArrayLength<T> for UInt<N, B1> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
type ArrayType
impl<Ul, Bl, Ur> BitAnd<Ur> for UInt<Ul, Bl> where
Ul: Unsigned,
Ur: Unsigned,
Bl: Bit,
UInt<Ul, Bl>: PrivateAnd<Ur>,
<UInt<Ul, Bl> as PrivateAnd<Ur>>::Output: Trim,
[src]
Ul: Unsigned,
Ur: Unsigned,
Bl: Bit,
UInt<Ul, Bl>: PrivateAnd<Ur>,
<UInt<Ul, Bl> as PrivateAnd<Ur>>::Output: Trim,
Anding unsigned integers.
We use our PrivateAnd
operator and then Trim
the output.
type Output = <<UInt<Ul, Bl> as PrivateAnd<Ur>>::Output as Trim>::Output
The resulting type after applying the &
operator.
pub fn bitand(self, rhs: Ur) -> <UInt<Ul, Bl> as BitAnd<Ur>>::Output
[src]
impl<Ul, Ur> BitOr<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
[src]
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
UInt<Ul, B1> | UInt<Ur, B0> = UInt<Ul | Ur, B1>
type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>
The resulting type after applying the |
operator.
pub fn bitor(
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B0>>>::Output
[src]
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B0>>>::Output
impl<Ul, Ur> BitOr<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
[src]
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
UInt<Ul, B0> | UInt<Ur, B0> = UInt<Ul | Ur, B0>
type Output = UInt<<Ul as BitOr<Ur>>::Output, B0>
The resulting type after applying the |
operator.
pub fn bitor(
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B0>>>::Output
[src]
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B0>>>::Output
impl<Ul, Ur> BitOr<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
[src]
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
UInt<Ul, B0> | UInt<Ur, B1> = UInt<Ul | Ur, B1>
type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>
The resulting type after applying the |
operator.
pub fn bitor(
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B1>>>::Output
[src]
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B1>>>::Output
impl<Ul, Ur> BitOr<UInt<Ur, B1>> for UInt<Ul, B1> where
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
[src]
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
UInt<Ul, B1> | UInt<Ur, B1> = UInt<Ul | Ur, B1>
type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>
The resulting type after applying the |
operator.
pub fn bitor(
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B1>>>::Output
[src]
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B1>>>::Output
impl<B, U> BitOr<UTerm> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
X | UTerm = X
type Output = UInt<U, B>
The resulting type after applying the |
operator.
pub fn bitor(self, UTerm) -> <UInt<U, B> as BitOr<UTerm>>::Output
[src]
impl<Ul, Bl, Ur> BitXor<Ur> for UInt<Ul, Bl> where
Ul: Unsigned,
Ur: Unsigned,
Bl: Bit,
UInt<Ul, Bl>: PrivateXor<Ur>,
<UInt<Ul, Bl> as PrivateXor<Ur>>::Output: Trim,
[src]
Ul: Unsigned,
Ur: Unsigned,
Bl: Bit,
UInt<Ul, Bl>: PrivateXor<Ur>,
<UInt<Ul, Bl> as PrivateXor<Ur>>::Output: Trim,
Xoring unsigned integers.
We use our PrivateXor
operator and then Trim
the output.
type Output = <<UInt<Ul, Bl> as PrivateXor<Ur>>::Output as Trim>::Output
The resulting type after applying the ^
operator.
pub fn bitxor(self, rhs: Ur) -> <UInt<Ul, Bl> as BitXor<Ur>>::Output
[src]
impl<U, B> Clone for UInt<U, B> where
B: Clone,
U: Clone,
[src]
B: Clone,
U: Clone,
impl<U, B> Cmp<UInt<U, B>> for UTerm where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
Zero < Nonzero
type Output = Less
The result of the comparison. It should only ever be one of Greater
, Less
, or Equal
.
pub fn compare<IM>(&self, &UInt<U, B>) -> <UTerm as Cmp<UInt<U, B>>>::Output where
IM: InternalMarker,
[src]
IM: InternalMarker,
impl<Ul, Ur> Cmp<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: Unsigned + PrivateCmp<Ur, Equal>,
Ur: Unsigned,
[src]
Ul: Unsigned + PrivateCmp<Ur, Equal>,
Ur: Unsigned,
UInt<Ul, B0>
cmp with UInt<Ur, B0>
: SoFar
is Equal
type Output = <Ul as PrivateCmp<Ur, Equal>>::Output
The result of the comparison. It should only ever be one of Greater
, Less
, or Equal
.
pub fn compare<IM>(
&self,
rhs: &UInt<Ur, B0>
) -> <UInt<Ul, B0> as Cmp<UInt<Ur, B0>>>::Output where
IM: InternalMarker,
[src]
&self,
rhs: &UInt<Ur, B0>
) -> <UInt<Ul, B0> as Cmp<UInt<Ur, B0>>>::Output where
IM: InternalMarker,
impl<Ul, Ur> Cmp<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: Unsigned + PrivateCmp<Ur, Greater>,
Ur: Unsigned,
[src]
Ul: Unsigned + PrivateCmp<Ur, Greater>,
Ur: Unsigned,
UInt<Ul, B1>
cmp with UInt<Ur, B0>
: SoFar
is Greater
type Output = <Ul as PrivateCmp<Ur, Greater>>::Output
The result of the comparison. It should only ever be one of Greater
, Less
, or Equal
.
pub fn compare<IM>(
&self,
rhs: &UInt<Ur, B0>
) -> <UInt<Ul, B1> as Cmp<UInt<Ur, B0>>>::Output where
IM: InternalMarker,
[src]
&self,
rhs: &UInt<Ur, B0>
) -> <UInt<Ul, B1> as Cmp<UInt<Ur, B0>>>::Output where
IM: InternalMarker,
impl<Ul, Ur> Cmp<UInt<Ur, B1>> for UInt<Ul, B1> where
Ul: Unsigned + PrivateCmp<Ur, Equal>,
Ur: Unsigned,
[src]
Ul: Unsigned + PrivateCmp<Ur, Equal>,
Ur: Unsigned,
UInt<Ul, B1>
cmp with UInt<Ur, B1>
: SoFar
is Equal
type Output = <Ul as PrivateCmp<Ur, Equal>>::Output
The result of the comparison. It should only ever be one of Greater
, Less
, or Equal
.
pub fn compare<IM>(
&self,
rhs: &UInt<Ur, B1>
) -> <UInt<Ul, B1> as Cmp<UInt<Ur, B1>>>::Output where
IM: InternalMarker,
[src]
&self,
rhs: &UInt<Ur, B1>
) -> <UInt<Ul, B1> as Cmp<UInt<Ur, B1>>>::Output where
IM: InternalMarker,
impl<Ul, Ur> Cmp<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: Unsigned + PrivateCmp<Ur, Less>,
Ur: Unsigned,
[src]
Ul: Unsigned + PrivateCmp<Ur, Less>,
Ur: Unsigned,
UInt<Ul, B0>
cmp with UInt<Ur, B1>
: SoFar
is Less
type Output = <Ul as PrivateCmp<Ur, Less>>::Output
The result of the comparison. It should only ever be one of Greater
, Less
, or Equal
.
pub fn compare<IM>(
&self,
rhs: &UInt<Ur, B1>
) -> <UInt<Ul, B0> as Cmp<UInt<Ur, B1>>>::Output where
IM: InternalMarker,
[src]
&self,
rhs: &UInt<Ur, B1>
) -> <UInt<Ul, B0> as Cmp<UInt<Ur, B1>>>::Output where
IM: InternalMarker,
impl<U, B> Cmp<UTerm> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
Nonzero > Zero
type Output = Greater
The result of the comparison. It should only ever be one of Greater
, Less
, or Equal
.
pub fn compare<IM>(&self, &UTerm) -> <UInt<U, B> as Cmp<UTerm>>::Output where
IM: InternalMarker,
[src]
IM: InternalMarker,
impl<U, B> Copy for UInt<U, B> where
B: Copy,
U: Copy,
[src]
B: Copy,
U: Copy,
impl<U, B> Debug for UInt<U, B> where
B: Debug,
U: Debug,
[src]
B: Debug,
U: Debug,
impl<U, B> Default for UInt<U, B> where
B: Default,
U: Default,
[src]
B: Default,
U: Default,
impl<Ur, Br> Div<UInt<Ur, Br>> for UTerm where
Ur: Unsigned,
Br: Bit,
[src]
Ur: Unsigned,
Br: Bit,
type Output = UTerm
The resulting type after applying the /
operator.
pub fn div(self, UInt<Ur, Br>) -> <UTerm as Div<UInt<Ur, Br>>>::Output
[src]
impl<Ul, Bl, Ur, Br> Div<UInt<Ur, Br>> for UInt<Ul, Bl> where
Ul: Unsigned,
Ur: Unsigned,
Br: Bit,
Bl: Bit,
UInt<Ul, Bl>: Len,
<UInt<Ul, Bl> as Len>::Output: Sub<B1>,
(): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>,
[src]
Ul: Unsigned,
Ur: Unsigned,
Br: Bit,
Bl: Bit,
UInt<Ul, Bl>: Len,
<UInt<Ul, Bl> as Len>::Output: Sub<B1>,
(): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>,
type Output = <() as PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>>::Quotient
The resulting type after applying the /
operator.
pub fn div(
self,
rhs: UInt<Ur, Br>
) -> <UInt<Ul, Bl> as Div<UInt<Ur, Br>>>::Output
[src]
self,
rhs: UInt<Ur, Br>
) -> <UInt<Ul, Bl> as Div<UInt<Ur, Br>>>::Output
impl<U, B> Eq for UInt<U, B> where
B: Eq,
U: Eq,
[src]
B: Eq,
U: Eq,
impl<Xp, Yp> Gcd<UInt<Yp, B0>> for UInt<Xp, B0> where
Xp: Gcd<Yp>,
UInt<Xp, B0>: NonZero,
UInt<Yp, B0>: NonZero,
[src]
Xp: Gcd<Yp>,
UInt<Xp, B0>: NonZero,
UInt<Yp, B0>: NonZero,
gcd(x, y) = 2*gcd(x/2, y/2) if both x and y even
impl<Xp, Yp> Gcd<UInt<Yp, B0>> for UInt<Xp, B1> where
UInt<Xp, B1>: Gcd<Yp>,
UInt<Yp, B0>: NonZero,
[src]
UInt<Xp, B1>: Gcd<Yp>,
UInt<Yp, B0>: NonZero,
gcd(x, y) = gcd(x, y/2) if x odd and y even
impl<Xp, Yp> Gcd<UInt<Yp, B1>> for UInt<Xp, B0> where
Xp: Gcd<UInt<Yp, B1>>,
UInt<Xp, B0>: NonZero,
[src]
Xp: Gcd<UInt<Yp, B1>>,
UInt<Xp, B0>: NonZero,
gcd(x, y) = gcd(x/2, y) if x even and y odd
impl<Xp, Yp> Gcd<UInt<Yp, B1>> for UInt<Xp, B1> where
UInt<Xp, B1>: Max<UInt<Yp, B1>>,
UInt<Xp, B1>: Min<UInt<Yp, B1>>,
UInt<Yp, B1>: Max<UInt<Xp, B1>>,
UInt<Yp, B1>: Min<UInt<Xp, B1>>,
<UInt<Xp, B1> as Max<UInt<Yp, B1>>>::Output: Sub<<UInt<Xp, B1> as Min<UInt<Yp, B1>>>::Output>,
<<UInt<Xp, B1> as Max<UInt<Yp, B1>>>::Output as Sub<<UInt<Xp, B1> as Min<UInt<Yp, B1>>>::Output>>::Output: Gcd<<UInt<Xp, B1> as Min<UInt<Yp, B1>>>::Output>,
[src]
UInt<Xp, B1>: Max<UInt<Yp, B1>>,
UInt<Xp, B1>: Min<UInt<Yp, B1>>,
UInt<Yp, B1>: Max<UInt<Xp, B1>>,
UInt<Yp, B1>: Min<UInt<Xp, B1>>,
<UInt<Xp, B1> as Max<UInt<Yp, B1>>>::Output: Sub<<UInt<Xp, B1> as Min<UInt<Yp, B1>>>::Output>,
<<UInt<Xp, B1> as Max<UInt<Yp, B1>>>::Output as Sub<<UInt<Xp, B1> as Min<UInt<Yp, B1>>>::Output>>::Output: Gcd<<UInt<Xp, B1> as Min<UInt<Yp, B1>>>::Output>,
gcd(x, y) = gcd([max(x, y) - min(x, y)], min(x, y)) if both x and y odd
This will immediately invoke the case for x even and y odd because the difference of two odd numbers is an even number.
type Output = <<<UInt<Xp, B1> as Max<UInt<Yp, B1>>>::Output as Sub<<UInt<Xp, B1> as Min<UInt<Yp, B1>>>::Output>>::Output as Gcd<<UInt<Xp, B1> as Min<UInt<Yp, B1>>>::Output>>::Output
The greatest common divisor.
impl<Un, Bn, Ui, Bi> GetBit<UInt<Ui, Bi>> for UInt<Un, Bn> where
Un: GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>,
UInt<Ui, Bi>: Copy,
UInt<Ui, Bi>: Sub<B1>,
[src]
Un: GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>,
UInt<Ui, Bi>: Copy,
UInt<Ui, Bi>: Sub<B1>,
type Output = <Un as GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>>::Output
pub fn get_bit<IM>(
&self,
i: &UInt<Ui, Bi>
) -> <UInt<Un, Bn> as GetBit<UInt<Ui, Bi>>>::Output where
IM: InternalMarker,
[src]
&self,
i: &UInt<Ui, Bi>
) -> <UInt<Un, Bn> as GetBit<UInt<Ui, Bi>>>::Output where
IM: InternalMarker,
impl<Un, Bn> GetBit<UTerm> for UInt<Un, Bn> where
Bn: Copy,
[src]
Bn: Copy,
type Output = Bn
pub fn get_bit<IM>(&self, &UTerm) -> <UInt<Un, Bn> as GetBit<UTerm>>::Output where
IM: InternalMarker,
[src]
IM: InternalMarker,
impl<U, B> Hash for UInt<U, B> where
B: Hash,
U: Hash,
[src]
B: Hash,
U: Hash,
pub fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,
[src]
__H: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<U, B> Len for UInt<U, B> where
B: Bit,
U: Unsigned + Len,
<U as Len>::Output: Add<B1>,
<<U as Len>::Output as Add<B1>>::Output: Unsigned,
[src]
B: Bit,
U: Unsigned + Len,
<U as Len>::Output: Add<B1>,
<<U as Len>::Output as Add<B1>>::Output: Unsigned,
Length of a bit is 1
type Output = <<U as Len>::Output as Add<B1>>::Output
The length as a type-level unsigned integer.
pub fn len(&self) -> <UInt<U, B> as Len>::Output
[src]
impl<U, B, Ur> Max<Ur> for UInt<U, B> where
B: Bit,
U: Unsigned,
Ur: Unsigned,
UInt<U, B>: Cmp<Ur>,
UInt<U, B>: PrivateMax<Ur, <UInt<U, B> as Cmp<Ur>>::Output>,
[src]
B: Bit,
U: Unsigned,
Ur: Unsigned,
UInt<U, B>: Cmp<Ur>,
UInt<U, B>: PrivateMax<Ur, <UInt<U, B> as Cmp<Ur>>::Output>,
type Output = <UInt<U, B> as PrivateMax<Ur, <UInt<U, B> as Cmp<Ur>>::Output>>::Output
The type of the maximum of Self
and Rhs
pub fn max(self, rhs: Ur) -> <UInt<U, B> as Max<Ur>>::Output
[src]
impl<U, B, Ur> Min<Ur> for UInt<U, B> where
B: Bit,
U: Unsigned,
Ur: Unsigned,
UInt<U, B>: Cmp<Ur>,
UInt<U, B>: PrivateMin<Ur, <UInt<U, B> as Cmp<Ur>>::Output>,
[src]
B: Bit,
U: Unsigned,
Ur: Unsigned,
UInt<U, B>: Cmp<Ur>,
UInt<U, B>: PrivateMin<Ur, <UInt<U, B> as Cmp<Ur>>::Output>,
type Output = <UInt<U, B> as PrivateMin<Ur, <UInt<U, B> as Cmp<Ur>>::Output>>::Output
The type of the minimum of Self
and Rhs
pub fn min(self, rhs: Ur) -> <UInt<U, B> as Min<Ur>>::Output
[src]
impl<U, B> Mul<B0> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
UInt * B0 = UTerm
type Output = UTerm
The resulting type after applying the *
operator.
pub fn mul(self, B0) -> <UInt<U, B> as Mul<B0>>::Output
[src]
impl<U, B> Mul<B1> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
UInt * B1 = UInt
type Output = UInt<U, B>
The resulting type after applying the *
operator.
pub fn mul(self, B1) -> <UInt<U, B> as Mul<B1>>::Output
[src]
impl<Ul, B, Ur> Mul<UInt<Ur, B>> for UInt<Ul, B1> where
B: Bit,
Ul: Unsigned + Mul<UInt<Ur, B>>,
Ur: Unsigned,
UInt<<Ul as Mul<UInt<Ur, B>>>::Output, B0>: Add<UInt<Ur, B>>,
[src]
B: Bit,
Ul: Unsigned + Mul<UInt<Ur, B>>,
Ur: Unsigned,
UInt<<Ul as Mul<UInt<Ur, B>>>::Output, B0>: Add<UInt<Ur, B>>,
UInt<Ul, B1> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0> + UInt<Ur, B>
type Output = <UInt<<Ul as Mul<UInt<Ur, B>>>::Output, B0> as Add<UInt<Ur, B>>>::Output
The resulting type after applying the *
operator.
pub fn mul(self, rhs: UInt<Ur, B>) -> <UInt<Ul, B1> as Mul<UInt<Ur, B>>>::Output
[src]
impl<Ul, B, Ur> Mul<UInt<Ur, B>> for UInt<Ul, B0> where
B: Bit,
Ul: Unsigned + Mul<UInt<Ur, B>>,
Ur: Unsigned,
[src]
B: Bit,
Ul: Unsigned + Mul<UInt<Ur, B>>,
Ur: Unsigned,
UInt<Ul, B0> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0>
type Output = UInt<<Ul as Mul<UInt<Ur, B>>>::Output, B0>
The resulting type after applying the *
operator.
pub fn mul(self, rhs: UInt<Ur, B>) -> <UInt<Ul, B0> as Mul<UInt<Ur, B>>>::Output
[src]
impl<U, B> Mul<UTerm> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
UInt<U, B> * UTerm = UTerm
type Output = UTerm
The resulting type after applying the *
operator.
pub fn mul(self, UTerm) -> <UInt<U, B> as Mul<UTerm>>::Output
[src]
impl<U, B> NonZero for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
impl<U, B> Ord for UInt<U, B> where
B: Ord,
U: Ord,
[src]
B: Ord,
U: Ord,
pub fn cmp(&self, other: &UInt<U, B>) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Ul, Bl, Ur, Br> PartialDiv<UInt<Ur, Br>> for UInt<Ul, Bl> where
Ul: Unsigned,
Ur: Unsigned,
Br: Bit,
Bl: Bit,
UInt<Ul, Bl>: Div<UInt<Ur, Br>>,
UInt<Ul, Bl>: Rem<UInt<Ur, Br>>,
<UInt<Ul, Bl> as Rem<UInt<Ur, Br>>>::Output == UTerm,
[src]
Ul: Unsigned,
Ur: Unsigned,
Br: Bit,
Bl: Bit,
UInt<Ul, Bl>: Div<UInt<Ur, Br>>,
UInt<Ul, Bl>: Rem<UInt<Ur, Br>>,
<UInt<Ul, Bl> as Rem<UInt<Ur, Br>>>::Output == UTerm,
type Output = <UInt<Ul, Bl> as Div<UInt<Ur, Br>>>::Output
The type of the result of the division
pub fn partial_div(
self,
rhs: UInt<Ur, Br>
) -> <UInt<Ul, Bl> as PartialDiv<UInt<Ur, Br>>>::Output
[src]
self,
rhs: UInt<Ur, Br>
) -> <UInt<Ul, Bl> as PartialDiv<UInt<Ur, Br>>>::Output
impl<Ur, Br> PartialDiv<UInt<Ur, Br>> for UTerm where
Ur: Unsigned,
Br: Bit,
[src]
Ur: Unsigned,
Br: Bit,
type Output = UTerm
The type of the result of the division
pub fn partial_div(
self,
UInt<Ur, Br>
) -> <UTerm as PartialDiv<UInt<Ur, Br>>>::Output
[src]
self,
UInt<Ur, Br>
) -> <UTerm as PartialDiv<UInt<Ur, Br>>>::Output
impl<U, B> PartialEq<UInt<U, B>> for UInt<U, B> where
B: PartialEq<B>,
U: PartialEq<U>,
[src]
B: PartialEq<B>,
U: PartialEq<U>,
impl<U, B> PartialOrd<UInt<U, B>> for UInt<U, B> where
B: PartialOrd<B>,
U: PartialOrd<U>,
[src]
B: PartialOrd<B>,
U: PartialOrd<U>,
pub fn partial_cmp(&self, other: &UInt<U, B>) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<U, B> Pow<UInt<U, B>> for i16 where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = i16
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <i16 as Pow<UInt<U, B>>>::Output
[src]
impl<U, B> Pow<UInt<U, B>> for i64 where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = i64
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <i64 as Pow<UInt<U, B>>>::Output
[src]
impl<U, B> Pow<UInt<U, B>> for f64 where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = f64
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <f64 as Pow<UInt<U, B>>>::Output
[src]
impl<U, B> Pow<UInt<U, B>> for i32 where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = i32
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <i32 as Pow<UInt<U, B>>>::Output
[src]
impl<U, B> Pow<UInt<U, B>> for i8 where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = i8
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <i8 as Pow<UInt<U, B>>>::Output
[src]
impl<U, B> Pow<UInt<U, B>> for u64 where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = u64
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <u64 as Pow<UInt<U, B>>>::Output
[src]
impl<U, B> Pow<UInt<U, B>> for usize where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = usize
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <usize as Pow<UInt<U, B>>>::Output
[src]
impl<U, B> Pow<UInt<U, B>> for u32 where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = u32
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <u32 as Pow<UInt<U, B>>>::Output
[src]
impl<U, B> Pow<UInt<U, B>> for u16 where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = u16
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <u16 as Pow<UInt<U, B>>>::Output
[src]
impl<U, B> Pow<UInt<U, B>> for isize where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = isize
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <isize as Pow<UInt<U, B>>>::Output
[src]
impl<U, B> Pow<UInt<U, B>> for u8 where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = u8
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <u8 as Pow<UInt<U, B>>>::Output
[src]
impl<U, B> Pow<UInt<U, B>> for f32 where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
type Output = f32
The result of the exponentiation.
pub fn powi(self, UInt<U, B>) -> <f32 as Pow<UInt<U, B>>>::Output
[src]
impl<U> PowerOfTwo for UInt<U, B0> where
U: Unsigned + PowerOfTwo,
[src]
U: Unsigned + PowerOfTwo,
impl PowerOfTwo for UInt<UTerm, B1>
[src]
impl<Ul, Bl, Ur, Br> Rem<UInt<Ur, Br>> for UInt<Ul, Bl> where
Ul: Unsigned,
Ur: Unsigned,
Br: Bit,
Bl: Bit,
UInt<Ul, Bl>: Len,
<UInt<Ul, Bl> as Len>::Output: Sub<B1>,
(): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>,
[src]
Ul: Unsigned,
Ur: Unsigned,
Br: Bit,
Bl: Bit,
UInt<Ul, Bl>: Len,
<UInt<Ul, Bl> as Len>::Output: Sub<B1>,
(): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>,
type Output = <() as PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>>::Remainder
The resulting type after applying the %
operator.
pub fn rem(
self,
rhs: UInt<Ur, Br>
) -> <UInt<Ul, Bl> as Rem<UInt<Ur, Br>>>::Output
[src]
self,
rhs: UInt<Ur, Br>
) -> <UInt<Ul, Bl> as Rem<UInt<Ur, Br>>>::Output
impl<Ur, Br> Rem<UInt<Ur, Br>> for UTerm where
Ur: Unsigned,
Br: Bit,
[src]
Ur: Unsigned,
Br: Bit,
type Output = UTerm
The resulting type after applying the %
operator.
pub fn rem(self, UInt<Ur, Br>) -> <UTerm as Rem<UInt<Ur, Br>>>::Output
[src]
impl<U, B> Shl<B0> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
Shifting left any unsigned by a zero bit: U << B0 = U
type Output = UInt<U, B>
The resulting type after applying the <<
operator.
pub fn shl(self, B0) -> <UInt<U, B> as Shl<B0>>::Output
[src]
impl<U, B> Shl<B1> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
Shifting left a UInt
by a one bit: UInt<U, B> << B1 = UInt<UInt<U, B>, B0>
type Output = UInt<UInt<U, B>, B0>
The resulting type after applying the <<
operator.
pub fn shl(self, B1) -> <UInt<U, B> as Shl<B1>>::Output
[src]
impl<U, B, Ur, Br> Shl<UInt<Ur, Br>> for UInt<U, B> where
B: Bit,
U: Unsigned,
Ur: Unsigned,
Br: Bit,
UInt<Ur, Br>: Sub<B1>,
UInt<UInt<U, B>, B0>: Shl<<UInt<Ur, Br> as Sub<B1>>::Output>,
[src]
B: Bit,
U: Unsigned,
Ur: Unsigned,
Br: Bit,
UInt<Ur, Br>: Sub<B1>,
UInt<UInt<U, B>, B0>: Shl<<UInt<Ur, Br> as Sub<B1>>::Output>,
Shifting left UInt
by UInt
: X << Y
= UInt(X, B0) << (Y - 1)
type Output = <UInt<UInt<U, B>, B0> as Shl<<UInt<Ur, Br> as Sub<B1>>::Output>>::Output
The resulting type after applying the <<
operator.
pub fn shl(self, rhs: UInt<Ur, Br>) -> <UInt<U, B> as Shl<UInt<Ur, Br>>>::Output
[src]
impl<U, B> Shl<UTerm> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
Shifting left UInt
by UTerm
: UInt<U, B> << UTerm = UInt<U, B>
type Output = UInt<U, B>
The resulting type after applying the <<
operator.
pub fn shl(self, UTerm) -> <UInt<U, B> as Shl<UTerm>>::Output
[src]
impl<U, B> Shr<B0> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
Shifting right any unsigned by a zero bit: U >> B0 = U
type Output = UInt<U, B>
The resulting type after applying the >>
operator.
pub fn shr(self, B0) -> <UInt<U, B> as Shr<B0>>::Output
[src]
impl<U, B> Shr<B1> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
Shifting right a UInt
by a 1 bit: UInt<U, B> >> B1 = U
type Output = U
The resulting type after applying the >>
operator.
pub fn shr(self, B1) -> <UInt<U, B> as Shr<B1>>::Output
[src]
impl<U, B, Ur, Br> Shr<UInt<Ur, Br>> for UInt<U, B> where
B: Bit,
U: Unsigned + Shr<<UInt<Ur, Br> as Sub<B1>>::Output>,
Ur: Unsigned,
Br: Bit,
UInt<Ur, Br>: Sub<B1>,
[src]
B: Bit,
U: Unsigned + Shr<<UInt<Ur, Br> as Sub<B1>>::Output>,
Ur: Unsigned,
Br: Bit,
UInt<Ur, Br>: Sub<B1>,
Shifting right UInt
by UInt
: UInt(U, B) >> Y
= U >> (Y - 1)
type Output = <U as Shr<<UInt<Ur, Br> as Sub<B1>>::Output>>::Output
The resulting type after applying the >>
operator.
pub fn shr(self, rhs: UInt<Ur, Br>) -> <UInt<U, B> as Shr<UInt<Ur, Br>>>::Output
[src]
impl<U, B> Shr<UTerm> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
Shifting right UInt
by UTerm
: UInt<U, B> >> UTerm = UInt<U, B>
type Output = UInt<U, B>
The resulting type after applying the >>
operator.
pub fn shr(self, UTerm) -> <UInt<U, B> as Shr<UTerm>>::Output
[src]
impl<U, B> StructuralEq for UInt<U, B>
[src]
impl<U, B> StructuralPartialEq for UInt<U, B>
[src]
impl<U, B> Sub<B0> for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
UInt - B0 = UInt
type Output = UInt<U, B>
The resulting type after applying the -
operator.
pub fn sub(self, B0) -> <UInt<U, B> as Sub<B0>>::Output
[src]
impl<U, B> Sub<B1> for UInt<UInt<U, B>, B1> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
UInt<U, B1> - B1 = UInt<U, B0>
type Output = UInt<UInt<U, B>, B0>
The resulting type after applying the -
operator.
pub fn sub(self, B1) -> <UInt<UInt<U, B>, B1> as Sub<B1>>::Output
[src]
impl Sub<B1> for UInt<UTerm, B1>
[src]
UInt<UTerm, B1> - B1 = UTerm
type Output = UTerm
The resulting type after applying the -
operator.
pub fn sub(self, B1) -> <UInt<UTerm, B1> as Sub<B1>>::Output
[src]
impl<U> Sub<B1> for UInt<U, B0> where
U: Unsigned + Sub<B1>,
<U as Sub<B1>>::Output: Unsigned,
[src]
U: Unsigned + Sub<B1>,
<U as Sub<B1>>::Output: Unsigned,
UInt<U, B0> - B1 = UInt<U - B1, B1>
type Output = UInt<<U as Sub<B1>>::Output, B1>
The resulting type after applying the -
operator.
pub fn sub(self, B1) -> <UInt<U, B0> as Sub<B1>>::Output
[src]
impl<Ul, Bl, Ur> Sub<Ur> for UInt<Ul, Bl> where
Ul: Unsigned,
Ur: Unsigned,
Bl: Bit,
UInt<Ul, Bl>: PrivateSub<Ur>,
<UInt<Ul, Bl> as PrivateSub<Ur>>::Output: Trim,
[src]
Ul: Unsigned,
Ur: Unsigned,
Bl: Bit,
UInt<Ul, Bl>: PrivateSub<Ur>,
<UInt<Ul, Bl> as PrivateSub<Ur>>::Output: Trim,
Subtracting unsigned integers. We just do our PrivateSub
and then Trim
the output.
type Output = <<UInt<Ul, Bl> as PrivateSub<Ur>>::Output as Trim>::Output
The resulting type after applying the -
operator.
pub fn sub(self, rhs: Ur) -> <UInt<Ul, Bl> as Sub<Ur>>::Output
[src]
impl<U, B> Unsigned for UInt<U, B> where
B: Bit,
U: Unsigned,
[src]
B: Bit,
U: Unsigned,
pub const U8: u8
[src]
pub const U16: u16
[src]
pub const U32: u32
[src]
pub const U64: u64
[src]
pub const USIZE: usize
[src]
pub const I8: i8
[src]
pub const I16: i16
[src]
pub const I32: i32
[src]
pub const I64: i64
[src]
pub const ISIZE: isize
[src]
pub fn to_u8() -> u8
[src]
pub fn to_u16() -> u16
[src]
pub fn to_u32() -> u32
[src]
pub fn to_u64() -> u64
[src]
pub fn to_usize() -> usize
[src]
pub fn to_i8() -> i8
[src]
pub fn to_i16() -> i16
[src]
pub fn to_i32() -> i32
[src]
pub fn to_i64() -> i64
[src]
pub fn to_isize() -> isize
[src]
Auto Trait Implementations
impl<U, B> RefUnwindSafe for UInt<U, B> where
B: RefUnwindSafe,
U: RefUnwindSafe,
B: RefUnwindSafe,
U: RefUnwindSafe,
impl<U, B> Send for UInt<U, B> where
B: Send,
U: Send,
B: Send,
U: Send,
impl<U, B> Sync for UInt<U, B> where
B: Sync,
U: Sync,
B: Sync,
U: Sync,
impl<U, B> Unpin for UInt<U, B> where
B: Unpin,
U: Unpin,
B: Unpin,
U: Unpin,
impl<U, B> UnwindSafe for UInt<U, B> where
B: UnwindSafe,
U: UnwindSafe,
B: UnwindSafe,
U: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> CallHasher for T where
T: Hash,
[src]
T: Hash,
impl<T> From<T> for T
[src]
impl<X> Gcd<UTerm> for X where
X: Unsigned + NonZero,
[src]
X: Unsigned + NonZero,
type Output = X
The greatest common divisor.
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<N> Logarithm2 for N where
N: PrivateLogarithm2,
[src]
N: PrivateLogarithm2,
type Output = <N as PrivateLogarithm2>::Output
The result of the integer binary logarithm.
impl<X, N> Pow<N> for X where
N: Unsigned,
X: Unsigned + PrivatePow<UInt<UTerm, B1>, N>,
[src]
N: Unsigned,
X: Unsigned + PrivatePow<UInt<UTerm, B1>, N>,
type Output = <X as PrivatePow<UInt<UTerm, B1>, N>>::Output
The result of the exponentiation.
pub fn powi(self, n: N) -> <X as Pow<N>>::Output
[src]
impl<T> Same<T> for T
[src]
type Output = T
Should always be Self
impl<N, I, B> SetBit<I, B> for N where
N: PrivateSetBit<I, B>,
<N as PrivateSetBit<I, B>>::Output: Trim,
[src]
N: PrivateSetBit<I, B>,
<N as PrivateSetBit<I, B>>::Output: Trim,
type Output = <<N as PrivateSetBit<I, B>>::Output as Trim>::Output
pub fn set_bit<IM>(self, i: I, b: B) -> <N as SetBit<I, B>>::Output where
IM: InternalMarker,
[src]
IM: InternalMarker,
impl<T> Size for T where
T: 'static + ArrayLength<u8> + Debug + Default + Eq + Hash + Send + Sync,
[src]
T: 'static + ArrayLength<u8> + Debug + Default + Eq + Hash + Send + Sync,
impl<N> SquareRoot for N where
N: PrivateSquareRoot,
[src]
N: PrivateSquareRoot,
type Output = <N as PrivateSquareRoot>::Output
The result of the integer square root.
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
[src]
V: MultiLane<T>,