[−]Struct cv::knn::hnsw::typenum::UInt
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,
B: Bit,
U: Unsigned,
Trait Implementations
impl<U, B> Add<B0> for UInt<U, B> where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
U + B0 = U
type Output = UInt<U, B>
The resulting type after applying the +
operator.
fn add(self, B0) -> <UInt<U, B> as Add<B0>>::Output
impl<U> Add<B1> for UInt<U, B0> where
U: Unsigned,
U: Unsigned,
UInt<U, B0> + B1 = UInt<U + B1>
type Output = UInt<U, B1>
The resulting type after applying the +
operator.
fn add(self, B1) -> <UInt<U, B0> as Add<B1>>::Output
impl<U> Add<B1> for UInt<U, B1> where
U: Unsigned + Add<B1>,
<U as Add<B1>>::Output: Unsigned,
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.
fn add(self, B1) -> <UInt<U, B1> as Add<B1>>::Output
impl<Ul, Ur> Add<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
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.
fn add(self, rhs: UInt<Ur, B0>) -> <UInt<Ul, B0> as Add<UInt<Ur, B0>>>::Output
impl<Ul, Ur> Add<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
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.
fn add(self, rhs: UInt<Ur, B0>) -> <UInt<Ul, B1> as Add<UInt<Ur, B0>>>::Output
impl<Ul, Ur> Add<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: Unsigned + Add<Ur>,
Ur: Unsigned,
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.
fn add(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>,
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.
fn add(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,
B: Bit,
U: Unsigned,
UInt<U, B> + UTerm = UInt<U, B>
type Output = UInt<U, B>
The resulting type after applying the +
operator.
fn add(self, UTerm) -> <UInt<U, B> as Add<UTerm>>::Output
impl<T, N> ArrayLength<T> for UInt<N, B0> where
N: ArrayLength<T>,
N: ArrayLength<T>,
type ArrayType
impl<T, N> ArrayLength<T> for UInt<N, B1> where
N: ArrayLength<T>,
N: ArrayLength<T>,
type ArrayType
impl<Ul, Bl, Ur> BitAnd<Ur> for UInt<Ul, Bl> where
Bl: Bit,
Ul: Unsigned,
Ur: Unsigned,
UInt<Ul, Bl>: PrivateAnd<Ur>,
<UInt<Ul, Bl> as PrivateAnd<Ur>>::Output: Trim,
Bl: Bit,
Ul: Unsigned,
Ur: Unsigned,
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.
fn bitand(self, rhs: Ur) -> <UInt<Ul, Bl> as BitAnd<Ur>>::Output
impl<Ul, Ur> BitOr<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
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.
fn bitor(
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B0>>>::Output
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B0>>>::Output
impl<Ul, Ur> BitOr<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
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.
fn bitor(
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B0>>>::Output
self,
rhs: UInt<Ur, B0>
) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B0>>>::Output
impl<Ul, Ur> BitOr<UInt<Ur, B1>> for UInt<Ul, B1> where
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
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.
fn bitor(
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B1>>>::Output
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B1>>>::Output
impl<Ul, Ur> BitOr<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: Unsigned + BitOr<Ur>,
Ur: Unsigned,
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.
fn bitor(
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B1>>>::Output
self,
rhs: UInt<Ur, B1>
) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B1>>>::Output
impl<B, U> BitOr<UTerm> for UInt<U, B> where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
X | UTerm = X
type Output = UInt<U, B>
The resulting type after applying the |
operator.
fn bitor(self, UTerm) -> <UInt<U, B> as BitOr<UTerm>>::Output
impl<Ul, Bl, Ur> BitXor<Ur> for UInt<Ul, Bl> where
Bl: Bit,
Ul: Unsigned,
Ur: Unsigned,
UInt<Ul, Bl>: PrivateXor<Ur>,
<UInt<Ul, Bl> as PrivateXor<Ur>>::Output: Trim,
Bl: Bit,
Ul: Unsigned,
Ur: Unsigned,
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.
fn bitxor(self, rhs: Ur) -> <UInt<Ul, Bl> as BitXor<Ur>>::Output
impl<U, B> Clone for UInt<U, B> where
B: Clone,
U: Clone,
B: Clone,
U: Clone,
fn clone(&self) -> UInt<U, B>
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<U, B> Cmp<UInt<U, B>> for UTerm where
B: Bit,
U: Unsigned,
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
.
fn compare<IM>(&self, &UInt<U, B>) -> <UTerm as Cmp<UInt<U, B>>>::Output where
IM: InternalMarker,
IM: InternalMarker,
impl<Ul, Ur> Cmp<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: Unsigned + PrivateCmp<Ur, Greater>,
Ur: Unsigned,
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
.
fn compare<IM>(
&self,
rhs: &UInt<Ur, B0>
) -> <UInt<Ul, B1> as Cmp<UInt<Ur, B0>>>::Output where
IM: InternalMarker,
&self,
rhs: &UInt<Ur, B0>
) -> <UInt<Ul, B1> as Cmp<UInt<Ur, B0>>>::Output where
IM: InternalMarker,
impl<Ul, Ur> Cmp<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: Unsigned + PrivateCmp<Ur, Equal>,
Ur: Unsigned,
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
.
fn compare<IM>(
&self,
rhs: &UInt<Ur, B0>
) -> <UInt<Ul, B0> as Cmp<UInt<Ur, B0>>>::Output where
IM: InternalMarker,
&self,
rhs: &UInt<Ur, B0>
) -> <UInt<Ul, B0> as Cmp<UInt<Ur, B0>>>::Output where
IM: InternalMarker,
impl<Ul, Ur> Cmp<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: Unsigned + PrivateCmp<Ur, Less>,
Ur: Unsigned,
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
.
fn compare<IM>(
&self,
rhs: &UInt<Ur, B1>
) -> <UInt<Ul, B0> as Cmp<UInt<Ur, B1>>>::Output where
IM: InternalMarker,
&self,
rhs: &UInt<Ur, B1>
) -> <UInt<Ul, B0> as Cmp<UInt<Ur, B1>>>::Output where
IM: InternalMarker,
impl<Ul, Ur> Cmp<UInt<Ur, B1>> for UInt<Ul, B1> where
Ul: Unsigned + PrivateCmp<Ur, Equal>,
Ur: Unsigned,
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
.
fn compare<IM>(
&self,
rhs: &UInt<Ur, B1>
) -> <UInt<Ul, B1> as Cmp<UInt<Ur, B1>>>::Output where
IM: InternalMarker,
&self,
rhs: &UInt<Ur, B1>
) -> <UInt<Ul, B1> as Cmp<UInt<Ur, B1>>>::Output where
IM: InternalMarker,
impl<U, B> Cmp<UTerm> for UInt<U, B> where
B: Bit,
U: Unsigned,
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
.
fn compare<IM>(&self, &UTerm) -> <UInt<U, B> as Cmp<UTerm>>::Output where
IM: InternalMarker,
IM: InternalMarker,
impl<U, B> Copy for UInt<U, B> where
B: Copy,
U: Copy,
B: Copy,
U: Copy,
impl<U, B> Debug for UInt<U, B> where
B: Debug,
U: Debug,
B: Debug,
U: Debug,
impl<U, B> Default for UInt<U, B> where
B: Default,
U: Default,
B: Default,
U: Default,
impl<U, B> Dim for UInt<U, B> where
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
U: DimName + Unsigned,
[src]
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
U: DimName + Unsigned,
fn try_to_usize() -> Option<usize>
[src]
fn from_usize(dim: usize) -> UInt<U, B>
[src]
fn value(&self) -> usize
[src]
fn is<D>() -> bool where
D: Dim,
[src]
D: Dim,
impl<A, B, C, D, E, F, G> Dim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G> where
A: PartialEq<A> + Send + Copy + Sync + Any + Debug + Bit,
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
C: PartialEq<C> + Send + Copy + Sync + Any + Debug + Bit,
D: PartialEq<D> + Send + Copy + Sync + Any + Debug + Bit,
E: PartialEq<E> + Send + Copy + Sync + Any + Debug + Bit,
F: PartialEq<F> + Send + Copy + Sync + Any + Debug + Bit,
G: PartialEq<G> + Send + Copy + Sync + Any + Debug + Bit,
[src]
A: PartialEq<A> + Send + Copy + Sync + Any + Debug + Bit,
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
C: PartialEq<C> + Send + Copy + Sync + Any + Debug + Bit,
D: PartialEq<D> + Send + Copy + Sync + Any + Debug + Bit,
E: PartialEq<E> + Send + Copy + Sync + Any + Debug + Bit,
F: PartialEq<F> + Send + Copy + Sync + Any + Debug + Bit,
G: PartialEq<G> + Send + Copy + Sync + Any + Debug + Bit,
fn try_to_usize() -> Option<usize>
[src]
fn from_usize(
dim: usize
) -> UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G>
[src]
dim: usize
) -> UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G>
fn value(&self) -> usize
[src]
fn is<D>() -> bool where
D: Dim,
[src]
D: Dim,
impl<U, B> DimName for UInt<U, B> where
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
U: DimName + Unsigned,
[src]
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
U: DimName + Unsigned,
impl<A, B, C, D, E, F, G> DimName for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G> where
A: PartialEq<A> + Send + Copy + Sync + Any + Debug + Bit,
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
C: PartialEq<C> + Send + Copy + Sync + Any + Debug + Bit,
D: PartialEq<D> + Send + Copy + Sync + Any + Debug + Bit,
E: PartialEq<E> + Send + Copy + Sync + Any + Debug + Bit,
F: PartialEq<F> + Send + Copy + Sync + Any + Debug + Bit,
G: PartialEq<G> + Send + Copy + Sync + Any + Debug + Bit,
[src]
A: PartialEq<A> + Send + Copy + Sync + Any + Debug + Bit,
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
C: PartialEq<C> + Send + Copy + Sync + Any + Debug + Bit,
D: PartialEq<D> + Send + Copy + Sync + Any + Debug + Bit,
E: PartialEq<E> + Send + Copy + Sync + Any + Debug + Bit,
F: PartialEq<F> + Send + Copy + Sync + Any + Debug + Bit,
G: PartialEq<G> + Send + Copy + Sync + Any + Debug + Bit,
type Value = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G>
fn name(
) -> UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G>
[src]
) -> UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G>
fn dim() -> usize
[src]
impl<Ul, Bl, Ur, Br> Div<UInt<Ur, Br>> for UInt<Ul, Bl> where
Bl: Bit,
Br: Bit,
Ul: Unsigned,
Ur: Unsigned,
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>,
Bl: Bit,
Br: Bit,
Ul: Unsigned,
Ur: Unsigned,
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.
fn div(self, rhs: UInt<Ur, Br>) -> <UInt<Ul, Bl> as Div<UInt<Ur, Br>>>::Output
impl<Ur, Br> Div<UInt<Ur, Br>> for UTerm where
Br: Bit,
Ur: Unsigned,
Br: Bit,
Ur: Unsigned,
type Output = UTerm
The resulting type after applying the /
operator.
fn div(self, UInt<Ur, Br>) -> <UTerm as Div<UInt<Ur, Br>>>::Output
impl<U, B> Eq for UInt<U, B> where
B: Eq,
U: Eq,
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,
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,
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,
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>,
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>,
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
fn get_bit<IM>(
&self,
i: &UInt<Ui, Bi>
) -> <UInt<Un, Bn> as GetBit<UInt<Ui, Bi>>>::Output where
IM: InternalMarker,
&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,
Bn: Copy,
type Output = Bn
fn get_bit<IM>(&self, &UTerm) -> <UInt<Un, Bn> as GetBit<UTerm>>::Output where
IM: InternalMarker,
IM: InternalMarker,
impl<U, B> Hash for UInt<U, B> where
B: Hash,
U: Hash,
B: Hash,
U: Hash,
fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,
__H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<U, B> IsNotStaticOne for UInt<U, B> where
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
U: DimName + Unsigned,
[src]
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
U: DimName + Unsigned,
impl<A, B, C, D, E, F, G> IsNotStaticOne for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G> where
A: PartialEq<A> + Send + Copy + Sync + Any + Debug + Bit,
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
C: PartialEq<C> + Send + Copy + Sync + Any + Debug + Bit,
D: PartialEq<D> + Send + Copy + Sync + Any + Debug + Bit,
E: PartialEq<E> + Send + Copy + Sync + Any + Debug + Bit,
F: PartialEq<F> + Send + Copy + Sync + Any + Debug + Bit,
G: PartialEq<G> + Send + Copy + Sync + Any + Debug + Bit,
[src]
A: PartialEq<A> + Send + Copy + Sync + Any + Debug + Bit,
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
C: PartialEq<C> + Send + Copy + Sync + Any + Debug + Bit,
D: PartialEq<D> + Send + Copy + Sync + Any + Debug + Bit,
E: PartialEq<E> + Send + Copy + Sync + Any + Debug + Bit,
F: PartialEq<F> + Send + Copy + Sync + Any + Debug + Bit,
G: PartialEq<G> + Send + Copy + Sync + Any + Debug + Bit,
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,
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.
fn len(&self) -> <UInt<U, B> as Len>::Output
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>,
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
fn max(self, rhs: Ur) -> <UInt<U, B> as Max<Ur>>::Output
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>,
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
fn min(self, rhs: Ur) -> <UInt<U, B> as Min<Ur>>::Output
impl<U, B> Mul<B0> for UInt<U, B> where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
UInt * B0 = UTerm
type Output = UTerm
The resulting type after applying the *
operator.
fn mul(self, B0) -> <UInt<U, B> as Mul<B0>>::Output
impl<U, B> Mul<B1> for UInt<U, B> where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
UInt * B1 = UInt
type Output = UInt<U, B>
The resulting type after applying the *
operator.
fn mul(self, B1) -> <UInt<U, B> as Mul<B1>>::Output
impl<Ul, B, Ur> Mul<UInt<Ur, B>> for UInt<Ul, B0> where
B: Bit,
Ul: Unsigned + Mul<UInt<Ur, B>>,
Ur: Unsigned,
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.
fn mul(self, rhs: UInt<Ur, B>) -> <UInt<Ul, B0> as Mul<UInt<Ur, B>>>::Output
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>>,
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.
fn mul(self, rhs: UInt<Ur, B>) -> <UInt<Ul, B1> as Mul<UInt<Ur, B>>>::Output
impl<U, B> Mul<UTerm> for UInt<U, B> where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
UInt<U, B> * UTerm = UTerm
type Output = UTerm
The resulting type after applying the *
operator.
fn mul(self, UTerm) -> <UInt<U, B> as Mul<UTerm>>::Output
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UTerm, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UTerm, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UTerm, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UTerm, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>, B0>
[src]
impl<U, B> NamedDim for UInt<U, B> where
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
U: DimName + Unsigned,
[src]
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
U: DimName + Unsigned,
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UTerm, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UTerm, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>
[src]
impl<A, B, C, D, E, F, G> NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, A>, B>, C>, D>, E>, F>, G> where
A: PartialEq<A> + Send + Copy + Sync + Any + Debug + Bit,
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
C: PartialEq<C> + Send + Copy + Sync + Any + Debug + Bit,
D: PartialEq<D> + Send + Copy + Sync + Any + Debug + Bit,
E: PartialEq<E> + Send + Copy + Sync + Any + Debug + Bit,
F: PartialEq<F> + Send + Copy + Sync + Any + Debug + Bit,
G: PartialEq<G> + Send + Copy + Sync + Any + Debug + Bit,
[src]
A: PartialEq<A> + Send + Copy + Sync + Any + Debug + Bit,
B: PartialEq<B> + Send + Copy + Sync + Any + Debug + Bit,
C: PartialEq<C> + Send + Copy + Sync + Any + Debug + Bit,
D: PartialEq<D> + Send + Copy + Sync + Any + Debug + Bit,
E: PartialEq<E> + Send + Copy + Sync + Any + Debug + Bit,
F: PartialEq<F> + Send + Copy + Sync + Any + Debug + Bit,
G: PartialEq<G> + Send + Copy + Sync + Any + Debug + Bit,
impl NamedDim for UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UTerm, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>, B1>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>, B0>
[src]
impl NamedDim for UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>, B1>
[src]
impl<U, B> NonZero for UInt<U, B> where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
impl<U, B> Ord for UInt<U, B> where
B: Ord,
U: Ord,
B: Ord,
U: Ord,
fn cmp(&self, other: &UInt<U, B>) -> Ordering
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<Ul, Bl, Ur, Br> PartialDiv<UInt<Ur, Br>> for UInt<Ul, Bl> where
Bl: Bit,
Br: Bit,
Ul: Unsigned,
Ur: Unsigned,
UInt<Ul, Bl>: Div<UInt<Ur, Br>>,
UInt<Ul, Bl>: Rem<UInt<Ur, Br>>,
<UInt<Ul, Bl> as Rem<UInt<Ur, Br>>>::Output == UTerm,
Bl: Bit,
Br: Bit,
Ul: Unsigned,
Ur: Unsigned,
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
fn partial_div(
self,
rhs: UInt<Ur, Br>
) -> <UInt<Ul, Bl> as PartialDiv<UInt<Ur, Br>>>::Output
self,
rhs: UInt<Ur, Br>
) -> <UInt<Ul, Bl> as PartialDiv<UInt<Ur, Br>>>::Output
impl<Ur, Br> PartialDiv<UInt<Ur, Br>> for UTerm where
Br: Bit,
Ur: Unsigned,
Br: Bit,
Ur: Unsigned,
type Output = UTerm
The type of the result of the division
fn partial_div(
self,
UInt<Ur, Br>
) -> <UTerm as PartialDiv<UInt<Ur, Br>>>::Output
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>,
B: PartialEq<B>,
U: PartialEq<U>,
impl<U, B> PartialOrd<UInt<U, B>> for UInt<U, B> where
B: PartialOrd<B>,
U: PartialOrd<U>,
B: PartialOrd<B>,
U: PartialOrd<U>,
fn partial_cmp(&self, other: &UInt<U, B>) -> Option<Ordering>
fn lt(&self, other: &UInt<U, B>) -> bool
fn le(&self, other: &UInt<U, B>) -> bool
fn gt(&self, other: &UInt<U, B>) -> bool
fn ge(&self, other: &UInt<U, B>) -> bool
impl<U, B> Pow<UInt<U, B>> for isize where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = isize
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <isize as Pow<UInt<U, B>>>::Output
impl<U, B> Pow<UInt<U, B>> for i16 where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = i16
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <i16 as Pow<UInt<U, B>>>::Output
impl<U, B> Pow<UInt<U, B>> for f32 where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = f32
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <f32 as Pow<UInt<U, B>>>::Output
impl<U, B> Pow<UInt<U, B>> for i8 where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = i8
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <i8 as Pow<UInt<U, B>>>::Output
impl<U, B> Pow<UInt<U, B>> for u64 where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = u64
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <u64 as Pow<UInt<U, B>>>::Output
impl<U, B> Pow<UInt<U, B>> for u8 where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = u8
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <u8 as Pow<UInt<U, B>>>::Output
impl<U, B> Pow<UInt<U, B>> for i64 where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = i64
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <i64 as Pow<UInt<U, B>>>::Output
impl<U, B> Pow<UInt<U, B>> for usize where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = usize
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <usize as Pow<UInt<U, B>>>::Output
impl<U, B> Pow<UInt<U, B>> for u16 where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = u16
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <u16 as Pow<UInt<U, B>>>::Output
impl<U, B> Pow<UInt<U, B>> for f64 where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = f64
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <f64 as Pow<UInt<U, B>>>::Output
impl<U, B> Pow<UInt<U, B>> for u32 where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = u32
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <u32 as Pow<UInt<U, B>>>::Output
impl<U, B> Pow<UInt<U, B>> for i32 where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
type Output = i32
The result of the exponentiation.
fn powi(self, UInt<U, B>) -> <i32 as Pow<UInt<U, B>>>::Output
impl<U> PowerOfTwo for UInt<U, B0> where
U: Unsigned + PowerOfTwo,
U: Unsigned + PowerOfTwo,
impl PowerOfTwo for UInt<UTerm, B1>
impl<Ur, Br> Rem<UInt<Ur, Br>> for UTerm where
Br: Bit,
Ur: Unsigned,
Br: Bit,
Ur: Unsigned,
type Output = UTerm
The resulting type after applying the %
operator.
fn rem(self, UInt<Ur, Br>) -> <UTerm as Rem<UInt<Ur, Br>>>::Output
impl<Ul, Bl, Ur, Br> Rem<UInt<Ur, Br>> for UInt<Ul, Bl> where
Bl: Bit,
Br: Bit,
Ul: Unsigned,
Ur: Unsigned,
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>,
Bl: Bit,
Br: Bit,
Ul: Unsigned,
Ur: Unsigned,
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.
fn rem(self, rhs: UInt<Ur, Br>) -> <UInt<Ul, Bl> as Rem<UInt<Ur, Br>>>::Output
impl<U, B> Shl<B0> for UInt<U, B> where
B: Bit,
U: Unsigned,
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.
fn shl(self, B0) -> <UInt<U, B> as Shl<B0>>::Output
impl<U, B> Shl<B1> for UInt<U, B> where
B: Bit,
U: Unsigned,
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.
fn shl(self, B1) -> <UInt<U, B> as Shl<B1>>::Output
impl<U, B, Ur, Br> Shl<UInt<Ur, Br>> for UInt<U, B> where
B: Bit,
Br: Bit,
U: Unsigned,
Ur: Unsigned,
UInt<Ur, Br>: Sub<B1>,
UInt<UInt<U, B>, B0>: Shl<<UInt<Ur, Br> as Sub<B1>>::Output>,
B: Bit,
Br: Bit,
U: Unsigned,
Ur: Unsigned,
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.
fn shl(self, rhs: UInt<Ur, Br>) -> <UInt<U, B> as Shl<UInt<Ur, Br>>>::Output
impl<U, B> Shl<UTerm> for UInt<U, B> where
B: Bit,
U: Unsigned,
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.
fn shl(self, UTerm) -> <UInt<U, B> as Shl<UTerm>>::Output
impl<U, B> Shr<B0> for UInt<U, B> where
B: Bit,
U: Unsigned,
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.
fn shr(self, B0) -> <UInt<U, B> as Shr<B0>>::Output
impl<U, B> Shr<B1> for UInt<U, B> where
B: Bit,
U: Unsigned,
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.
fn shr(self, B1) -> <UInt<U, B> as Shr<B1>>::Output
impl<U, B, Ur, Br> Shr<UInt<Ur, Br>> for UInt<U, B> where
B: Bit,
Br: Bit,
U: Unsigned + Shr<<UInt<Ur, Br> as Sub<B1>>::Output>,
Ur: Unsigned,
UInt<Ur, Br>: Sub<B1>,
B: Bit,
Br: Bit,
U: Unsigned + Shr<<UInt<Ur, Br> as Sub<B1>>::Output>,
Ur: Unsigned,
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.
fn shr(self, rhs: UInt<Ur, Br>) -> <UInt<U, B> as Shr<UInt<Ur, Br>>>::Output
impl<U, B> Shr<UTerm> for UInt<U, B> where
B: Bit,
U: Unsigned,
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.
fn shr(self, UTerm) -> <UInt<U, B> as Shr<UTerm>>::Output
impl<U, B> StructuralEq for UInt<U, B>
impl<U, B> StructuralPartialEq for UInt<U, B>
impl<U, B> Sub<B0> for UInt<U, B> where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
UInt - B0 = UInt
type Output = UInt<U, B>
The resulting type after applying the -
operator.
fn sub(self, B0) -> <UInt<U, B> as Sub<B0>>::Output
impl<U> Sub<B1> for UInt<U, B0> where
U: Unsigned + Sub<B1>,
<U as Sub<B1>>::Output: Unsigned,
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.
fn sub(self, B1) -> <UInt<U, B0> as Sub<B1>>::Output
impl<U, B> Sub<B1> for UInt<UInt<U, B>, B1> where
B: Bit,
U: Unsigned,
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.
fn sub(self, B1) -> <UInt<UInt<U, B>, B1> as Sub<B1>>::Output
impl Sub<B1> for UInt<UTerm, B1>
UInt<UTerm, B1> - B1 = UTerm
type Output = UTerm
The resulting type after applying the -
operator.
fn sub(self, B1) -> <UInt<UTerm, B1> as Sub<B1>>::Output
impl<Ul, Bl, Ur> Sub<Ur> for UInt<Ul, Bl> where
Bl: Bit,
Ul: Unsigned,
Ur: Unsigned,
UInt<Ul, Bl>: PrivateSub<Ur>,
<UInt<Ul, Bl> as PrivateSub<Ur>>::Output: Trim,
Bl: Bit,
Ul: Unsigned,
Ur: Unsigned,
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.
fn sub(self, rhs: Ur) -> <UInt<Ul, Bl> as Sub<Ur>>::Output
impl<U, B> Unsigned for UInt<U, B> where
B: Bit,
U: Unsigned,
B: Bit,
U: Unsigned,
const U8: u8
const U16: u16
const U32: u32
const U64: u64
const USIZE: usize
const I8: i8
const I16: i16
const I32: i32
const I64: i64
const ISIZE: isize
fn to_u8() -> u8
fn to_u16() -> u16
fn to_u32() -> u32
fn to_u64() -> u64
fn to_usize() -> usize
fn to_i8() -> i8
fn to_i16() -> i16
fn to_i32() -> i32
fn to_i64() -> i64
fn to_isize() -> isize
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, N1, N2> AddLength<T, N2> for N1 where
N1: ArrayLength<T> + Add<N2>,
N2: ArrayLength<T>,
<N1 as Add<N2>>::Output: ArrayLength<T>,
N1: ArrayLength<T> + Add<N2>,
N2: ArrayLength<T>,
<N1 as Add<N2>>::Output: ArrayLength<T>,
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,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, Right> ClosedDiv<Right> for T where
T: Div<Right, Output = T> + DivAssign<Right>,
T: Div<Right, Output = T> + DivAssign<Right>,
impl<D1, D2> DimAdd<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Add<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Add<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Add<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Add<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Add<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn add(self, D2) -> <D1 as DimAdd<D2>>::Output
[src]
impl<D> DimAdd<Dynamic> for D where
D: DimName,
[src]
D: DimName,
impl<D1, D2> DimDiv<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Div<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Div<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Div<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Div<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Div<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn div(self, D2) -> <D1 as DimDiv<D2>>::Output
[src]
impl<D> DimDiv<Dynamic> for D where
D: DimName,
[src]
D: DimName,
impl<D1, D2> DimMax<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Max<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Max<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Max<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Max<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Max<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn max(self, D2) -> <D1 as DimMax<D2>>::Output
[src]
impl<D> DimMax<Dynamic> for D where
D: DimName,
[src]
D: DimName,
impl<D1, D2> DimMin<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Min<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Min<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Min<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Min<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Min<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn min(self, D2) -> <D1 as DimMin<D2>>::Output
[src]
impl<D> DimMin<Dynamic> for D where
D: DimName,
[src]
D: DimName,
impl<D1, D2> DimMul<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Mul<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Mul<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Mul<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Mul<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Mul<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn mul(self, D2) -> <D1 as DimMul<D2>>::Output
[src]
impl<D> DimMul<Dynamic> for D where
D: DimName,
[src]
D: DimName,
impl<D1, D2> DimNameAdd<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Add<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Add<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Add<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Add<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Add<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn add(self, D2) -> <D1 as DimNameAdd<D2>>::Output
[src]
impl<D1, D2> DimNameDiv<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Div<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Div<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Div<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Div<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Div<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn div(self, D2) -> <D1 as DimNameDiv<D2>>::Output
[src]
impl<D1, D2> DimNameMax<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Max<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Max<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Max<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Max<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Max<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn max(self, D2) -> <D1 as DimNameMax<D2>>::Output
[src]
impl<D1, D2> DimNameMin<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Min<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Min<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Min<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Min<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Min<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn min(self, D2) -> <D1 as DimNameMin<D2>>::Output
[src]
impl<D1, D2> DimNameMul<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Mul<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Mul<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Mul<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Mul<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Mul<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn mul(self, D2) -> <D1 as DimNameMul<D2>>::Output
[src]
impl<D1, D2> DimNameSub<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Sub<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Sub<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Sub<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Sub<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Sub<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn sub(self, D2) -> <D1 as DimNameSub<D2>>::Output
[src]
impl<D1, D2> DimSub<D2> for D1 where
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Sub<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Sub<<D2 as DimName>::Value>>::Output: NamedDim,
[src]
D1: DimName,
D2: DimName,
<D1 as DimName>::Value: Sub<<D2 as DimName>::Value>,
<<D1 as DimName>::Value as Sub<<D2 as DimName>::Value>>::Output: NamedDim,
type Output = <<<D1 as DimName>::Value as Sub<<D2 as DimName>::Value>>::Output as NamedDim>::Name
fn sub(self, D2) -> <D1 as DimSub<D2>>::Output
[src]
impl<D> DimSub<Dynamic> for D where
D: DimName,
[src]
D: DimName,
impl<T> From<T> for T
[src]
impl<X> Gcd<UTerm> for X where
X: Unsigned + NonZero,
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<A, B> IsEqual<B> for A where
A: Cmp<B> + IsEqualPrivate<B, <A as Cmp<B>>::Output>,
A: Cmp<B> + IsEqualPrivate<B, <A as Cmp<B>>::Output>,
type Output = <A as IsEqualPrivate<B, <A as Cmp<B>>::Output>>::Output
The type representing either True
or False
fn is_equal(self, rhs: B) -> <A as IsEqual<B>>::Output
impl<A, B> IsGreater<B> for A where
A: Cmp<B> + IsGreaterPrivate<B, <A as Cmp<B>>::Output>,
A: Cmp<B> + IsGreaterPrivate<B, <A as Cmp<B>>::Output>,
type Output = <A as IsGreaterPrivate<B, <A as Cmp<B>>::Output>>::Output
The type representing either True
or False
fn is_greater(self, rhs: B) -> <A as IsGreater<B>>::Output
impl<A, B> IsGreaterOrEqual<B> for A where
A: Cmp<B> + IsGreaterOrEqualPrivate<B, <A as Cmp<B>>::Output>,
A: Cmp<B> + IsGreaterOrEqualPrivate<B, <A as Cmp<B>>::Output>,
type Output = <A as IsGreaterOrEqualPrivate<B, <A as Cmp<B>>::Output>>::Output
The type representing either True
or False
fn is_greater_or_equal(self, rhs: B) -> <A as IsGreaterOrEqual<B>>::Output
impl<A, B> IsLess<B> for A where
A: Cmp<B> + IsLessPrivate<B, <A as Cmp<B>>::Output>,
A: Cmp<B> + IsLessPrivate<B, <A as Cmp<B>>::Output>,
type Output = <A as IsLessPrivate<B, <A as Cmp<B>>::Output>>::Output
The type representing either True
or False
fn is_less(self, rhs: B) -> <A as IsLess<B>>::Output
impl<A, B> IsLessOrEqual<B> for A where
A: Cmp<B> + IsLessOrEqualPrivate<B, <A as Cmp<B>>::Output>,
A: Cmp<B> + IsLessOrEqualPrivate<B, <A as Cmp<B>>::Output>,
type Output = <A as IsLessOrEqualPrivate<B, <A as Cmp<B>>::Output>>::Output
The type representing either True
or False
fn is_less_or_equal(self, rhs: B) -> <A as IsLessOrEqual<B>>::Output
impl<A, B> IsNotEqual<B> for A where
A: Cmp<B> + IsNotEqualPrivate<B, <A as Cmp<B>>::Output>,
A: Cmp<B> + IsNotEqualPrivate<B, <A as Cmp<B>>::Output>,
type Output = <A as IsNotEqualPrivate<B, <A as Cmp<B>>::Output>>::Output
The type representing either True
or False
fn is_not_equal(self, rhs: B) -> <A as IsNotEqual<B>>::Output
impl<T> LinalgScalar for T where
T: One<Output = T> + Add<T, Output = T> + Sub<T, Output = T> + 'static + Mul<T> + Copy + Div<T, Output = T> + Zero,
[src]
T: One<Output = T> + Add<T, Output = T> + Sub<T, Output = T> + 'static + Mul<T> + Copy + Div<T, Output = T> + Zero,
impl<N> Logarithm2 for N where
N: PrivateLogarithm2,
N: PrivateLogarithm2,
type Output = <N as PrivateLogarithm2>::Output
The result of the integer binary logarithm.
impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
[src]
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
impl<M, N> PartialDiv<N> for M where
M: Integer + Div<N> + Rem<N, Output = Z0>,
M: Integer + Div<N> + Rem<N, Output = Z0>,
type Output = <M as Div<N>>::Output
The type of the result of the division
fn partial_div(self, rhs: N) -> <M as PartialDiv<N>>::Output
impl<X, N> Pow<N> for X where
N: Unsigned,
X: Unsigned + PrivatePow<UInt<UTerm, B1>, N>,
N: Unsigned,
X: Unsigned + PrivatePow<UInt<UTerm, B1>, N>,
type Output = <X as PrivatePow<UInt<UTerm, B1>, N>>::Output
The result of the exponentiation.
fn powi(self, n: N) -> <X as Pow<N>>::Output
impl<T, Base> RefNum<Base> for T where
T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base>,
[src]
T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> Scalar for T where
T: PartialEq<T> + Copy + Any + Debug,
[src]
T: PartialEq<T> + Copy + Any + Debug,
impl<N, I, B> SetBit<I, B> for N where
N: PrivateSetBit<I, B>,
<N as PrivateSetBit<I, B>>::Output: Trim,
N: PrivateSetBit<I, B>,
<N as PrivateSetBit<I, B>>::Output: Trim,
type Output = <<N as PrivateSetBit<I, B>>::Output as Trim>::Output
fn set_bit<IM>(self, i: I, b: B) -> <N as SetBit<I, B>>::Output where
IM: InternalMarker,
IM: InternalMarker,
impl<N> SquareRoot for N where
N: PrivateSquareRoot,
N: PrivateSquareRoot,
type Output = <N as PrivateSquareRoot>::Output
The result of the integer square root.
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
fn is_in_subset(&self) -> bool
fn to_subset_unchecked(&self) -> SS
fn from_subset(element: &SS) -> SP
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
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.
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.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,